Quickstart

Turso is currently in BETA. It may contain bugs and unexpected behavior. Use caution with production data and ensure you have backups.

Interactive shell

The fastest way to try Turso is through the tursodb interactive SQL shell.

Install the CLI

Run the installer script to download the latest tursodb binary:

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/tursodatabase/turso/releases/latest/download/turso_cli-installer.sh | sh

Alternatively, install with Homebrew on macOS:

brew install turso

Start the interactive shell

Launch tursodb to open an in-memory SQL session:

tursodb

You should see:

Turso
Enter ".help" for usage hints.
Connected to a transient in-memory database.
Use ".open FILENAME" to reopen on a persistent database
turso>

To work with a persistent file instead of memory, pass a filename: tursodb mydb.db

Create a table and insert data

Run these SQL statements in the shell:

CREATE TABLE users (id INT, username TEXT);
INSERT INTO users VALUES (1, 'alice');
INSERT INTO users VALUES (2, 'bob');

Query your data

Retrieve the rows you just inserted:

SELECT * FROM users;

Output:

turso> SELECT * FROM users;
┌────┬──────────┐
│ id │ username │
├────┼──────────┤
│  1 │ alice    │
├────┼──────────┤
│  2 │ bob      │
└────┴──────────┘

Inspect the schema

Use the .schema shell command to view table definitions:

.schema users

CREATE TABLE users (id INT, username TEXT);

To exit the shell, press Ctrl+D or type .quit.

Use Turso from code

Turso provides native bindings for Rust, JavaScript, Python, Go, and Java. Choose your language below.

Rust
JavaScript
Python
Go

Add the turso crate to your project:

cargo add turso
cargo add tokio --features full

Then connect and query:

use turso::Builder;

#[tokio::main]
async fn main() -> turso::Result<()> {
    let db = Builder::new_local(":memory:").build().await?;
    let conn = db.connect()?;

    conn.execute(
        "CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)",
        ()
    ).await?;

    conn.execute(
        "INSERT INTO users (name, email) VALUES (?1, ?2)",
        ["Alice", "[email protected]"]
    ).await?;

    let mut rows = conn.query("SELECT * FROM users", ()).await?;

    while let Some(row) = rows.next().await? {
        let id = row.get_value(0)?;
        let name = row.get_value(1)?;
        let email = row.get_value(2)?;
        println!("User: {} - {} ({})",
            id.as_integer().unwrap_or(&0),
            name.as_text().unwrap_or(&"".to_string()),
            email.as_text().unwrap_or(&"".to_string())
        );
    }

    Ok(())
}

Install the package:

npm install @tursodatabase/database

Then connect and query:

import { connect } from '@tursodatabase/database';

// Use ':memory:' for in-memory or pass a file path for persistence
const db = await connect(':memory:');

db.exec('CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT)');

const insert = db.prepare('INSERT INTO users (name, email) VALUES (?, ?)');
insert.run('Alice', '[email protected]');
insert.run('Bob', '[email protected]');

const users = db.prepare('SELECT * FROM users').all();
console.log(users);
// [
//   { id: 1, name: 'Alice', email: '[email protected]' },
//   { id: 2, name: 'Bob', email: '[email protected]' }
// ]

Install the package:

uv pip install pyturso

Then connect and query:

import turso

conn = turso.connect(":memory:")
cur = conn.cursor()

cur.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT)")
cur.execute("INSERT INTO users VALUES (1, 'alice'), (2, 'bob')")

cur.execute("SELECT * FROM users ORDER BY id")
rows = cur.fetchall()
print(rows)  # [(1, 'alice'), (2, 'bob')]

conn.close()

Install the driver:

go get turso.tech/database/tursogo

Then connect and query:

package main

import (
    "database/sql"
    "fmt"
    "os"

    _ "turso.tech/database/tursogo"
)

func main() {
    conn, err := sql.Open("turso", ":memory:")
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        os.Exit(1)
    }

    conn.Exec("CREATE TABLE users (id INTEGER, username TEXT)")

    stmt, _ := conn.Prepare("INSERT INTO users (id, username) VALUES (?, ?)")
    defer stmt.Close()
    stmt.Exec(1, "alice")
    stmt.Exec(2, "bob")

    rows, _ := conn.Query("SELECT * FROM users")
    defer rows.Close()
    for rows.Next() {
        var id int
        var username string
        rows.Scan(&id, &username)
        fmt.Printf("%d, %s\n", id, username)
    }
}

Next steps

Installation

All installation methods: curl, Homebrew, Cargo, and each language binding.

Transactions

Learn about deferred, immediate, and concurrent transactions.

Vector search

Store and query embeddings for semantic search and recommendations.

CLI reference

Full reference for shell commands and command-line options.

Get Started

Language Bindings

Core Features

CLI

Extensions

Compatibility

Interactive shell

Use Turso from code

Next steps

Installation

Transactions

Vector search

CLI reference

Build docs developers (and LLMs) love

Get Started

Language Bindings

Core Features

CLI

Extensions

Compatibility

​Interactive shell

​Use Turso from code

​Next steps

Installation

Transactions

Vector search

CLI reference

Build docs developers (and LLMs) love

Interactive shell

Use Turso from code

Next steps