Tinybird Pricing in 2026: The Real 30-Day Bill Behind the vCPU-Second Meter

Tinybird's 2026 pricing looks cheap on the plan card and behaves like a compute bill in production. The plan card shows a free tier and a $49/month Developer plan. The invoice is driven by something the card barely mentions: vCPU-seconds. At the published overage rate of $0.0002 per vCPU-second, one vCPU held on around the clock costs $518.40 a month. Storage and query count, the two things most teams budget for, barely move the number.

Quick answer

Tinybird (2026) meters compute by the vCPU-second at $0.0002/second, plus $0.058/GB/month storage and $0.01/GB intra-cloud egress. The plan base ($49/month Developer, custom SaaS and Enterprise) buys you a compute allocation; the real bill scales with how many vCPUs your queries keep busy. Convert the second-rate to a monthly rate before you budget: one always-on vCPU is $17.28/day, $518.40/month. A realistic mid-size embedded-analytics workload lands near $1,050/month, and roughly 99 percent of that is compute, not storage. The only lever that meaningfully cuts the bill is vCPU-seconds: right-size always-on replicas and shrink per-query CPU time. Optimizing storage or chasing query counts saves you nothing.

The meter that actually bills you

Most pricing pages want you to compare plan names. Tinybird's real invoice ignores plan names once you are past the included allocation and bills three lines (figures from Tinybird's pricing page, 2026):

• Compute: $0.0002 per vCPU-second.
• Storage: $0.058 per GB per month, same on every tier.
• Egress: $0.01/GB intra-cloud, $0.10/GB inter-cloud, $0.016/GB private networking.

Queries are unlimited on paid tiers. That is the tell. When a vendor makes the thing you count (queries) free and meters the thing you cannot see (CPU time), your budget has to follow the CPU time.

The number nobody prints is the monthly cost of one vCPU. Here it is:

• Per second: $0.0002
• Per hour: $0.72
• Per day: $17.28
• Per 30-day month: $518.40

Write that on the wall. Every capacity decision you make on Tinybird is really a decision about how many of those $518.40 units you keep running.

The plan ladder, decoded

The tiers are compute-and-storage envelopes, not feature gates:

The Developer plan reads as a flat $49. In practice its 0.5 vCPU allocation is worth about $259/month of compute at the overage rate, so the $49 is a discounted floor, not the true unit cost. The moment your workload wants more than half a core held warm, you are buying vCPU-seconds at the metered rate, and that is where the bill leaves the plan card behind.

A worked 30-day bill

Take a B2B SaaS embedding Tinybird for customer-facing dashboards. Nothing exotic:

• Roughly 2 vCPUs held effectively always-on to keep p95 latency sane under concurrent dashboard loads.
• 150 GB of event data stored.
• 300 GB/month of query results served to customers in the same cloud region.

The 30-day math:

• Compute: 2 vCPU x $518.40 = $1,036.80
• Storage: 150 GB x $0.058 = $8.70
• Egress: 300 GB x $0.01 = $3.00
• Total: $1,048.50/month

Compute is $1,036.80 of that, or 98.9 percent. Storage and egress together are $11.70, close to a rounding error. If you walked into this budgeting for storage and free queries, you missed 99 percent of the invoice.

The meter-spread: same product, 8x the bill

The reason vCPU-second pricing surprises teams is that identical products land at wildly different bills depending on how much CPU their queries burn. Hold the workload above constant and vary only compute discipline:

That is an 8x spread on the same feature set, driven entirely by vCPU-seconds. Not one dollar of it comes from storing more data or running more queries. A team that never looks past the plan card cannot see this axis at all.

For contrast, ClickHouse Cloud, the open engine Tinybird is built on, meters compute on a similar pay-for-what-runs basis rather than a flat seat (ClickHouse Cloud pricing, 2026). The lesson generalizes: on managed real-time analytics, your invoice is a compute-time invoice wearing a plan-name costume.

The one lever that cuts the bill

Because 99 percent of the invoice is vCPU-seconds, there is exactly one place to work, and two ways to work it:

1. Stop holding replicas warm you do not need. Dropping from 2.0 always-on vCPU to a 1.3 average with scale-to-fit takes compute from $1,036.80 to $673.92. That is $362.88/month, a 35 percent cut, with zero feature loss.
2. Halve per-query CPU time. Better sorting keys and materialized rollups let the same request rate fit in fewer threads, which means fewer vCPUs held to hold latency. Same effect on the bill, from the other direction.

Everything else is noise. Compressing storage saves cents. Reducing query count saves nothing, because queries are already unlimited. Budget your engineering hours where the meter is: CPU time.

Where each side wins and loses

A compute-time meter is not automatically expensive; it just relocates the risk.

• You win when you serve high request volume over small-to-medium tables, where each query is cheap CPU. Unlimited queries plus a modest vCPU count is a genuinely good deal.
• You lose when you over-provision "just in case," or run heavy analytical scans at low request volume, where a few expensive queries still pin a full core you pay for by the second.

If your usage pattern is spiky, the always-on assumption is the trap. Model your real duty cycle, not your peak, before you commit to a SaaS tier. The same discipline applies to the observability and product-analytics bills next to it: see the Axiom pricing teardown, 2026 and the PostHog pricing teardown, 2026, where the meters hide in ingested GB and tracked events respectively.

Bottom line

Tinybird's 2026 pricing is honest once you translate it. The plan card sells you a floor; the meter sells you vCPU-seconds. Convert the second-rate to $518.40 per always-on vCPU per month, size your always-on footprint against your real duty cycle, and treat storage and query count as the rounding errors they are.

Math check: at $0.0002/vCPU-second, one always-on vCPU is $518.40/month, so a 2-vCPU steady workload is a ~$1,050 bill that is 99 percent compute; the only 35 percent-plus cut comes from holding fewer vCPUs, not from storage.