Turso

What Turso actually is

Turso is a managed database platform built on libSQL, an open-source fork of SQLite, that lets you create very large numbers of small databases and replicate each of them close to your users. The company behind it was founded in 2021 by Glauber Costa, Pekka Enberg and Dejan Mircevski — engineers out of ScyllaDB and the Linux kernel world — and went through Y Combinator's W2023 batch. Corporate HQ is Claymont, Delaware, though most of the engineering team operates from Europe and South America. The product we are reviewing here is Turso Cloud, the managed offering; the database itself is MIT-licensed and self-hostable.

The core idea is worth stating plainly because it inverts how most people think about databases. Instead of one large Postgres or MySQL instance holding every customer's data, you provision one tiny SQLite-compatible database per tenant, per user, or per AI agent. Each database is a file — the format is byte-compatible with SQLite — and Turso replicates that file to edge locations so reads are served near the caller. For multi-tenant SaaS this gives hard data isolation per customer without paying for a dedicated server per customer, and it maps naturally onto AI agent memory, where thousands of short-lived, small state stores are the norm.

Under the hood, Turso is written in Rust with an async-first I/O model, which suits serverless and edge runtimes where blocking calls are expensive or unavailable. The feature set goes beyond plain SQLite: vector search, full-text search via Tantivy, concurrent writes, change data capture, and incremental view maintenance are included or in flight. The SQL dialect and file format stay SQLite-compatible, which is the point — your local development database is the same format as production.

The data plane runs on third-party infrastructure. Turso's own trust center lists AWS as its cloud provider and Fly.io for database hosting, with backups landing in S3. That architecture matters for the residency discussion later, and we flag it again under the trade-offs.

Pricing: what you really pay

Turso publishes a full price list, and we always prefer providers who do. The free plan is $0 with no credit card and no time limit: 100 databases, 5 GB of storage, 500 million rows read and 10 million rows written per month, 3 GB of sync traffic, and one day of point-in-time restore. One correction to make up front: older marketing claimed 500 databases free. The current published limit is 100 databases on Free — still far more than most hobby projects will ever create.

Developer is $5.99 per month billed monthly, or $4.99 per month billed yearly ($59.88 up front). It lifts the database cap to unlimited and includes 9 GB of storage (overage $0.75 per GB), 2.5 billion rows read (overage $1 per billion), 25 million rows written (overage $1 per million), 10 GB of syncs (overage $0.35 per GB), and 10 days of point-in-time restore. Scaler is $29 monthly or $24.92 per month billed yearly ($299 per year), with 24 GB of storage, 100 billion rows read, 100 million rows written, 30 days of restore, and team features. Pro is $499 monthly or $416.58 per month billed yearly ($4,999 per year): 50 GB of storage, 250 billion rows read, 250 million rows written, 90 days of restore, SSO, customer-managed encryption keys, HIPAA and SOC 2 paperwork, and priority email plus Slack support. Enterprise is quoted per contract and adds dedicated infrastructure, bring-your-own-cloud deployment, and unlimited usage.

Two observations from our reading of this structure. First, the usage dimension that will surprise you is rows read, not storage. A single unindexed query that scans a large table can burn millions of row reads; the free plan's 500 million sounds enormous until a background job with a missing index quietly scans its way through it. Turso's docs are upfront about this, and we would set up usage alerts on day one. Second, the yearly prices are a real discount (roughly 17 percent on Developer) but they commit you for a year, and the plan steps are steep — $4.99 to $24.92 to $416.58 per month on annual billing. If your workload sits between Scaler and Pro, model the overage math before assuming the jump is unavoidable; the included allowances plus per-unit overage often let a busy Scaler plan land well under $416.

Performance & infrastructure

We have not run Turso through our own benchmark suite, so we will not quote numbers we do not have. What we can point to is the architecture and the vendor's published guarantees. Since 2025 Turso Cloud has run a diskless design: commits are acknowledged only once the write-ahead log sits in S3 Express One Zone, and local disks act purely as cache. That buys durability at the level of AWS S3 — eleven nines — while accepting the latency cost of a remote write. Turso publishes exactly what that costs per plan: up to 100 ms of added commit latency on Free, 50 ms on Developer, 25 ms on Scaler, and 10 ms on Pro and above. We respect a vendor that puts a number like that on a pricing-adjacent page instead of burying it.

Geography is a genuine strength. The trust center states servers run in more than 30 locations worldwide, and you pick per database where replicas live. Read latency for a globally distributed app is therefore a function of placement you control. For our own latency and throughput comparisons against other providers, see our /benchmarks page.

On availability, Turso does not publish a public uptime SLA for the self-serve tiers — the commitment is on durability, not on monthly uptime percentage. Enterprise contracts can include custom SLAs. For many readers that is the honest trade: you get an unusually strong durability story and no uptime promise to hold them to.

Where it falls short

Start with the obvious: SQLite is not Postgres. The dialect has no stored procedures, a deliberately small type system, and query planning that stops being fun once your working set leaves memory. Turso has added concurrent writes and richer indexing, but a workload built around complex multi-table analytics is fighting the abstraction. If your queries are heavy on joins and aggregations, a conventional relational engine will serve you better.

The multi-database model is powerful and operationally unfamiliar. Migrating a schema change across ten thousand databases, reasoning about connection pooling per tenant, and debugging "this one customer's database is slow" are problems single-database users never see. Turso ships schema migration tooling, and the pattern is well supported, but budget engineering time for the mental model change.

Residency deserves a careful read. The trust center's own FAQ says you can keep an EU-only database entirely inside the EU — with one exception: backups are stored in S3 in us-east-2. If your compliance requirement is strict EU data residency, that exception is the sentence that matters, not the marketing. Encryption at rest and in transit is on, and Pro and Enterprise can use their own S3 buckets, which is the route we would take for regulated data.

Support follows the usual tiering. Free and Developer are community support only; priority email and Slack arrive at Pro, at $416.58 per month billed yearly. For a startup running production on Scaler, that means no fast path to a human when something breaks at 3 a.m. Enterprise sales can fix that, at enterprise prices.

Who should pick this

Our pick for multi-tenant SaaS where per-customer isolation is a product requirement rather than a nice-to-have: billing platforms, white-label tools, per-client dashboards. The same shape fits AI agent memory — many small, short-lived state stores with cheap reads — and edge apps on Cloudflare Workers or Vercel where a TCP connection to a distant Postgres is the wrong tool.

We would steer elsewhere in two cases. If your data model is genuinely relational and query-heavy, Postgres-family options will waste less of your time. If you want an uptime SLA with teeth on a self-serve budget, Turso does not offer one today, and you should look at providers who publish theirs.

For teams who fit the pattern, the economics are hard to beat at the low end: $0 for 100 databases with 5 GB and a half-billion row reads is a real free tier, not a teaser, and the per-tenant isolation you get for $4.99 per month on the annual Developer plan would have required a fleet of instances a decade ago. In the database-hosting category, we think of Turso as the specialist — narrow fit, very deep.

Key takeaways

• Managed SQLite-compatible databases (libSQL, MIT-licensed) at the edge, one per tenant or per agent, replicated to 30+ locations.
• Free plan: $0, 100 databases, 5 GB storage, 500M rows read monthly — a genuine free tier, though older "500 databases" claims no longer match the published limit.
• Paid tiers run $5.99/mo (Developer), $29/mo (Scaler), $499/mo (Pro) monthly billing; annual billing cuts roughly 17 percent.
• Durability is the headline guarantee (eleven nines via S3-backed commits) with published commit-latency costs per tier — but there is no public uptime SLA on self-serve plans.
• Watch rows-read metering and the EU backup caveat: backups land in S3 us-east-2 unless you bring your own buckets at Pro or Enterprise.
• Ideal for multi-tenant SaaS and AI agent memory; wrong tool for query-heavy relational workloads — see our other picks in /category/database-hosting.

Sources

• https://turso.tech/pricing.md
• https://turso.tech/what-is-turso
• https://turso.tech/about
• https://trust.turso.tech/faq
• https://docs.turso.tech/cloud/durability
• https://turso.tech/blog/turso-cloud-goes-diskless
• https://www.cbinsights.com/company/turso
• https://pitchbook.com:8443/profiles/company/491091-67