Turso vs Neon

Quick verdict

Turso offers SQLite-compatible databases in two forms. Turso Database is an in-process engine written in Rust (MIT licence, pre-1.0; v0.8.2 on 6 October 2026) that Turso describes as replacing libSQL, its earlier SQLite fork, as its intended direction. Turso Cloud is the managed service that hosts Turso Database and libSQL databases, with branching, point-in-time recovery and analytics. Apps can query Turso Cloud over the network, or keep a local copy through embedded replicas or Turso Sync.

Neon is serverless PostgreSQL built on separated storage and compute, now part of Databricks and branded Lakebase Postgres. It supports Postgres 14 to 18, autoscales compute, scales to zero after 5 minutes idle, and creates copy-on-write branches that include data. New projects run in AWS regions only. Plans are Free, Launch and Scale.

For backend platforms rather than databases, see Turso vs Supabase and Supabase vs Neon.

Side by side

Key differences

SQLite-compatible versus PostgreSQL

This is the deciding difference. Turso speaks SQLite's dialect and file format, with SQLite's flexible typing and a single database file. Turso Database adds features SQLite lacks, including BEGIN CONCURRENT for concurrent writers under MVCC (one of two conflicting transactions must roll back and retry), change data capture, vector support and experimental Postgres compatibility. Neon is PostgreSQL: its types, JSONB, extensions, roles and the wider Postgres tool ecosystem, with documented differences such as no tablespaces and a neon_superuser role instead of a true superuser.

In our assessment, if your schema or tooling already assumes Postgres, Neon is the natural fit; if your app already uses SQLite, Turso keeps the same model and adds a cloud copy.

Local reads versus network queries

Turso can place the database inside your application. An embedded replica keeps a local file that syncs from a Turso Cloud primary; Turso documents that reads run locally and writes go to the cloud primary, with the writing replica seeing its own writes immediately. Turso Sync, recommended for new projects that need sync, adds local writes with explicit push() and pull(). Both need a filesystem. Turso's older Edge Replicas (copies in many regions) are deprecated for new users.

Neon is always reached over the network. For serverless and edge runtimes it provides a driver that queries over HTTP or WebSockets. Side by side, as shown in each vendor's docs:

// TypeScript, @libsql/client (Turso): remote query with a bound parameter
import { createClient } from "@libsql/client";
const client = createClient({
  url: process.env.TURSO_DATABASE_URL,
  authToken: process.env.TURSO_AUTH_TOKEN,
});
const result = await client.execute({
  sql: "SELECT * FROM users WHERE id = ?",
  args: [1],
});

// JavaScript, @neondatabase/serverless (Neon): tagged-template query
import { neon } from "@neondatabase/serverless";
const sql = neon(process.env.DATABASE_URL);
const postId = 12;
const posts = await sql`SELECT * FROM posts WHERE id = ${postId}`;

Branching and restore

Neon's branches are its signature feature: copy-on-write clones with schema and data, created from the current state or a past point inside the restore window, without loading the parent. That suits a database per pull request or preview environment.

Turso branching creates a new database from an existing one (turso db create my-new-database-branch --from-db my-existing-database). The docs note the branch is completely separate, schema changes must be merged by hand, it needs its own token, and it counts towards your plan's database quota. Turso's point-in-time history is longer on its higher plans (up to 90 days on Pro) and Turso Cloud can recover deleted databases for up to five days.

Billing models

Turso charges a plan fee and meters rows read, rows written, storage and sync volume; there are no compute hours. Neon meters compute in CU-hours (one CU is about 4 GB of RAM with associated CPU) and storage in GB-months, and charges nothing for compute while a database has scaled to zero. For a read-heavy app with many tiny tenants, Turso's row-based model may be simpler to predict; for a single larger Postgres database with bursts of activity, Neon's compute-hour model applies. Neither vendor publishes a worked example we can quote, so model your own workload.

Pricing and licensing

Turso. Listed on the Turso pricing page in October 2026, in USD. Free: 0 USD, 100 databases, 5 GB storage, 500 million rows read and 10 million rows written per month, 3 GB of syncs, 1 day of history. Developer: 4.99 USD per month (a saving is shown for yearly billing), unlimited databases, 9 GB storage then 0.75 USD per GB, 2.5 billion rows read then 1 USD per billion, 25 million rows written then 1 USD per million, 10 days of history. Scaler: listed at 24.92 USD per month, 24 GB storage, 30 days of history. Pro: listed at 416.58 USD per month, 50 GB storage, 90 days of history. Enterprise: custom.

Neon. Listed on the Neon pricing page and plans documentation in October 2026, in USD. Free: 0 USD, up to 100 projects, 100 CU-hours per project per month, 1 GB storage per project, 10 branches per project, 6 hours of restore history. Launch: 0.106 USD per CU-hour, autoscaling up to 16 CU, up to 7 days of history. Scale: 0.222 USD per CU-hour, fixed computes up to 56 CU, up to 30 days of history. Storage on paid plans is 0.35 USD per GB-month; Neon states there is no monthly minimum on Launch and Scale.

Pricing checked on the vendors' official pages on 7 October 2026. Prices change; confirm before buying.

Where each one leads

Limitations

When to choose each

When neither is right

• You deploy on Cloudflare Workers and want a SQLite database bound to the Worker: see Cloudflare D1 vs Turso.
• You want auth, storage and APIs as well as the database: see Supabase vs Neon.
• You need provisioned Postgres inside your AWS account: see Neon vs AWS RDS.
• Your workload is analytical: see DuckDB vs SQLite.

Final recommendation

Frequently asked questions

Sources

• Turso pricing
• Turso docs: Turso Cloud
• Turso docs: Branching
• Turso docs: Concurrent writes
• Turso docs: Embedded replicas
• Turso docs: TypeScript SDK reference
• Turso Database (GitHub repository, MIT)
• Neon pricing
• Neon docs: Plans
• Neon docs: Branching
• Neon docs: Serverless driver
• Neon docs: Postgres compatibility

Checked October 2026.

How we research comparisons: our editorial method.