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 Developer plan that Tinybird prices from $25 a month. The invoice is driven by something the card barely mentions: the plan size you sit on. Tinybird sells always-on compute as a six-rung ladder from $25 to $799 a month, and reserves its $0.0002 per vCPU-second rate for burst above whatever that rung already includes. Storage and query count, the two things most teams budget for, barely move the number.

Correction, September 11, 2026: this teardown originally described Tinybird's Developer plan as a flat $49 a month for 0.5 vCPU. Tinybird's pricing page publishes two figures for that plan and does not reconcile them: the plan card carries a compute slider and loads showing $49 a month at the 0.5 vCPU position, while the plan comparison table below it lists Developer as "Starting at $25/month" with a compute range of 0.25 to 8 vCPUs (Tinybird pricing, checked September 11, 2026). Both figures are the vendor's own. The entry price is $25, not $49, and Developer is a sliding scale rather than a flat fee. The vCPU-second rate this page turns on, $0.0002, was re-verified against the same source on the same date and is unchanged, as were $0.058 per GB-month of storage and the $0.01, $0.10 and $0.016 per GB egress rates.

Correction, September 26, 2026: this teardown previously treated $0.0002 per vCPU-second as the price of always-on compute, and on that basis published "$518.40 per always-on vCPU per month" and a worked 30-day bill of $1,048.50 that was 99 percent compute. Tinybird's own documentation says otherwise: $0.0002 per second is an overage rate, charged only on usage that exceeds the vCPU allocation already included in your plan. In Tinybird's words, "if your plan includes 1 vCPU, you can consume 1 vCPU second per second without overage" (Tinybird Developer plan docs, checked September 26, 2026), and the pricing page labels that comparison row "vCPU overages" rather than compute (Tinybird pricing). Always-on vCPUs are bought as a plan size instead: Tinybird publishes six Developer sizes at $25, $49, $99, $199, $399 and $799 a month for 0.25, 0.5, 1, 2, 4 and 8 vCPUs. One always-on vCPU is therefore $99 a month on the S-1 size, and the worked bill below has been recomputed to $209.25. The conclusion that compute dominates the invoice survives, and so does the roughly 8x spread between a tuned and an over-provisioned footprint; the unit price and the lever are what change. Every rate quoted on this page was re-verified against both sources on September 26, 2026.

Quick answer

Tinybird (2026) sells always-on compute as a plan size and meters only what spills over it. On the Developer plan the six sizes are $25, $49, $99, $199, $399 and $799 a month for 0.25, 0.5, 1, 2, 4 and 8 vCPUs; storage is $0.058/GB/month above the 25 GB included, egress is $0.01/GB intra-cloud, and burst above your vCPU allocation is charged at $0.0002 per vCPU-second. So the number to budget is the rung, not the second-rate: one always-on vCPU is $99/month. A realistic mid-size embedded-analytics workload lands near $209/month, and roughly 95 percent of that is the compute rung, not storage. The lever that meaningfully cuts the bill is the rung itself: resize to your real duty cycle, which Tinybird applies instantly in self-service, and keep steady-state usage inside the allocation so you never pay overage. Optimizing storage or chasing query counts saves you almost nothing.

The meter that actually bills you

Most pricing pages want you to compare plan names. On Tinybird the plan name is most of the bill. A Developer plan is a fixed monthly fee for a fixed vCPU allocation, and Tinybird's own billing table for that plan lists five resources, not three (Tinybird Developer plan docs, 2026):

• vCPUs: a fixed monthly fee for the allocation you pick, plus $0.0002 per vCPU-second for usage that exceeds it.
• Storage: $0.058 per GB per month above the 25 GB included, same rate on every tier.
• Data transfer: $0.01/GB intra-cloud, $0.10/GB inter-cloud, $0.016/GB private networking.
• On-demand CPU: separate 64-core instances for populate and copy jobs, billed in credits per core per minute (0.0027 to 0.004 depending on region).
• LLM usage: the MCP and Explorations AI tools, with $100 of credits included per billing cycle and usage billed at cost above that.

Queries are unlimited on paid tiers. That is the tell, but it points somewhere different from where most write-ups take it. Because queries are free and the allocation is fixed, the size of your rung is the whole decision, and the per-second rate is the penalty for guessing that rung too small.

The number nobody prints is what an always-on vCPU actually costs. On the Developer ladder it is $99 a month, the S-1 size. The $0.0002 per-second rate does annualise to $0.72 an hour, $17.28 a day and $518.40 a month, but that is the price of a core you are borrowing on top of your allocation, not the price of one you own. Borrowing is capped as well: Tinybird documents burst to 3x your base on the S-1/4 through S-2 sizes and 2x on S-4 and above, with requests beyond that returning HTTP 429.

The plan ladder, decoded

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

The Developer plan is not a flat fee, and it is not a slider over a metered rate either. It is six discrete sizes, and Tinybird publishes every one of them:

The ladder is close to linear at roughly $100 per vCPU per month, which is about one fifth of what the same core costs at the overage rate. That gap is the whole game. The plan card loads showing $49 a month at the S-1/2 position while the comparison table quotes the S-1/4 floor of $25, which is why the same page appears to publish two Developer prices; both are rungs of this ladder. Resizing is instant and self-service in either direction up to 8 vCPUs, so the rung is a dial you are expected to turn, not a tier you commit to.

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, which is the S-2 rung.
• 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: Developer S-2, 2 vCPU = $199.00
• Storage: (150 GB minus the 25 GB included) x $0.058 = $7.25
• Egress: 300 GB x $0.01 = $3.00
• Total: $209.25/month

Compute is $199.00 of that, or 95.1 percent. Storage and egress together are $10.25. If you walked into this budgeting for storage and free queries, you still missed 95 percent of the invoice. If you budgeted it from the per-second rate, you overshot by a factor of five.

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

The reason Tinybird pricing surprises teams is that identical products land on very different rungs 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 which rung you sit on. 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 contrast is the useful part: Tinybird asks you to pick a compute size up front and penalises a low guess, so once the rung is right its invoice is mostly a fixed number.

The one lever that cuts the bill

Because 95 percent of the invoice is the compute rung, there is exactly one place to work, and two ways to work it:

1. Drop a rung. If your real duty cycle fits inside 1 vCPU rather than 2, moving from S-2 to S-1 takes compute from $199 to $99. That is $100/month, a 50 percent cut, and Tinybird applies the resize instantly in self-service. The ladder is coarse, so this lever moves in big steps rather than smoothly.
2. Halve per-query CPU time. Better sorting keys and materialized rollups let the same request rate fit in fewer threads, which is what makes a smaller rung survivable in the first place. It is not a saving on its own; it is what unlocks lever one.

The trap sits on the other side. If your steady state genuinely needs 2 vCPUs and you sit on S-1 to save $100, the excess is billed at $0.0002 per vCPU-second, and a full extra core held all month is $518.40. Undersizing costs more than oversizing. Everything else is noise: compressing storage saves cents, and reducing query count saves nothing, because queries are already unlimited.

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 push you onto a rung you only need for minutes a day.

If your usage pattern is spiky, size for the duty cycle and let burst absorb the peaks: the smaller Developer rungs burst to 3x their base before the overage meter starts. 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 read it in the right order. The plan card sells you a rung; the meter only bills what spills over it. Price your always-on footprint off the ladder at roughly $100 per vCPU per month, keep the $0.0002 per-second rate in mind as the cost of undersizing rather than the cost of running, and treat storage and query count as the rounding errors they are.

Math check: an always-on vCPU is $99/month on the Developer ladder, so a 2-vCPU steady workload is the $199 S-2 rung and a ~$209 bill that is 95 percent compute; the only 50 percent cut comes from dropping a rung, not from storage, and the $0.0002/second rate is what you pay for getting the rung too small.