Turso: A Complete Guide

What is Turso?What is Turso?

In-process SQL database compatible with SQLite, written in Rust with vector search and CDC support

6-min readUpdated Aug 2026

Turso in 60 seconds

WHAT IT IS

An open-source SQL database compatible with SQLite, written in Rust and built for the edge and local-first apps.

WHY IT'S USED

Teams pick it to run SQLite past a single process, with embedded replicas, edge replication, and a database per tenant.

STRENGTHS

+SQLite-compatible SQL, so existing queries and drivers keep working
+Embedded replicas put a local copy next to the app for fast reads
+Cheap to spin up millions of small databases, one per tenant or user

LIMITATIONS

−Young project still in beta, so expect churn and rough edges for now
−Built for OLTP and edge reads, not heavy OLAP or analytical scans
−No built-in high availability model yet, unlike mature SQL engines

BEST KNOWN FOR

Edge applicationsLocal-first appsPer-tenant SaaS databasesAI agent databasesOffline-first mobile

Jump to at a glance, how it works, or quick start for the full picture on Turso.

At a glance

Category	Embedded
First released	2024
License	MIT
Written in	Rust
Runs on	Linux, Macos, Windows
Deployment	Embedded, Self-hosted, Edge
Wire protocol
Query dialect	sqlite-sql
Consistency	strong
ACID support	native
JSON support	native
Full-text search	extension
Vector support	native
HA model	none
Managed by	turso

What is Turso?

Turso is an open-source SQL database that is compatible with SQLite. It keeps SQLite's file-based storage and its SQL dialect, then extends the engine so it can run past a single local process. You get the same tables, the same SELECT statements, and the same drivers, plus replication, native vector search, and change data capture. The result is a database that starts as small and simple as SQLite but reaches out to the edge.

The project comes from Turso, a company that began by hosting libSQL, an open fork of SQLite it created after the SQLite maintainers declined outside contributions. libSQL added the server, replication, and extension hooks that hosted use needs. In 2024 the company started a full rewrite of the engine in Rust, still under the SQLite-compatible banner it uses today, aiming for a drop-in replacement that stays open to contribution. The engine is MIT licensed and the code is on GitHub.

Turso targets edge and local-first workloads, where data sits close to the user and reads need to be fast. Prisma runs it under Prisma Optimize, Val Town builds on it, and tools like OpenStatus and Flipt store state in it. A newer pattern is AI: companies such as Adaptive spin up millions of small per-agent databases on Turso Cloud, one for each running agent. The engine is still in beta, so it shows up more in new projects than in legacy systems.

How Turso works

Turso builds on libSQL, an open fork of SQLite that keeps the on-disk file format and SQL dialect but reopens the codebase to outside contributions. On top of the core engine it adds a server layer, a remote protocol over HTTP, and hooks for replication and extensions that stock SQLite does not expose. Anything a SQLite client can read, Turso can read, so existing files and drivers move over without a rewrite.

For hosted use, Turso runs database servers across many regions and replicates data between them. A write lands on the primary and streams out to replicas near your users, so a request served from a nearby region reads local data instead of crossing an ocean. This edge replication turns a single-file database into one that answers with low latency for a global audience, without you placing the data by hand.

Two patterns define how teams use it. Embedded replicas keep a full SQLite file inside the application process that syncs from the remote primary, so reads hit local disk at sub-millisecond speed while writes forward to the primary. Per-tenant databases lean on the fact that a Turso database is cheap to create, so instead of one shared database you give each customer, user, or AI agent their own, sometimes millions at once.

Key concepts

libSQL and SQLite compatibility

Turso is a fork and rewrite of SQLite that keeps its file format and SQL dialect while reopening the engine to outside contributions. Existing SQLite queries, schemas, and drivers work without changes, so a project can adopt Turso by pointing at a new connection string. The difference is the server, replication, and extensions on top.

Embedded replicas

An embedded replica is a full SQLite database file that lives inside your application process and syncs from a remote Turso primary. Reads run against the local file at sub-millisecond latency with no network round trip, while writes forward to the primary and stream back. It gives an app local SQLite speed with a hosted database behind it.

Edge replication

Turso runs database servers across many regions and copies data between them so it sits close to users. A write commits on the primary and replicates out to nearby regions, letting a request read local data instead of a distant origin. This lowers read latency for a global audience and is why teams pick Turso over a single-region server.

Database per tenant

Because a Turso database is cheap to create and tear down, teams give each customer or workload its own instead of one shared database. Per-tenant isolation makes separation, backups, and deletion simple, since each tenant maps to a distinct file. The pattern scales into the millions, which is why AI platforms hand every agent a private store.

Native vector search

Turso includes vector search in the core engine rather than a bolt-on extension. You store embeddings in a column, build an index over them, and run nearest-neighbor queries with plain SQL alongside the rest of your data. Keeping vectors next to operational rows means a retrieval step reads from one database, which suits AI features.

Change data capture

Change data capture, or CDC, records every insert, update, and delete as an ordered stream that other systems can read. Turso exposes this so downstream services can react to writes, sync a search index, or feed an analytics pipeline without polling. Paired with replication, it lets a database fan its changes out to the rest of a stack.

Turso by the numbers

Live GitHub adoption, updated daily

#1 of 14 open-source embedded databases by GitHub stars

GitHub stars

23.9k

+867 in 30d

Forks

1.3k

Weekly growth

+90

stars in the last 7 days

Last commit

today

Aug 2026

Source: github.com/tursodatabase/turso

Who uses Turso

A handful of the companies running it in production

Prisma

Val Town

OpenStatus

Flipt

Adaptive

Undb

Solana Tracker

When to use Turso

Best for

✓Edge and low-latency reads

Turso replicates data to regions near your users and can keep a local copy inside the app, so reads return in well under a millisecond instead of crossing the network to a single distant origin server.

✓Local-first and offline apps

Embedded replicas give an app a real SQLite file on device that keeps working offline and syncs to the primary when a connection returns, which fits mobile and desktop clients that cannot assume the network.

✓Per-tenant SaaS and AI agents

When each customer or agent should own its data, Turso lets you create a separate cheap database per tenant, scaling into the millions of small databases without the cost of running that many full servers.

✓Teams already on SQLite

A project built on SQLite can move to Turso by swapping the connection, keeping its schema, queries, and drivers, then gaining replication and hosting with no migration to a different SQL dialect.

Not ideal for

✕Heavy analytical scans

Turso targets transactional reads and writes, so scan-heavy analytics over billions of rows belong on a column store like ClickHouse or DuckDB, which are built to crunch large aggregates far faster.

✕Strict high availability needs

The engine has no built-in failover or clustering model yet, so workloads that demand automatic multi-node high availability are better served by a distributed SQL engine such as CockroachDB or YugabyteDB.

✕Large single-database write loads

SQLite serializes writes to one database, so a single hot database with heavy concurrent writes will bottleneck. The per-tenant pattern spreads load, but one giant shared table is not where Turso shines.

✕Mature-stack production bets

Turso is still in beta with an evolving API and tooling, so a team that needs a decade of proven operational history and broad third-party support may prefer an established engine like Postgres for now.

Turso vs alternatives

Head-to-head specs against the top 4 alternatives

Spec	Turso	SQLite	PostgreSQL	MongoDB	Amazon DynamoDB
Identity
License	MIT	Public Domain	PostgreSQL License	SSPL	Proprietary
First released	2024	2000	1996	2009	2012
Wire protocol			postgresql	mongodb	http
Capabilities
ACID	Native	Native	Native	Native	Native
JSON	Native	Native	Native	Native	Native
Vector	Native	Extension	Extension	Native	No
HA model	None	None	Primary-standby	Raft	Multi-master
Ecosystem
Managed providers	1	2	9	1	1
ORM support	—	8	10	6	2
Use cases
Best for	Edge applications · Local-first apps · SQLite-compatible workloads	Embedded applications, mobile apps, local data storage, edge computing, and prototyping	General-purpose OLTP, complex queries with advanced SQL, geospatial data with PostGIS, and applications requiring strong ACID compliance	Flexible-schema applications, content management, real-time analytics, and mobile/IoT backends	Serverless applications, high-throughput key-value access patterns, and globally distributed low-latency workloads
Not ideal for	Heavy OLAP · Multi-node distributed systems	High-concurrency write-heavy workloads, multi-user client-server applications	Extreme write-heavy workloads at massive horizontal scale, simple key-value caching, or real-time streaming without extensions	Highly relational data with complex joins or strict referential integrity requirements	Complex relational queries, ad-hoc analytics, or workloads requiring flexible querying without predefined access patterns

Turso vs SQLite

Turso

SQLite

Identity

License

MIT

Public Domain

First released

2024

2000

Wire protocol

Capabilities

ACID

Native

JSON

Native

Vector

Native

Extension

HA model

None

Ecosystem

Managed providers

ORM support

—

Use cases

Best for

Edge applications · Local-first apps · SQLite-compatible workloads

Embedded applications, mobile apps, local data storage, edge computing, and prototyping

Not ideal for

Heavy OLAP · Multi-node distributed systems

High-concurrency write-heavy workloads, multi-user client-server applications

Turso vs PostgreSQL

Turso

PostgreSQL

Identity

License

MIT

PostgreSQL License

First released

2024

1996

Wire protocol

postgresql

Capabilities

ACID

Native

JSON

Native

Vector

Native

Extension

HA model

None

Primary-standby

Ecosystem

Managed providers

ORM support

—

Use cases

Best for

Edge applications · Local-first apps · SQLite-compatible workloads

General-purpose OLTP, complex queries with advanced SQL, geospatial data with PostGIS, and applications requiring strong ACID compliance

Not ideal for

Heavy OLAP · Multi-node distributed systems

Extreme write-heavy workloads at massive horizontal scale, simple key-value caching, or real-time streaming without extensions

Turso vs MongoDB

Turso

MongoDB

Identity

License

MIT

SSPL

First released

2024

2009

Wire protocol

mongodb

Capabilities

ACID

Native

JSON

Native

Vector

Native

HA model

None

Raft

Ecosystem

Managed providers

ORM support

—

Use cases

Best for

Edge applications · Local-first apps · SQLite-compatible workloads

Flexible-schema applications, content management, real-time analytics, and mobile/IoT backends

Not ideal for

Heavy OLAP · Multi-node distributed systems

Highly relational data with complex joins or strict referential integrity requirements

Turso vs Amazon DynamoDB

Turso

Amazon DynamoDB

Identity

License

MIT

Proprietary

First released

2024

2012

Wire protocol

http

Capabilities

ACID

Native

JSON

Native

Vector

Native

HA model

None

Multi-master

Ecosystem

Managed providers

ORM support

—

Use cases

Best for

Edge applications · Local-first apps · SQLite-compatible workloads

Serverless applications, high-throughput key-value access patterns, and globally distributed low-latency workloads

Not ideal for

Heavy OLAP · Multi-node distributed systems

Complex relational queries, ad-hoc analytics, or workloads requiring flexible querying without predefined access patterns

Quick start

Install the Turso CLI, create a database, and run a first query. Under a minute once the CLI is on your machine.

Install the Turso CLI

# macOS / Linux
curl -sSfL https://get.tur.so/install.sh | bash

# Or with Homebrew
brew install tursodatabase/tap/turso

turso auth signup
turso db create my-app
turso db show my-app

Open a SQL shell

turso db shell my-app

Create a table and insert a row

CREATE TABLE users (
  id INTEGER PRIMARY KEY,
  email TEXT UNIQUE NOT NULL,
  created_at TEXT DEFAULT (datetime('now'))
);

INSERT INTO users (email) VALUES ('[email protected]');

SELECT * FROM users;

That is a live database with an edge replica. Connect from any language with the libSQL drivers, or open it in a GUI to browse tables and run queries visually.

Manage Turso visually with 1bench

Resources

Official

Related database guides

PostgreSQL

The world's most advanced open-source relational database

MongoDB

The most popular document database for modern applications

Qdrant

High-performance open-source vector database for next-generation AI applications

DuckDB

Fast in-process analytical database with rich SQL support and zero dependencies

Typesense

Fast, typo-tolerant open-source search engine with built-in vector and semantic search

Neon

Serverless PostgreSQL with separated storage and compute, branching, and scale-to-zero

Frequently asked questions

What is Turso used for?

Turso is a SQLite-compatible SQL database used for edge applications, local-first and offline apps, per-tenant SaaS, and databases for AI agents. Teams reach for it when they want SQLite's simplicity but need reads served close to users, a local replica inside the app, or a cheap separate database for every customer or agent. Companies like Prisma, Val Town, OpenStatus, and Adaptive run it in production, and it also stores vector embeddings for AI features through its built-in vector search.

Is Turso free?

Yes. The Turso database engine is open source under the MIT license, so you can download, self-host, modify, and run it in production at no cost. Turso the company also offers Turso Cloud, a managed service with a free tier for small workloads and paid plans that add more databases, storage, and regions. The engine itself stays free whether you self-host or use the cloud, and because it keeps the SQLite file format you can move your data elsewhere.

Who owns Turso?

Turso is built by a company also called Turso, a US-based startup formerly known as ChiselStrike. The company created libSQL, the open fork of SQLite that the project grew from, and now develops the Rust rewrite of the engine in the open on GitHub. Unlike community-run SQLite, Turso has a single vendor behind it with a managed cloud product, though the engine is MIT licensed and open to outside contributions rather than closed.

Is Turso based on SQLite?

Yes. Turso started as libSQL, an open fork of SQLite, and the current engine is a rewrite of SQLite in Rust that keeps its on-disk file format and SQL dialect. Existing SQLite databases, queries, and drivers work with Turso without changes. The difference is that Turso adds a server, replication across regions, embedded replicas, native vector search, and change data capture, features stock SQLite does not include on its own.

Is Turso an edge database?

Yes. Turso is designed to run at the edge, meaning it replicates your database to servers in many regions so reads are served from the location closest to each user. It also supports embedded replicas, a full SQLite file kept inside the application that syncs from the primary for sub-millisecond local reads. Both approaches cut the network distance between the app and its data, which is the core idea behind an edge database.

Skip the config files

Connect to Turso in 30 seconds. Browse tables, run queries, and edit rows visually, on localhost, self-hosted, or cloud.

Open Turso in 1bench