Turn raw JSON payloads into live dashboard charts in under 60 seconds. Get aggregations across millions of raw data points on the fly, without the time sink of schemas, drivers, or background pipelines.
curl -X POST https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84 \
-H "Authorization: Bearer sec_live_..." \
-d '{
,
,
}'Post any standard JSON payload. Numeric fields automatically become distinct columnar series without schemas or database migrations. Aggregate millions of raw data points on arrival with hardware-accelerated SIMD downsampling—keeping multi-widget customer dashboards responsive under heavy concurrent load without background data pipelines or caching layers.
curl -X POST https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry \
-H "Authorization: Bearer sec_live_..." \
-H "Content-Type: application/json" \
-d '{
"speed_kmh": 88.4,
"fuel_pct": 72.1,
"engine_temp": 91.5
}'// Standard native fetch without SDK dependencies
interface TelemetryPoint {
speed_kmh: number;
fuel_pct: number;
engine_temp: number;
}
const point: TelemetryPoint = {
speed_kmh: 88.4,
fuel_pct: 72.1,
engine_temp: 91.5
};
const res = await fetch("https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry", {
method: "POST",
headers: {
"Authorization": "Bearer sec_live_...",
"Content-Type": "application/json"
},
body: JSON.stringify(point)
});
const data = await res.json();import httpx
httpx.post(
"https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry",
headers={"Authorization": "Bearer sec_live_..."},
json={"speed_kmh": 88.4, "fuel_pct": 72.1, "engine_temp": 91.5}
)// Native HttpClient / System.Net.Http.Json
using var client = new HttpClient { BaseAddress = new Uri("https://fra1.timesinkdb.com") };
client.DefaultRequestHeaders.Authorization = new("Bearer", "sec_live_...");
var res = await client.PostAsJsonAsync("/databases/42/series/fleet.truck-84.telemetry", new
{
speed_kmh = 88.4,
fuel_pct = 72.1,
engine_temp = 91.5
});{
"status": "accepted",
"ingestedBytes": 48,
"pointsIngested": 3
}
Nested JSON payloads automatically flatten into dot-notation series names on arrival without DDL declarations or schema migrations. Every numeric field appends directly as a fixed 16-byte point into columnar storage. The ingest pipeline accepts individual writes as well as batch payloads up to 5,000 points per request via POST /databases/{databaseId}/ingest.
Specify ?mode=blob to capture arbitrary JSON payloads, webhook receipts, and diagnostic traces verbatim as raw blobs without schema extraction or parsing overhead. Events stream back chronologically via GET /databases/{databaseId}/series/{seriesKey}?from=-1h, preserving complete audit traces without operating a separate document store.
curl -X POST https://fra1.timesinkdb.com/databases/42/query \
-H "Authorization: Bearer sec_live_..." \
-H "Content-Type: application/json" \
-d '{
"range": { "from": "-1h", "to": "now" },
"interval": "5m",
"queries": [{ "id": "avg_speed", "seriesKey": "fleet.*.telemetry.speed_kmh", "fn": "avg" }]
}'const res = await fetch("https://fra1.timesinkdb.com/databases/42/query", {
method: "POST",
headers: { "Authorization": "Bearer sec_live_...", "Content-Type": "application/json" },
body: JSON.stringify({
range: { from: "-1h", to: "now" },
interval: "5m",
queries: [{ id: "avg_speed", seriesKey: "fleet.*.telemetry.speed_kmh", fn: "avg" }]
})
});res = httpx.post(
"https://fra1.timesinkdb.com/databases/42/query",
headers={"Authorization": "Bearer sec_live_..."},
json={
"range": {"from": "-1h", "to": "now"},
"interval": "5m",
"queries": [{"id": "avg_speed", "seriesKey": "fleet.*.telemetry.speed_kmh", "fn": "avg"}]
}
).json()// High-speed analytical downsampling in milliseconds
var res = await client.PostAsJsonAsync("/databases/42/query", new
{
range = new { from = "-1h", to = "now" },
interval = "5m",
queries = new[] { new { id = "avg_speed", seriesKey = "fleet.*.telemetry.speed_kmh", fn = "avg" } }
});
var data = await res.Content.ReadFromJsonAsync<QueryResponse>();{
"interval": "5m",
"timestamps": [
1788624300000,
1788624600000,
1788624900000
],
"results": {
"avg_speed": {
"values": [84.2, 87.6, 88.4]
}
}
}Query multidimensional hierarchies using glob patterns without high-cardinality index bloat. Hardware-accelerated SIMD vector downsampling aggregates millions of raw data points in single-digit milliseconds. Multi-tenant dimensions (sensor serials, fleet vehicles, microservice instances) scale with zero memory amplification or out-of-memory crashes.
Each database allocates dedicated query workers (4 to 24+). Bursty multi-panel dashboards execute concurrently in parallel worker lanes rather than failing with HTTP 429 rate limits. Because vector downsampling executes directly from columnar memory in single-digit milliseconds on the host, workers turn over immediately to keep end-user dashboards fluid and responsive.
Heavy multi-month analytical scans run isolated on their allocated workers without starving concurrent queries serving customer-facing charts or live operational gauges. The engine actively monitors client connection state: when a user closes a browser tab, refreshes a dashboard, or aborts an HTTP request, the in-flight scan immediately terminates and releases its worker back to the database.
curl -X GET https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry.speed_kmh \
-H "Authorization: Bearer sec_live_..."// Standard native fetch without an SDK or ORM
const res = await fetch(
"https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry.speed_kmh",
{ headers: { "Authorization": "Bearer sec_live_..." } }
);
const { value, ts } = await res.json();
console.log(`Current speed: ${value} km/h`); // 88.4 km/h# Standard HTTP request without a database SDK
import httpx
data = httpx.get(
"https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.telemetry.speed_kmh",
headers={"Authorization": "Bearer sec_live_..."}
).json()
speed = data["value"] # 88.4// Native HttpClient without third-party libraries or an ORM
var point = await client.GetFromJsonAsync<LatestValueResponse<double>>(
"/databases/42/series/fleet.truck-84.telemetry.speed_kmh"
);
Console.WriteLine($"Current speed: {point?.Value} km/h"); // 88.4 km/h{
"series": "fleet.truck-84.telemetry.speed_kmh",
"ts": 1788624900000,
"value": 88.4
}TimesinkDB keeps the latest point of every active stream in high-speed memory. Instant O(1) lookups deliver your latest readings in <1ms—letting live status indicators, IoT gauges, and health probes read directly from the database without waiting for disk scans.
Operational gauges, status cards, and edge microservices query live telemetry over standard HTTPS. With an 82-byte response footprint and <1ms in-memory server execution, frontends read live state directly from the database—eliminating the cost and sync headaches of running an auxiliary Redis cache.
Skip provisioning serverless lambdas just to extract metrics from Stripe, GitHub, or Shopify. Point webhooks directly to TimesinkDB with edge HMAC signature verification and declarative metric extraction.
Stripe-Signature: t=1788624900,v1=9f83ac027b4d...{
"seriesKey": "stripe.revenue.mrr",
"ts": "$.created",
"value": "$.data.object.amount / 100"
}X-Hub-Signature-256: sha256=4f2a7b8e...{
"seriesKey": "github.deploy.duration_seconds",
"ts": "$.deployment_status.created_at",
"value": "$.deployment_status.duration_ms / 1000"
}X-Shopify-Hmac-SHA256: 7d9e2b1a8...{
"seriesKey": "shopify.store.gmv",
"ts": "$.created_at",
"value": "$.total_price"
}<iframe
src="https://fra1.timesinkdb.com/databases/42/series/saas.tenant_42.api_calls.html?from=-24h&interval=5m&token=tok_ro_..."
class="w-full h-40 border-0"></iframe>
Avoid building background aggregation pipelines, Redis caches, and custom charting frontends. Issue scoped read-only tokens (tok_ro_...) and embed live interactive charts directly into your customer portal—turning telemetry into a revenue-driving product feature with one line of HTML.
Leave PostgreSQL, MySQL, DynamoDB, or MongoDB focused strictly on transactional application data. When ephemeral Lambdas and edge workers write high-velocity telemetry directly to primary databases, they bloat indexes, exhaust connection pools, and spike query latency. TimesinkDB offloads operational time-series over standard, stateless fetch()—no connection poolers (no PgBouncer), no table bloat, and no cold-start stalls.
await fetch('https://fra1.timesinkdb.com/databases/42/series/jobs.worker', {
method: 'POST',
headers: { Authorization: `Bearer ${env.TS_KEY}`, 'Content-Type': 'application/json' },
body: JSON.stringify({ duration_ms, memory_mb })
});ESP32s, cellular gateways, and Raspberry Pis struggle with bulky binary protocol drivers and heavy MQTT brokers over flaky connections. With TimesinkDB, if your device can make an HTTPS POST with JSON, you're done—complete with automatic retry deduplication.
http.begin("https://fra1.timesinkdb.com/databases/42/series/fleet.sensor_84");
http.addHeader("Authorization", "Bearer sec_live_...");
http.addHeader("Content-Type", "application/json");
http.POST("{\"temp\":21.8,\"battery_pct\":94.2}");Purchase predictable capacity at the account level and split it freely across production, staging, and dev databases—with unlimited team members, zero per-database fees, and $0 write charges.
Includes 1 dedicated Sandbox DB with 1 GB NVMe storage, 1 GB egress, 1,000 series, unlimited ingest, and 1 parallel query worker with instant wake-on-request. Ideal for testing webhooks, microservices, and rapid prototyping.
Capacity is purchased once at the account level and split freely across production, staging, QA, and preview environments with no per-database base fees and unlimited team seats.
Every database allocates a dedicated operational baseline: 10 GB storage, 5 GB egress, 2 query workers, 65,000 series. Staging spikes, dev testing, or batch exports never steal compute or stall production queries. Capacity pools freely across all your environments—Pro ($35/mo) accommodates up to 6 fully isolated databases, and Scale ($85/mo) accommodates up to 12 databases with zero per-database base fees.
Strict raw byte accounting with deterministic sizing—no 1KB block rounding and no hidden index multipliers.
Define day-granularity retention rules per series pattern (e.g. fleet.*: 14d, audit.*: 365d) applied retroactively daily in the background. Infinite retention by default preserves data until updated.
Strict Spend Cap pauses writes at 100% quota (HTTP 422) with 80% & 90% advance alerts while data remains 100% queryable. Optional Elastic Auto-Expand absorbs surges using unallocated account capacity first ($0 extra), only provisioning +20 GB blocks when your entire pool is exhausted.
Customer-facing interactive SVG chart embeds (/databases/{databaseId}/series/{seriesKey}.html) consume 0 GB egress quota. Serve millions of customer dashboard views with unlimited fair-use bandwidth.
Direct wholesale cloud bandwidth rate. Built-in SIMD downsampling returns only downsampled data points, slashing raw JSON transfer size by up to 95%.
Continuous numeric series (cpu_usage) and raw JSON event streams (webhooks.stripe) share the same quota (1,000 Sandbox; 65,000 on standard plans).
Only the unique series key counts toward the quota. Stream millions of points or event payloads into any registered series without consuming extra slots.
Ingest telemetry without per-request API fees, batch surcharges, or micro-transaction billing. Stream 10 points or 100 million points without counting API calls.
Writes commit to memory immediately so callers never block. Query-time Last-Write-Wins (LWW) deduplication handles webhook and network retries automatically without write locks.
POST /databases/{databaseId}/ingest with identical $0.00 write fees.
No artificial per-second or per-minute rate throttling. Queries execute concurrently across dedicated Parallel Query Workers (4 Starter, 12 Pro, 24 Scale). Because hardware-accelerated SIMD downsampling completes in single-digit milliseconds, workers turn over immediately, allowing concurrent UI widgets and analytical queries to resolve without throttling stalls.
Heavy multi-month analytical scans run isolated on their own workers without starving instant gauge lookups or customer charts. Cancelled browser tabs immediately release worker slots.
Writes commit to high-speed memory in <1ms for peak throughput, persisting to NVMe storage in the background. Best for IoT sensor fleets and high-frequency metrics.
?requireCommit=true)
Confirms data is safely written to physical NVMe storage before answering 200 OK. Ideal for mission-critical webhooks (Stripe payouts, Shopify orders) and strict audit compliance. Unlocks on Pro+.
Scale storage, bandwidth, and concurrency freely split across your environments
High-speed NVMe storage with triple-replicated cloud resilience and automated checksum verification. Tiered: $0.30/GB (≤50GB) • $0.24/GB (51–250GB) • $0.16/GB (>250GB).
Bandwidth for analytical API queries at standard $0.08/GB. Interactive SVG chart embeds remain 100% free with unlimited fair-use.
Dedicated parallel query workers ($0.80/worker). Each worker processes hardware-accelerated analytical scans concurrently. Allocating 12+ workers isolates heavy multi-month scans from real-time customer dashboards without queuing delays or throttling.
Single-tenant dedicated hardware host, 1 TB private NVMe storage pool, uncapped query concurrency, contractual 99.95% Availability SLA with priority escalation, private cloud network peering (Azure VNet peering, with Cloudflare Anycast edge routing connecting external workloads from AWS, GCP, or on-premises networks), and unlimited provisioned databases. Physical hardware isolation without noisy neighbors and complete whitelabeling.
Writes safely capped at quota (HTTP 422) with 80% & 90% alerts. Existing data remains 100% queryable. Optional Elastic Auto-Expand.
Stream millions of data points and webhook events with $0.00 write transaction fees, zero batch surcharges, or micro-transactions.
Split provisioned NVMe storage, egress, and query workers freely across dev, staging, QA, and prod with zero per-database base fees.
$0 per-seat fees. Invite your entire engineering team and generate unlimited scoped machine tokens across up to 65,000 active series.
Customer-facing SVG chart embeds (/databases/{databaseId}/series/{seriesKey}.svg) consume 0 GB egress quota with unlimited fair-use views.
Export complete datasets at any time in open Apache Parquet and streaming JSON formats via 1-click dashboard or REST APIs.
TimesinkDB is engineered by Timesink Oy, an independent infrastructure company headquartered in Tampere, Finland. We eliminate the operational overhead and vendor lock-in of legacy TSDBs by pairing sovereign European data residency with open Apache Parquet exports, zero-allocation engine speed, and transparent fixed pricing.
European customer telemetry remains strictly within European borders. Governed under Finnish legal jurisdiction with comprehensive Data Processing Agreements (DPAs) that safeguard operational metrics from extraterritorial legal claims and third-party jurisdiction conflicts.
Zero noisy-neighbor contention. Each database operates with dedicated parallel query workers and an isolated embedded engine partition with fixed resource quotas, backed by a contractual 99.95% availability SLA across all paid plans.
Retain total ownership of your telemetry. Stream historical archives out on demand via 1-click downloads or automated REST endpoints in open Apache Parquet and newline-delimited JSON—without proprietary wrappers or egress surcharges.
germanywestcentral
•
Latency: <15ms EU
•
GDPR DPA & Finnish Jurisdiction
eastus2
•
Latency: <10ms US East
•
Triple-Replicated NVMe
japaneast
•
Latency: <8ms APAC
•
Triple-Replicated NVMe
Cloudflare Anycast terminates TLS at the nearest edge PoP for instant connection setup, routing traffic across private backbones to regional nodes.
Sub-millisecond writes commit to memory and persist automatically to direct NVMe storage, backed by automated snapshots and zero noisy neighbors.
In addition to standard clusters in Frankfurt, Virginia, and Tokyo, Dedicated Nodes can be provisioned in any Azure region worldwide—including US West (westus2), Sweden (swedencentral), UK (uksouth), Singapore (southeastasia), or Australia (australiaeast)—with custom VNet peering and private routing.
No credit card is required. The Free Developer Sandbox is free forever and provisions in under 10 seconds with 1 GB of NVMe storage, 1,000 active series, and 1 Parallel Query Worker. You can immediately test cURL ingestion, webhooks, and downsampling queries with no setup friction.
Inactive sandboxes pause automatically to conserve resources and wake instantly on your next HTTP request with all data intact. Data is preserved indefinitely within your 1 GB storage quota. You can export your dataset at any time or upgrade seamlessly to Starter ($10/mo), Pro ($35/mo), Scale ($85/mo), or Custom capacity without interruption.
Capacity (NVMe storage, JSON egress, and parallel query workers) is purchased at the account level and pooled across all your databases with no per-database base fees and unlimited seats ($0 per user or machine API key) on Pro, Scale, Dedicated, and Custom plans (Starter is single-database only). To guarantee rock-solid performance isolation across environments, each database allocates a minimum operational baseline of at least 10 GB storage, 5 GB egress, and 2 query workers—ensuring staging spikes never impact production. For example, a Pro plan (80 GB / 40 GB / 12w) comfortably accommodates up to 6 fully isolated databases under a single consolidated invoice.
Yes. TimesinkDB charges $0.00 in per-request write ingestion fees across all plans. Unlike traditional platforms that bill per million requests or write units (such as InfluxDB, AWS CloudWatch, or Datadog), you pay strictly for provisioned storage and outbound analytical JSON egress. Stream 10 points or 100 million points without counting API calls or paying micro-transaction surcharges.
Fixed plans operate under a Zero-Overage Spend Cap by default. If your database reaches 100% of its provisioned storage, existing data remains 100% intact and queryable, while incoming writes are safely capped (returning HTTP 422 Storage Quota Exceeded)—preventing unexpected overage charges. Automated email/webhook alerts trigger at 80% and 90% capacity to provide ample advance notice.
For mission-critical production systems that cannot tolerate write interruptions, you can toggle Elastic Auto-Expand: the database first absorbs surges using any unallocated pooled capacity remaining in your account plan at $0 extra charge. If all pooled capacity is exhausted, it automatically provisions a +20 GB storage block on your account.
Subscriptions are billed monthly or annually (with 2 months free / ~17% discount). Upgrades take effect immediately with prorated billing, and cancellations or downgrades remain fully active until the end of your prepaid period with no cancellation penalties.
Storage is metered strictly on raw, auditable byte size with deterministic sizing—no compression guesswork, hidden index multipliers, or block-rounding padding:
Under this deterministic accounting, a standard 20 GB allocation holds exactly 1,250,000,000 numeric points. For example, a telemetry sensor reporting every 10 seconds generates ~259,200 points per month, consuming only ~4.1 MB of storage per month. Engineering teams can calculate their exact steady-state retention footprint on a napkin before writing a single line of code.
A series is an immutable named metric or event stream (cpu_usage, temperature, or webhooks.stripe) mapped in the registry as Numeric or Blob. Databases include 1,000 series (Sandbox) or 65,000 series (Starter, Pro, Scale, Custom). Crucially, only the unique series key counts toward the limit—points and events appended to a series are unlimited up to your provisioned storage capacity.
Retention defaults to infinite retention (preserving all data until manually purged). You can configure granular day-level retention rules per series pattern (e.g. fleet.*: 14d, audit.*: 365d, or fallback *: 90d) via PUT /databases/{databaseId}/retention/rules. Retention is evaluated daily in the background and applies retroactively to already ingested data, automatically sweeping expired historical points without maintenance scripts or database locks.
TimesinkDB never artificially limits your query rate with arbitrary per-second or per-minute throttling. Instead, analytical throughput is powered by dedicated Parallel Query Workers executing at memory-bus speeds.
With SIMD vectorization downsampling contiguous columnar pages at memory-bus speeds, analytical queries execute in single-digit milliseconds across dedicated workers. When request bursts exceed provisioned capacity, queries await worker availability asynchronously and execute immediately as workers free up—requests are never dropped or throttled with HTTP 429 errors.
The core architectural benefit of dedicated workers is workload isolation: heavy multi-month analytical scans run isolated on their own workers without starving real-time dashboard widgets, live gauge lookups, or customer charts. Furthermore, query workers are cancellation-aware: when users refresh or close dashboard tabs, cancelled requests immediately yield their worker slot so waiting queries execute without delay.
TimesinkDB provides two ingestion modes:
202 Accepted, persisting to NVMe storage in the background. Optimized for continuous telemetry, IoT fleets, and high-frequency metrics.?requireCommit=true): On Pro, Scale, Dedicated, and Custom plans, callers can enforce physical on-disk persistence before returning 200 OK (Zero RPO). Critical for high-value webhooks (Stripe, Shopify) and strict audit compliance.Both modes include automatic query-time deduplication: duplicate requests from retried webhooks or network hiccups are ingested immediately without performance degradation. If two writes target the same series with an identical timestamp, the latest write wins, replacing the prior value without double-counting.
Yes. You generate restricted read-only tokens (tok_ro_...) scoped strictly to specific series keys and time ranges. They are 100% safe to embed in client-facing iframes, mobile applications, or customer portals with zero risk of write mutation or administrative account access.
Crucially, interactive SVG chart embeds (/databases/{databaseId}/series/{seriesKey}.html) include unlimited fair-use views ($0.00 egress) across all plans. Customer dashboard views never consume your monthly analytical JSON query egress allowance. Charts include subtle attribution on Sandbox and Starter, complete whitelabeling with custom themes on Pro, and custom CNAME domains (metrics.yourdomain.com) on Scale+.
Never. TimesinkDB guarantees 100% data portability with zero vendor lock-in. You always own your telemetry outright.
You can export complete datasets at any time via 1-click downloads directly from the web console or through automated REST APIs in open Apache Parquet and standard streaming JSON formats. Seamlessly back up into cold cloud storage (Amazon S3, Azure Blob, Google Cloud Storage) or load historical archives into analytical query engines (DuckDB, Snowflake, BigQuery) without proprietary ETL gymnastics.
For enterprise workloads requiring physical single-tenant isolation, the Dedicated Node plan ($349/mo or $3,500/yr) provisions a private, single-tenant compute host (Azure VM with private NVMe storage volume) with zero noisy neighbors, uncapped query concurrency, a 1 TB private NVMe storage pool, and 1 TB monthly egress. You can carve out unlimited isolated databases across dev, staging, and production on that dedicated host.
For secure private network topologies, Dedicated Nodes support direct Azure VNet peering for low-latency internal connectivity, alongside Cloudflare Anycast edge routing connecting external workloads from AWS VPCs, Google Cloud Platform, or on-premises enterprise networks without public internet traversal.
Dedicated Nodes can be provisioned in Europe (Frankfurt germanywestcentral), North America (N. Virginia eastus2), or Asia-Pacific (Tokyo japaneast). Additional Azure regions (including westus2, swedencentral, uksouth, southeastasia, or australiaeast) are available on order. Contact our engineering team to coordinate custom network peering and regional placement.
All paid plans (Starter, Pro, Scale, Dedicated Node, and Custom) include a contractual 99.95% Availability SLA (allowing less than 21.6 minutes of total monthly downtime). This is backed at the infrastructure level by automated Azure Capacity Reservations, triple-replicated NVMe storage volumes, Cloudflare Anycast edge routing, and automated deployment pipelines that eliminate manual operator error. In addition, the TimesinkDB storage engine features built-in corruption detection and fast crash recovery. Free Sandbox databases operate on a best-effort basis without a contractual SLA, featuring automatic idle sleep and instant on-demand wake.
System availability is tracked 24/7 by independent, multi-region synthetic health probes probing ingestion and query endpoints across North America, Europe, and Asia. If monthly availability falls below 99.95%, paying accounts are eligible for graduated invoice service credits (10% to 50% credit applied directly to their subsequent monthly renewal invoice via Paddle). Detailed claim procedures and permitted exclusions are outlined in our Service Level Agreement terms.
It's an intentional double meaning. In telemetry pipelines, an ingestion endpoint is known as a sink—TimesinkDB is an ultra-fast ingestion sink for timestamped columnar data.
Practically, building traditional time-series stacks (Kafka queues, connection poolers, schema migrations, and high-cardinality index tuning) felt like an endless time sink. We built TimesinkDB so you can POST JSON over HTTPS and get back to shipping your actual product.
Launching October 2026. Join the early access waitlist to reserve your 1 GB Free Sandbox with zero credit card required.