Backend & data
Managed database prices in 2026: Neon, Supabase, PlanetScale, Turso, Cloudflare D1 and Layerbase
Six managed database providers: flat plans, usage billing, limits and three calculated workloads. Includes Layerbase, checked in November 2026.
In this article
There is no directly comparable price across six providers that charge for different things (compute, a fixed plan or rows): on a medium workload, Cloudflare D1 comes to $17.25 a month, Neon $18.28, Turso $29 and Supabase $25, but each one's limits change the decision.
1. Entry plans from six providers#
Neon charges for compute and storage; Supabase for a plan and resources; PlanetScale for cluster size; Turso and D1 for rows; Layerbase for fixed plans. The November 4, 2026 rate review distinguishes Turso’s monthly billing from annual equivalents.
| Provider | Engine | Free plan | Paid entry | How it charges |
|---|---|---|---|---|
| Neon | PostgreSQL | Yes, permanent: 100 CU-h and 1 GB per project | No fixed fee: $0.106 per CU-hour (Launch) | By use: compute per hour and $0.35 per GB-month |
| Supabase | PostgreSQL | Yes: 500 MB and pauses after 1 week | From $25 a month (Pro) | Plan plus compute, disk and egress |
| PlanetScale | PostgreSQL and Vitess (MySQL-compatible) | No | From $5 a month (single-node Postgres, PS-5) | By cluster size |
| Turso | SQLite-compatible | Yes: 5 GB and 500 million reads | $5.99 a month (Developer) | Plan plus rows read and written and storage |
| Cloudflare D1 | SQLite | Yes, with daily caps: 5 million reads and 100,000 writes | $5 a month minimum (Workers Paid) | Rows read and written plus storage |
| Layerbase | PostgreSQL, MariaDB, Redis, SQLite and others; availability depends on plan | Free: 2 databases, 5 GB shared; sleeps when idle and wakes on connection | Solo: $5/month; Pro: $15/month | Flat plan fee with included capacity; optional upgrades |
PlanetScale no longer offers a free plan: its documentation states that all databases require a paid subscription, with single-node Postgres from $5 a month. All figures are in US dollars and exclude taxes.
Supabase pricing: Free, Pro and real costs in 2026
Documentation: Neon: pricing · Supabase: pricing and plans · PlanetScale: pricing · PlanetScale: plans · Turso: pricing
2. Layerbase: flat monthly plans#
According to its pricing page, checked on November 4, 2026, Layerbase offers these plans without metered query or compute-hour charges. Storage and capacity allowances are shared across the databases on a plan.
| Plan | USD/month | Databases and total storage | Availability and backups |
|---|---|---|---|
| Free | $0 | Up to 2 databases; 5 GB | Sleeps when idle and wakes on connection; no scheduled backups |
| Solo | $5 | Up to 2 databases; 10 GB | 768 MB pool keeps one database always on; daily backups with 7-day retention |
| Pro | $15 | Up to 10 databases; 25 GB | Shared 1.5 GB RAM and 1 vCPU pool; backups with 30-day retention |
Pro allows up to ten databases, but does not guarantee that all ten stay always on: they share the pool, and databases outside it can sleep. Each optional $10/month block adds 1 GB RAM, 1 vCPU and 25 GB storage. Shared plans run in US East, with no choice of region.
A flat price does not mean unlimited capacity. The acceptable-use policy limits sustained bandwidth and can stop databases when exceeded. Free requires sleep periods and is intended for development and early-stage products; applications earning recurring revenue in production need a paid plan. We have not benchmarked Layerbase.
Documentation: Layerbase: plan pricing and conditions · Layerbase: acceptable use and Free plan scope
3. Restore, branches and limits#
Beyond price, point-in-time restore and the number of branches or databases make the difference in daily work. The table summarizes what each provider publishes.
| Provider | Point-in-time restore | Branches or databases |
|---|---|---|
| Neon | 6 hours (Free), up to 7 days (Launch), up to 30 days (Scale) | 10 branches per project (Free and Launch), 25 (Scale); extra at $1.50 per branch-month |
| Supabase | Daily 7-day backups on Pro; point-in-time recovery as a $100 a month add-on | 2 active projects on Free |
| Turso | From 1 day (Free) to 90 days (Pro) | 100 databases on Free; unlimited on paid plans |
| Cloudflare D1 | Time Travel: 7 days (Free) and 30 days (Paid) | Databases follow Workers limits |
Documentation: Cloudflare: D1 pricing · Cloudflare: D1 Time Travel
4. Three calculated workloads#
To compare different billing models, the code calculates the monthly cost of three workloads on four of the six providers. PlanetScale and Layerbase are excluded: cluster size or pool capacity cannot be inferred from row counts alone. We have not verified that any workload in the table fits a Layerbase plan. For Neon an average compute usage is assumed (0.2 CU on the first two workloads and 0.4 CU on the third, 730 hours a month); scale to zero would lower it.
TURSO = { # plan: (base, GB incl., reads incl. (M), writes incl. (M), USD/GB, USD per 1,000 M reads, USD per M writes)
"Free": (0.00, 5, 500, 10, None, None, None),
"Developer": (5.99, 9, 2_500, 25, 0.75, 1.00, 1.00),
"Scaler": (29, 24, 100_000, 100, 0.50, 0.80, 0.80),
"Pro": (499, 50, 250_000, 250, 0.45, 0.75, 0.75),
}
def turso(gb, reads, writes):
best = None
for plan, (base, gb_inc, lec_inc, esc_inc, r_gb, r_lec, r_esc) in TURSO.items():
if r_gb is None:
if gb > gb_inc or reads > lec_inc or writes > esc_inc:
continue
total = base
else:
total = base + max(0, gb - gb_inc) * r_gb + max(0, reads - lec_inc) / 1_000 * r_lec + max(0, writes - esc_inc) * r_esc
if best is None or total < best[1]:
best = (plan, total)
return best[1]
def d1(gb, reads, writes): # Workers Paid: $5 minimum; 25,000 M reads and 50 M writes included
return 5 + max(0, gb - 5) * 0.75 + max(0, reads - 25_000) * 0.001 + max(0, writes - 50) * 1.00
def supabase(gb): # Pro: $25, 8 GB included, Micro compute covered by the credit
return 25 + max(0, gb - 8) * 0.125
def neon(gb, cu_promedio): # Launch: $0.106 per CU-hour (730 h a month) and $0.35 per GB-month
return 0.106 * cu_promedio * 730 + 0.35 * gb
workloads = [("Small", 2, 200, 5, 0.2), ("Medium", 8, 4_000, 60, 0.2), ("Read-heavy", 10, 20_000, 20, 0.4)]
for name, gb, reads, writes, cu in workloads:
print(f"{name}: D1 {d1(gb, reads, writes):.2f} | Turso {turso(gb, reads, writes):.2f} | Supabase {supabase(gb):.2f} | Neon {neon(gb, cu):.2f}")| Workload | Cloudflare D1 | Turso (best plan) | Supabase Pro | Neon Launch |
|---|---|---|---|---|
| Small (2 GB · 200 M reads · 5 M writes) | $5 | $0 | $25 | $16.18 |
| Medium (8 GB · 4,000 M reads · 60 M writes) | $17.25 | $29 | $25 | $18.28 |
| Read-heavy (10 GB · 20,000 M reads · 20 M writes) | $8.75 | $24.24 | $25.25 | $34.45 |
The pattern is clear. With small workloads, Turso Free costs nothing and Cloudflare D1 starts at $5. On the medium workload, D1 ($17.25) and Neon ($18.28) come in below Supabase's $25, with Turso at $29. On the read-heavy one, D1 ($8.75) and Turso ($24.24) stay below, while Neon rises to $34.45 because its compute weighs more than rows; D1 dominates when reads are many because it charges $0.001 per million rows read. But D1 and Turso are SQLite and require a data model different from PostgreSQL; also check D1's per-database limits on its page.
Turso vs Supabase: pricing, billing model and which to choose
Documentation: Cloudflare: Workers pricing
5. Which to choose for your need#
There is no overall winner; the table turns each need into a criterion and a candidate.
| If you need… | Look first at | Usually fits |
|---|---|---|
| PostgreSQL with extensions, authentication and functions included | The engine and what comes included | Supabase or Neon |
| Pay only for what you use, with scale to zero | Compute per hour and idle time | Neon |
| Many small databases or very high reads per row | The price per million rows | Turso or Cloudflare D1 |
| Run the database next to code on Cloudflare Workers | The Workers integration | Cloudflare D1 |
| MySQL (Vitess) or PostgreSQL in a high-availability cluster | Cluster size and high availability | PlanetScale |
| A fixed monthly price for several small databases | Shared capacity, sleep behavior and acceptable-use limits | Layerbase |
Before deciding, estimate your rows read and written per month, the size of your data and whether your application needs PostgreSQL extensions. Those three facts eliminate half the options.
6. What these prices do not include#
The figures in this guide are those of each provider's base plan. Several items are billed separately and can move the bill.
- Egress: Neon includes 500 GB per project on Launch and then charges $0.10 per GB; Supabase includes 250 GB on Pro.
- Extra branches: Neon charges $1.50 per branch-month above those included.
- Backups and recovery: on Supabase, point-in-time recovery is a $100 a month add-on per 7 days of retention.
- Support and security: SSO, priority support and compliance usually cost more on higher plans.
7. Keep your numbers current#
Rates were checked on November 4, 2026. Examples estimate the stated workloads using monthly Turso billing; they exclude some resources and do not establish capacity, latency or availability. Confirm regions and conditions before buying.
- Note the date you read each rate.
- Measure your real rows read and written and the size of your data for a month.
- Compare more options in Codifly's database comparator.
Monthly billing versus annual equivalent#
Turso defaults to annual billing: Developer is equivalent to $4.99/month and Scaler to $24.92/month with that commitment. Monthly billing is $5.99 and $29; monthly Pro is $499. This guide’s tables and scenario code use monthly billing to compare it with other monthly plans.
Documentation: Turso · pricing and billing period