Serverless Databases Compared: What They Cost in 2026

A serverless database costs the least when your app sits idle, and the most when it runs all day. That single fact decides most purchases. A hobby app can run free on Neon, Turso or Cloudflare D1. An always-on SaaS can pay about twice as much on Aurora as on Neon for the same memory, before any I/O charges.

This guide compares the main serverless databases using their own pricing pages from October 2026. It then runs the numbers for two workloads and flags the billing traps. Always confirm prices on the vendor page before you commit, because they change often.

Key takeaways

• Scale-to-zero databases cost the least when an app sits idle, and the gap narrows when it runs all day.
• Neon, Turso and Cloudflare D1 offer real free tiers. Aurora and PlanetScale lean toward provisioned pricing.
• Our model puts a hobby app near $1.15 a month on Neon Launch and an always-on SaaS near $45.69.
• Storage keeps billing while compute sleeps, so delete what you do not need.

What is a serverless database?

A serverless database is a managed database that bills by usage and adjusts its capacity automatically, instead of charging for a fixed server. Some also scale to zero, which means compute shuts off when no queries arrive and you pay nothing for it.

Scale to zero is the feature that matters for small apps. Neon's pricing page says that compute "suspends automatically after inactivity" and that no compute hours accrue while it is suspended. Storage still costs money while compute sleeps.

Not every product sold as serverless works this way. Some bill by provisioned capacity and call it serverless because you skip server management. The comparison below separates the two groups.

How do Neon, Aurora, Turso, D1 and PlanetScale compare?

Neon, Turso and D1 offer scale-to-zero or usage billing with real free tiers. Aurora Serverless bills per capacity unit with a 0.5 ACU minimum. PlanetScale starts at a fixed monthly price. The table below lists what each vendor's pricing page states.

Service	Engine	Entry price	Compute billing	Storage billing
Neon	Postgres	Free, then pay as you go	$0.106 per CU-hour (Launch), $0.222 (Scale)	$0.35 per GB-month
Turso	SQLite (libSQL)	Free; Developer $4.99/mo	Rows read and written	5 GB free; 9 GB on Developer
Cloudflare D1	SQLite	Free	Rows read and written	5 GB free; $0.75 per GB-month beyond
Amazon Aurora Serverless	Postgres, MySQL	Free plan, then pay as you go	$0.12 per ACU-hour (Standard)	$0.10 per GB-month plus I/O
PlanetScale	Postgres, Vitess	From $5/mo (Postgres, single node)	Fixed plan	Billed separately

Sources: the pricing pages for Neon, Turso, Cloudflare D1, Amazon Aurora and PlanetScale.

Neon

Neon is a serverless Postgres service. Its Free plan gives each project 100 compute-hours and 1 GB of storage, with up to 2 CU (8 GB RAM) of autoscaling. Free compute suspends after five idle minutes and you cannot change that. Launch lets you disable suspension. Scale lets you set the timer from one minute to always on.

Turso and Cloudflare D1

Turso is a hosted service built on libSQL, a fork of SQLite. Its Free plan allows 100 databases, 5 GB of storage, 500 million rows read and 10 million rows written each month. The Developer plan costs $4.99 per month and the Scaler plan costs $24.92 per month.

Cloudflare D1 is Cloudflare's serverless SQLite database. The free tier allows 5 million rows read and 100,000 rows written per day. Free users get no overage billing, so queries fail once a daily limit is reached and resume after 00:00 UTC. Paid usage adds $0.001 per million rows read beyond the included allowance and $1.00 per million rows written.

Aurora Serverless and PlanetScale

Amazon Aurora Serverless is AWS's auto-scaling version of Aurora. The pricing page lists $0.12 per ACU-hour for Standard and $0.156 for I/O-Optimized in US East (N. Virginia), and it says the minimum capacity you can set is 0.5 ACU. A free plan covers up to 4 ACUs and 1 GiB of storage per cluster.

PlanetScale now sells Postgres and Vitess. Its Postgres entry price is $5 per month for a single node with 1/16 vCPU and 512 MiB of memory. The Vitess entry is $39 per month on three nodes. The pricing page does not describe scale-to-zero, so treat PlanetScale as fixed-price managed hosting.

CockroachDB

CockroachDB's current pricing page lists a Standard edition at $0.092 per vCPU-hour and says billing follows what you provision and store, not how much you query. Idle clusters are therefore billed. Older articles describe a free serverless tier, but the page we read no longer shows one. It offers a 30-day trial with $400 in credit.

What does each option really cost? A two-workload model

For a hobby app, Neon Launch costs about $1.15 a month and Aurora about $1.90. For an always-on small SaaS, Neon Launch costs about $45.69 and Aurora about $89.60, before I/O. The model uses vendor list prices and equal memory.

We analyzed 2 workloads, using list prices copied from each vendor page on October 9, 2026:

• Hobby app: active 30 hours a month at 1 GB of memory, with 1 GB of data.
• Small SaaS: always on at 2 GB of memory, with 20 GB of data.

Here is the arithmetic. Neon defines 1 CU as 4 GB of memory, so 1 GB is 0.25 CU. Aurora's 1 ACU holds about 2 GiB, so 1 GB needs 0.5 ACU, which is also the minimum.

Line item	Neon Launch	Aurora Standard
Hobby compute	30 h × 0.25 CU × $0.106 = $0.80	30 h × 0.5 ACU × $0.12 = $1.80
Hobby storage (1 GB)	$0.35	$0.10
Hobby total	$1.15	$1.90
SaaS compute	730 h × 0.5 CU × $0.106 = $38.69	730 h × 1 ACU × $0.12 = $87.60
SaaS storage (20 GB)	$7.00	$2.00
SaaS total	$45.69	$89.60

Turso's Scaler plan costs a flat $24.92 and includes 24 GB. It runs SQLite, not Postgres, so it answers a different need. Neon Free and Turso Free cover the hobby case for $0.

What the model leaves out

Aurora Standard also charges $0.20 per million I/Os, so the real Aurora bill rises with traffic. I/O-Optimized removes that charge but raises the ACU rate to $0.156. Neither model counts egress, backups or branches. Treat the numbers as a floor, not a quote.

Estimate your own bill in five steps

You can repeat this model for any app in ten minutes. Consider a nightly reporting tool, for example, that wakes for two hours a day.

1. Count active hours. Add up the hours your app actually queries the database each month.
2. Pick a memory size. Match it to your working set. A 1 GB working set fits 0.25 CU on Neon or 0.5 ACU on Aurora.
3. Multiply by the compute rate. Hours × capacity units × price per unit-hour.
4. Add storage. Gigabytes × the monthly storage price, charged for every hour of the month.
5. Add the extras. Include I/O on Aurora, rows read on Turso and D1, and egress everywhere.

For the reporting tool, 60 active hours at 0.25 CU on Neon Launch comes to 15 CU-hours, or about $1.59, plus storage. A fixed $5 plan, such as PlanetScale's entry Postgres tier, would cost about three times as much as that compute line.

Which free tier lasts longest?

Turso's free tier is the roomiest for storage and reads. Neon's is the most forgiving for Postgres users. D1's free tier has hard daily caps. Aurora's free plan is the most limited in storage.

The "at the limit" row matters most. D1 fails queries when you hit the daily limit. Neon's free compute stops when you exhaust 100 compute-hours. Turso's overage is off by default on the free plan. A surprise outage costs more than a surprise $3 bill, so read this row before you launch.

Which billing traps catch people?

Storage keeps billing while compute sleeps, always-on workloads erase the scale-to-zero discount, and per-row pricing punishes unindexed queries. Check each before choosing.

1. Idle storage. Neon charges $0.35 per GB-month whether or not compute runs. Delete old branches and data.
2. Cold starts. Compute that sleeps must wake. The first query after a quiet period can be slower. Test your own latency, because vendors quote their own best numbers.
3. Row-based pricing. Turso and D1 bill by rows read. A query without an index reads every row. Our test on a two-million-row table showed an index cut one lookup from 31 ms to 0.09 ms in PostgreSQL, and the same habit saves money on row billing.
4. Provisioned billing in disguise. CockroachDB and PlanetScale bill for capacity you reserve.
5. Free-tier cliffs. Daily caps and one-week pauses on competing platforms can take a live app offline.

Which serverless database should you pick?

Pick Neon for Postgres with scale-to-zero, Turso or D1 when SQLite is enough, and a provisioned plan when traffic is steady. The chart below turns that into three questions.

Use these rules of thumb:

• Side project or prototype: Neon Free or Turso Free. Zero cost, and migration is easy early.
• Postgres features needed: Neon. You get extensions, transactions and standard drivers.
• Edge or per-tenant databases: Turso. The free plan allows 100 databases.
• App already on Cloudflare Workers: D1. It sits next to your code.
• Steady, high traffic: compare provisioned capacity against usage billing. Always-on workloads often cost less on a fixed plan.

How do cold starts and connections affect real apps?

Scale-to-zero trades a slower first query for a lower bill. When compute sleeps, the next request must wake it, and your user waits. Test this on your own region and driver, because vendors quote their own best figures.

Connections need care as well. Serverless functions open many short-lived connections, and a Postgres server has a limited pool. Use the vendor's pooled connection string when it offers one, and keep queries short so compute can return to idle sooner.

Idle settings change the bill. Neon's pricing page lists free compute as always suspending after five minutes, Launch as able to disable suspension, and Scale as configurable from one minute to always on. An always-on setting removes cold starts but also removes the scale-to-zero saving.

How do you test cost before you commit?

Run your real workload on two vendors for one week. Record compute hours, storage and rows read. Multiply by the list prices above. Repeat the math with ten times the traffic, so you know where each bill goes.

Then set a budget alert. Most platforms let you cap spending or send warnings. A cap on a hobby project protects you from a runaway loop.

Key takeaways for buyers

Serverless databases save money when idle and lose their edge when busy. Neon, Turso and D1 offer genuine free tiers, while Aurora and PlanetScale lean toward provisioned pricing. Our two-workload model puts Neon Launch near $1.15 for a hobby app and $45.69 for an always-on SaaS, against $1.90 and $89.60 on Aurora Standard before I/O. Verify every price on the vendor page, and re-check each quarter.