Alex Spinov

Posted on Mar 26

Turso Has a Free Tier — Run SQLite at the Edge With 9 GB Storage and 500 Databases

#database #sqlite #serverless #webdev

SQLite is the most deployed database in the world. But it has one problem: it runs on a single machine.

Turso fixes this. It gives you distributed SQLite databases that replicate globally — with a free tier that includes 9 GB storage, 500 databases, and 25 billion row reads/month.

That's not a typo. 25 billion reads. Free.

What Is Turso?

Turso is built on libSQL (an open-source fork of SQLite). It gives you:

Edge replication. Your database is copied to locations closest to your users.
Embedded replicas. Sync a copy of the DB directly into your app for zero-latency reads.
SQLite compatibility. Same SQL, same tooling, same simplicity.

Free Tier Details

Resource	Free Limit
Databases	500
Storage	9 GB total
Row reads	25 billion/month
Row writes	75 million/month
Locations	Up to 3
Embedded replicas	Yes

This is enough to run a real production app.

Quick Start

1. Install the CLI

curl -sSfL https://get.tur.so/install.sh | bash
turso auth login

2. Create a Database

turso db create my-app
turso db show my-app --url
# → libsql://my-app-yourname.turso.io

3. Create a Token

turso db tokens create my-app

4. Query It

turso db shell my-app

CREATE TABLE users (
  id INTEGER PRIMARY KEY AUTOINCREMENT,
  name TEXT NOT NULL,
  email TEXT UNIQUE,
  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
);

INSERT INTO users (name, email) VALUES ('Alex', 'alex@example.com');
SELECT * FROM users;

5. Use It From Code

import { createClient } from '@libsql/client';

const db = createClient({
  url: 'libsql://my-app-yourname.turso.io',
  authToken: 'your-token',
});

// Read
const result = await db.execute('SELECT * FROM users WHERE email = ?', ['alex@example.com']);
console.log(result.rows);

// Write
await db.execute('INSERT INTO users (name, email) VALUES (?, ?)', ['Sam', 'sam@example.com']);

Embedded Replicas (Zero-Latency Reads)

This is Turso's killer feature. Sync the entire database into your app:

import { createClient } from '@libsql/client';

const db = createClient({
  url: 'file:local-replica.db',           // Local copy
  syncUrl: 'libsql://my-app-you.turso.io', // Remote source
  authToken: 'your-token',
});

await db.sync(); // Pull latest changes

// Reads hit local file = microsecond latency
const users = await db.execute('SELECT * FROM users');

Your reads hit a local file. Microsecond latency. No network round trip.

Turso vs Alternatives

Feature	Turso	PlanetScale	Neon	Supabase	SQLite
Engine	SQLite (libSQL)	MySQL	PostgreSQL	PostgreSQL	SQLite
Free storage	9 GB	5 GB	512 MB	500 MB	Unlimited (local)
Free databases	500	1	1	2	Unlimited
Edge replication	Yes	No	No	No	No
Embedded replica	Yes	No	No	No	Yes (it IS local)
Row reads free	25B/mo	1B/mo	Unlimited	Unlimited	Unlimited
Branching	Yes	Yes	Yes	No	No

When to Use Turso

Use Turso when:

You want SQLite simplicity with multi-region distribution
You need microsecond read latency (embedded replicas)
You're building edge-first apps (with Deno Deploy, Cloudflare Workers, etc.)
You want per-tenant databases (500 free databases = 500 tenants)

Don't use Turso when:

You need complex joins across huge tables (PostgreSQL is better)
You need full-text search (though SQLite FTS works)
You need stored procedures or advanced PostgreSQL features

The Bottom Line

Turso gives you the simplicity of SQLite with the distribution of a cloud database. The free tier is absurdly generous — 9 GB, 500 databases, 25 billion reads.

If your app reads more than it writes (and most apps do), Turso's embedded replicas give you effectively zero-latency reads for free.

Building data-intensive apps or need custom database solutions? I build backend tools and data pipelines for dev teams. Email spinov001@gmail.com — or explore my developer resources.

DEV Community