POST JSON. Get instant time-series.
Telemetry without the time sink. Push raw JSON metrics, events, and webhooks over standard HTTPS. Query downsampled analytics in milliseconds and embed live customer charts in one line of HTML. Zero schemas, zero connection pools, and $0 write fees.
curl -X POST https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84 \
-H "Authorization: Bearer sec_live_..." \
-H "Content-Type: application/json" \
-d '{
,
,
}'Sub-millisecond writes. On-the-fly analytical queries.
Ingest JSON over standard HTTPS and query downsampled aggregations across millions of points in single-digit milliseconds—with zero schema maintenance.
curl -X POST https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84 \
-H "Authorization: Bearer sec_live_..." \
-H "Content-Type: application/json" \
-d '{
"speed_kmh": 88.4,
"engine_temp": 91.5,
"battery_pct": 84.0
}'// Standard native fetch without SDK dependencies
interface TelemetryPoint {
speed_kmh: number;
engine_temp: number;
battery_pct: number;
}
const point: TelemetryPoint = {
speed_kmh: 88.4,
engine_temp: 91.5,
battery_pct: 84.0
};
const res = await fetch("https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84", {
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",
headers={"Authorization": "Bearer sec_live_..."},
json={"speed_kmh": 88.4, "engine_temp": 91.5, "battery_pct": 84.0}
)// 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", new
{
speed_kmh = 88.4,
engine_temp = 91.5,
battery_pct = 84.0
});{
"status": "accepted",
"ingestedBytes": 48,
"pointsIngested": 3
}
Nested JSON objects flatten up to 5 levels into dot-notation 16-byte numeric series (fleet.truck-84.*) with zero DDL migrations. String IDs are ignored in extract mode to protect your 65,000-series/DB quota.
?mode=blob / both)
Append ?mode=blob to store raw JSON payloads verbatim (16 + N bytes), or ?mode=both to extract numeric metrics while archiving the full JSON event. Push up to 5,000-item batches via POST /databases/{id}/ingest.
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.*.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.*.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.*.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.*.speed_kmh", fn = "avg" } }
});
var data = await res.Content.ReadFromJsonAsync<JsonElement>();{
"interval": "5m",
"timestamps": [
1788624300000,
1788624600000,
1788624900000
],
"results": {
"avg_speed": {
"values": [84.2, 87.6, 88.4]
}
}
}
Query dot-notation series hierarchies using glob patterns (fleet.*.speed_kmh) without inverted tag-index bloat. Wildcard patterns aggregate across all matching series into a unified result vector in a single pass—or compare up to 16 distinct series or patterns side-by-side in a single queries[] array—scaling across fleet vehicles, sensor IDs, and service instances without index memory amplification.
Contiguous 16-byte columnar pages let AVX-512 SIMD vector instructions evaluate sums, averages, extrema (min/max), and value predicates in a single pass. Millions of data points aggregate on the fly in single-digit milliseconds without pre-computed rollups, materialized views, or background sync cron jobs.
Queries execute across dedicated parallel query workers. Request bursts queue asynchronously in memory, while client-side cancellations immediately terminate in-flight scans and release worker capacity.
curl -X GET https://fra1.timesinkdb.com/databases/42/series/fleet.truck-84.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.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.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<JsonElement>(
"/databases/42/series/fleet.truck-84.speed_kmh"
);
Console.WriteLine($"Current speed: {point.GetProperty("value").GetDouble()} km/h"); // 88.4 km/h{
"seriesKey": "fleet.truck-84.speed_kmh",
"type": "numeric",
"ts": 1788624900000,
"value": 88.4
}
Omitting from resolves the most recent value of any series in constant time O(1) from active in-memory buffers and segment headers without scanning historical blocks.
Dashboards, status badges, and edge services can poll live state directly over HTTPS with a compact 72-byte payload—eliminating the cost and sync complexity of a separate Redis cache.
Four core integration patterns over HTTPS
Ingest webhooks directly without intermediate workers.
Skip provisioning serverless lambdas or queue brokers just to parse Stripe, GitHub, Shopify, or Clerk events. Point provider webhooks directly at /databases/{databaseId}/webhooks/{webhookKey} to verify, decompose, and persist events in a single step.
- Validates HMAC signatures and replay windows natively at the database edge
- Extracts numeric & boolean fields into 16-byte metric series while
mode=botharchives the full raw JSON payload in.blob - Built-in retry deduplication (Last-Write-Wins) and configurable timestamp extraction keep aggregates accurate across duplicate deliveries
- for mission-critical webhooks
Stripe-Signature: t=1788624900,v1=9f83ac027b4d...{
"status": "accepted",
"webhookKey": "stripe",
"eventId": "evt_3Q9x82LkdIwHu7ix",
"pointsIngested": 3,
"ingestedBytes": 214
}
// Auto-extracted series (mode=both):
// webhooks.stripe.data.object.amount → 14900
// webhooks.stripe.data.object.amount_received → 14900
// webhooks.stripe.blob → {"id":"evt_3Q9x...","type":"payment_intent.succeeded",...}X-Hub-Signature-256: sha256=4f2a7b8e...{
"status": "accepted",
"webhookKey": "github",
"eventId": "95f1042b-cc78-11e3-81ab-4c9367dc0958",
"pointsIngested": 3,
"ingestedBytes": 242
}
// Auto-extracted series (mode=both):
// webhooks.github.pull_request.additions → 342
// webhooks.github.pull_request.deletions → 58
// webhooks.github.blob → {"pull_request":{"number":892,"action":"opened"}}X-Shopify-Hmac-SHA256: 7d9e2b1a8...{
"status": "accepted",
"webhookKey": "shopify-orders",
"eventId": "b54557e4-491b-4321-9032-9b8182910412",
"pointsIngested": 3,
"ingestedBytes": 232
}
// Auto-extracted series (mode=both):
// webhooks.shopify-orders.total_price → 149.50
// webhooks.shopify-orders.subtotal_price → 139.00
// webhooks.shopify-orders.blob → {"id":5928192849,"currency":"USD"}<iframe
src="https://fra1.timesinkdb.com/databases/42/series/api.checkout.requests.html?from=-24h&interval=5m&token=tok_ro_..."
class="w-full h-40 border-0"></iframe>Embed live SVG and HTML charts via URL extensions.
Skip building background rollup pipelines, Redis caches, and frontend charting libraries. Append .svg or .html to any /series/{seriesKey} or /query URL to render responsive, $0-egress charts directly from the database.
- Authenticate embeds with scoped read-only tokens (
tok_ro_...) or lightweight server-side proxy routes - On-the-fly downsampling across millions of data points
- Built-in dark/light themes (
?theme) and custom hex color palettes (?color) on all tiers - "Powered by TimesinkDB" badge on Sandbox & Starter; watermark-free whitelabeling on Pro+ and custom CNAME on Scale+
Keep your core application database fast and lean.
Keep PostgreSQL, MySQL, DynamoDB, and MongoDB focused on transactional state. Writing high-velocity telemetry directly from serverless functions bloats indexes, exhausts connection pools, and spikes latency. Offload operational metrics and JSON events to TimesinkDB over stateless fetch()—with zero connection poolers, zero cold-start stalls, and isolated write paths that never block on analytical queries.
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 })
});Stream microcontroller telemetry without binary drivers.
Push sensor readings directly from ESP32 microcontrollers, cellular gateways, and embedded Linux nodes over standard HTTPS—without bulky binary protocol drivers or stateful MQTT brokers. Built-in query-time Last-Write-Wins (LWW) deduplication automatically resolves duplicate cellular retries.
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}");How TimesinkDB compares
Operational metrics, direct SaaS webhook analytics (Stripe, GitHub, Shopify, Clerk), serverless & edge telemetry offloading, IoT device fleets (mTLS), and customer-facing SaaS dashboards with $0-egress HTML/SVG chart embeds—supporting up to 65,000 metric or JSON event series per database.
TimesinkDB is an append-only time-series and event store, not a relational OLTP database or SQL data warehouse. Pair it with PostgreSQL or MySQL for transactional tables, foreign keys, and multi-table JOINs, and export .csv / .json streams to ClickHouse, DuckDB, or BigQuery for petabyte-scale ad-hoc SQL warehousing.
Note: Latencies reflect server-side execution on regional AMD EPYC NVMe nodes, excluding client network RTT.
Predictable pricing. Zero per-database fees.
Pool capacity at the account level and split it freely across production, staging, and dev databases—with unlimited seats and $0 write fees.
Free Developer Sandbox Database
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.
Pro, Scale, Dedicated, and Custom plans ($35+/mo) pool storage, egress, and query workers at the account level. Carve out independent databases for production, staging, QA, and preview environments under a single invoice with zero per-database licensing fees.
Each database operates with its own dedicated storage engine, isolated NVMe storage partition, isolated parallel query workers, independent credentials, and an independent 65,000-series catalog. Database allocation requires a minimum of 10 GB storage, 5 GB egress, and 2 query workers. Pro plans support up to 6 databases (390k total series); Scale plans support up to 12 databases (780k total series).
Predictable raw byte accounting with deterministic sizing—no 1 KB block rounding, no hidden index multipliers, and $0.00 write ingestion fees.
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 indefinitely until retention rules or purges are configured.
Strict Spend Cap (default) pauses writes at 100% quota (HTTP 422) with 80% & 90% alerts while data stays 100% queryable. Optional Elastic Auto-Expand draws from unallocated account storage first ($0), then adds +20 GB plan blocks ($0.16–$0.30/GB) with zero downtime.
Customer-facing interactive HTML & SVG chart embeds (/databases/{databaseId}/series/{seriesKey}.html and .svg) consume 0 GB egress quota. Serve millions of customer dashboard views with unlimited fair-use bandwidth.
Server-side SIMD downsampling aggregates millions of stored points on the fly, transferring only compact bucketed responses. Under Strict Spend Cap, reaching 100% egress pauses raw .json/.csv responses (HTTP 422) while ingestion and $0 visual embeds continue. Optional Elastic Auto-Expand draws from unallocated account egress first ($0), then adds +25 GB monthly blocks ($2.00/mo).
Continuous numeric series (cpu_usage) and raw JSON event streams (webhooks.stripe) share a per-database catalog quota (1,000 Sandbox; 65,000 per database on paid plans—scaling to 390,000 across 6 DBs on Pro, 780,000 across 12 DBs on Scale, and unlimited total series on Dedicated Node).
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 unpredictable line items. 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.
Queries execute concurrently across dedicated Parallel Query Workers (4 Starter, 12 Pro, 24 Scale). Hardware-accelerated SIMD downsampling completes in single-digit milliseconds, allowing rapid worker turnover for concurrent UI widgets and API queries.
Parallel Query Workers govern analytical read concurrency only—POST write ingestion is never gated by query workers and commits to in-memory buffers in <1ms with zero HTTP 429 write throttling. Client cancellations immediately terminate in-flight scans and release worker slots.
Writes commit to in-memory columnar buffers in <1ms for peak ingestion throughput, flushing to NVMe storage in the background (≤60s RPO). Best for IoT sensor fleets, serverless offloads, and high-frequency metrics.
?requireCommit=true)
Confirms data is flushed to physical NVMe storage via a coalesced group-commit window (<1.5s) before returning HTTP 200 OK. Ideal for high-value transactional webhooks (Stripe payouts, Shopify orders) and strict audit logs. Standard on Pro, Scale, and Dedicated Node plans, and Custom plans from $35/mo.
Configure Custom Account Capacity
Scale storage, bandwidth, and concurrency freely split across your environments
High-speed NVMe storage with triple-replicated cloud resilience and automated checksum verification ($0.16–$0.30/GB tiered).
Bandwidth for programmatic JSON and CSV API queries at standard $0.08/GB. Interactive HTML & SVG chart embeds remain 100% free with unlimited fair-use.
Concurrent AVX-512 analytical execution pipelines at $0.80/worker-mo. Allocate 12+ workers to isolate heavy multi-month scans from live dashboards.
Dedicated Node Enterprise Isolation
Single-tenant host with 1 TB private NVMe storage, 1 TB monthly egress, uncapped query concurrency on dedicated CPU cores, and unlimited isolated databases (65,000 series/DB). Includes a contractual 99.95% SLA, full whitelabeling, direct Azure VNet peering, and mTLS / IP-allowlisted Anycast routing for AWS, GCP, and on-prem workloads.
Account Guarantees & Built-In Protections
Zero-Overage Spend Cap
Strict Spend Cap pauses writes at 100% storage and raw JSON/CSV queries at 100% egress (HTTP 422) while keeping reads and $0 chart embeds online. Optional Elastic Auto-Expand available.
$0.00 Write API Fees
Stream millions of metric points and webhook events with $0.00 write fees, zero batch surcharges, and no per-request billing.
Pooled Multi-DB Capacity
Split provisioned storage, egress, and query workers across dev, staging, QA, and production databases on Pro, Scale, and Custom plans with zero per-database fees.
Unlimited Seats & API Keys
Invite your entire team with $0 per-seat fees and issue unlimited scoped API and embed tokens across 65,000 series per database.
Unlimited Visual Chart Embeds
Interactive HTML and SVG chart embeds consume 0 GB of your monthly egress quota with unlimited fair-use views.
Zero Vendor Lock-In
Export complete datasets at any time in standard streaming CSV and JSON formats via the dashboard or REST API.
Engineered in Finland. Built for sovereign, lock-in-free telemetry.
TimesinkDB is built by Timesink Oy, an independent infrastructure company headquartered in Tampere, Finland. We build high-efficiency telemetry infrastructure backed by strict European data governance and predictable economics.
Sovereign Regional Data Residency
Customer telemetry stays strictly within your selected region (Frankfurt EU fra, N. Virginia US iad, or Tokyo APAC nrt) with zero cross-region replication, governed by Finnish law and GDPR Data Processing Agreements.
Strict Workload Isolation & 99.95% Availability SLA
Each database runs an isolated storage engine with dedicated query workers and hard resource quotas—backed by a contractual 99.95% availability SLA across all paid plans.
Open Data Standards & Instant Erasure
Query and export data in standard .csv and .json formats with zero proprietary dialects, and execute instant administrative series or database purges for GDPR Art. 17 compliance.
Low-Latency Edge Termination & Regional Routing
Cloudflare Anycast terminates TLS 1.3 and HTTP/3 at 300+ edge locations for zero-RTT session resumption, routing writes, analytical queries, and chart embeds over private backbone links to your regional database host (fra, iad, nrt).
Continuous Availability & NVMe Durability
Data persists across triple-replicated NVMe storage with automated 30-day recovery snapshots, combining sub-millisecond in-memory ingest with optional synchronous commit verification.
Need a specific deployment region?
In addition to standard service locations in Frankfurt (fra), Virginia (iad), and Tokyo (nrt), Dedicated Nodes can be provisioned in global cloud regions on order—including US West, Sweden, UK South, Singapore, or Australia East—with custom VNet peering and private routing.
Frequently Asked Questions
No credit card is required. Reserve your Free Developer Sandbox today—when the service launches on October 29, 2026, it provisions in under 10 seconds with 1 GB of NVMe storage, 1,000 active series, and 1 Parallel Query Worker, free forever.
Inactive sandboxes pause automatically and wake on your next HTTP request with all data intact. You can export your dataset at any time or upgrade in place to Starter ($10/mo), Pro ($35/mo), Scale ($85/mo), or Custom capacity without downtime.
On Pro, Scale, Dedicated Node, and Custom plans ($35+/mo), account capacity (NVMe storage, JSON/CSV egress, and Parallel Query Workers) is pooled across isolated databases with zero per-database fees and unlimited team seats. Each database allocates at least 10 GB storage, 5 GB egress, and 2 query workers. For example, a Pro account (80 GB storage, 40 GB egress, 12 workers) can assign 60 GB and 8 workers to production, 10 GB and 2 workers to staging, and 10 GB and 2 workers to dev under one invoice. Starter ($10/mo) includes 1 dedicated database (20 GB storage, 4 workers).
Yes. TimesinkDB charges $0.00 in per-request write fees across all plans. You pay only for your provisioned account plan (NVMe storage, monthly JSON/CSV egress, and parallel query workers)—whether you ingest 10 points or 100 million points.
Fixed plans operate under a Zero-Overage Spend Cap by default: if a database reaches 100% of provisioned storage, existing data remains intact and queryable while writes pause (422 StorageQuotaExceeded); if it reaches 100% of monthly egress, programmatic .json and .csv queries pause until the monthly reset (422 EgressQuotaExceeded) while ingestion (POST) and $0 fair-use .svg / .html embeds continue uninterrupted. Automated alerts trigger at 80% and 90% capacity.
For mission-critical production systems, you can enable Elastic Auto-Expand for storage and/or monthly egress in three stages:
- Free Pooled Reallocation: When a database reaches 100% of its limit, it first allocates any remaining unallocated capacity from your account's pooled plan at $0.00 extra charge.
- Marginal Block Increments: Once your account's pooled capacity is fully allocated, it expands automatically in +20 GB storage blocks (at your active tiered rate: $0.30, $0.24, or $0.16/GB) or +25 GB monthly egress blocks ($2.00/mo @ $0.08/GB) with zero downtime.
- Persistent Baseline & Downsizing: Expanded capacity becomes your new subscription baseline for future cycles until scaled down in the web console (after a 30-day minimum hold, taking effect at the next renewal).
Subscriptions are billed monthly or annually (2 months free). Mid-cycle upgrades and auto-expand increments take effect immediately, prorated for the remainder of your billing term at your active monthly or discounted annual rate. Cancellations and downgrades remain active through the end of your prepaid period with no penalties.
Storage is metered strictly on raw, uncompressed byte size—with no compression guesswork, hidden index multipliers, or block-rounding padding:
Under this deterministic accounting, a 20 GB allocation holds 1,250,000,000 numeric points. For example, a sensor reporting every 10 seconds generates ~259,200 points per month (~4.1 MB/month). Pairing fixed 16-byte sizing with $0.00 write fees lets you calculate exact retention capacity upfront without worrying about per-write ingestion charges or variable compression ratios.
A series is an immutable named metric or event stream (cpu_usage, temperature, or webhooks.stripe). Each isolated database includes 1,000 series on Sandbox or 65,000 series per database on paid plans—scaling across multi-database pools (up to 390k on Pro, 780k on Scale, and unlimited on Dedicated Nodes). Only the unique series key counts toward the limit; points and events appended to a series are unlimited up to your storage quota.
Retention defaults to infinite retention. You can configure day-level retention rules per series pattern (e.g. fleet.*: 14d, audit.*: 365d, or *: 90d) via PUT /databases/{databaseId}/retention/rules. Rules evaluate daily in the background and apply retroactively to existing data, sweeping expired blocks with zero read/write locks or vacuum stalls.
Query execution is powered by dedicated Parallel Query Workers (4 Starter, 12 Pro, 24 Scale). Because hardware-accelerated SIMD vectorization downsamples contiguous columnar pages directly in memory, analytical queries execute in single-digit milliseconds and workers turn over rapidly.
When concurrent requests exceed active worker capacity, incoming queries queue asynchronously in host memory and execute as worker slots clear. Queries enforce a 4.0-second execution timeout once data scanning begins (returning HTTP 408 QueryTimeoutExceeded).
Dedicated workers provide workload isolation: long-range analytical scans execute in dedicated queues without blocking real-time gauge lookups or embedded charts. Workers are cancellation-aware; client disconnections or closed tabs immediately terminate the scan and release the worker slot.
TimesinkDB provides two ingestion modes:
- Asynchronous Ingest (Default): Writes commit into in-memory columnar buffers in <1ms and immediately return
202 Accepted, flushing to NVMe storage in the background (≤60s RPO). Optimized for continuous telemetry, IoT fleets, and high-frequency metrics. - Synchronous Ingest (
?requireCommit=trueor webhook configuration): On Pro, Scale, Dedicated Node, and Custom plans (from $35/mo), callers can enforce physical on-disk persistence via a coalesced group-commit flush window (<1.5s) before returning200 OK. Built for transactional webhooks (Stripe, Shopify) and audit logs.
Both modes include automatic query-time Last-Write-Wins (LWW) deduplication: timestamps are normalized to 100-nanosecond tick resolution, and duplicate deliveries targeting the same (seriesKey, timestamp) coalesce deterministically on read without write-path index locking. For high-concurrency webhook streams where a provider supplies 1-second timestamps (such as Stripe's created field), setting tsProperty: "" assigns unique 100ns server arrival ticks so concurrent same-second events are preserved individually.
Yes. Scoped read-only tokens (tok_ro_...) permit chart and query reads while blocking all writes and admin actions—letting you embed browser iframes without exposing secret keys (or isolate tenants into separate databases on Pro+ plans).
Interactive .html and .svg chart embeds include unlimited fair-use views ($0.00 egress); egress quotas apply only to programmatic JSON and CSV queries. All plans support dark/light themes (?theme) and custom colors (?color), with watermark-free whitelabeling on Pro+ ($35+/mo) and custom CNAME domains on Scale+ ($85+/mo).
No. TimesinkDB uses open REST endpoints and standard export formats with no proprietary query language or lock-in. You retain full ownership of your telemetry data.
You can export complete datasets at any time via the web console or through REST API endpoints in standard streaming CSV (.csv) and JSON (.json) formats. Archive directly into object storage (Amazon S3, Azure Blob, Google Cloud Storage) or load historical exports into analytical query engines (DuckDB, Snowflake, BigQuery) without custom conversion pipelines.
For enterprise workloads requiring single-tenant isolation, the Dedicated Node plan ($349/mo or $3,500/yr) provisions a private compute host with 1 TB private NVMe storage, 1 TB monthly egress, and uncapped query concurrency on dedicated CPU cores (with optional per-DB worker caps). You can carve out unlimited isolated databases (65,000 series/DB) across dev, staging, and production with zero noisy neighbors.
For private and hybrid network topologies, Dedicated Nodes support direct Azure VNet peering alongside mTLS and IP-allowlisted Cloudflare Anycast routing for AWS, GCP, and on-premises networks.
Nodes deploy in Frankfurt (fra), N. Virginia (iad), or Tokyo (nrt), with additional regions (US West, Sweden, UK South, Singapore, Australia East) available on order.
All paid plans (Starter, Pro, Scale, Dedicated Node, and Custom) include a contractual 99.95% Availability SLA (less than 21.6 minutes of monthly downtime), backed by failover compute capacity, replicated NVMe storage volumes, Cloudflare Anycast edge routing, and built-in storage corruption detection and crash recovery. Free Sandbox databases operate on a best-effort basis with automatic idle sleep and instant wake-on-request.
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 as a service credit on your subsequent monthly renewal invoice). Detailed claim procedures and permitted exclusions are outlined in our Service Level Agreement terms.
It's an intentional double meaning. In telemetry architectures, an ingestion target is called a sink—TimesinkDB is a high-throughput sink for timestamped metrics and JSON events.
In practice, assembling traditional time-series pipelines (Kafka queues, connection poolers, schema migrations, and cardinality tuning) is a massive engineering time sink. We built TimesinkDB so you can POST JSON over HTTPS and get back to shipping your product.
Ready to get started with TimesinkDB?
Launching October 29, 2026. Pre-register to reserve your 1 GB Free Sandbox with zero credit card required—we send a single self-serve activation email on launch day with zero marketing drip or sales calls.