Quickstart

Create a database and run your first query in minutes

1. Create a database

   Dashboard

   1. From your Bunny dashboard, click Add in the left-hand sidebar and select Database.

      

   2. Enter a unique name for your database. This name will be used to identify your database in the dashboard and connection URLs.

      

   3. Choose how you want your database deployed:

      • Automatic: We will choose the optimal regions for your database based on your location and best performance.
      • Single region: Deploy your database to a single region without any replication. Best for development or applications with users in one geographic area.
      • Manual: Manually select your storage location along with primary and replication regions. Best for applications with specific latency or compliance requirements.
      

   4. Click Add Database to create your database.

      

   5. Once created, copy your connection credentials:

      • Database URL: Your database endpoint
      • Access Token: Choose between Full Access (read/write) or Read Only depending on your needs
      
      Keep your access tokens secure. Never commit them to version control or expose them in client-side code.

   6. Optional: if you have an existing Edge Script or Magic Container, you can add your database credentials directly from this page:

      1. Click Add Secrets to Edge Script or Add Secrets to Magic Container Apps
      2. Select the script or app you want to connect
      3. The database URL and access token will be added as environment variables automatically
      

   CLI

   Don’t have the CLI installed? See the CLI quickstart to install and authenticate.

   Create a database interactively:

   bunny db create
   

   You’ll be prompted for a name and region mode (automatic, single region, or manual). After creation, the CLI offers to:

   • Link the current directory to the database (writes .bunny/database.json)
   • Generate a full-access auth token
   • Save BUNNY_DATABASE_URL and BUNNY_DATABASE_AUTH_TOKEN to a .env file

   For a fully non-interactive run (e.g. in CI):

   bunny db create --name mydb --primary FR
   

   Keep your access tokens secure. Never commit them to version control or expose them in client-side code.

   See bunny db for the full command reference, including bunny db shell for an interactive SQL prompt.

2. Install an SDK and connect

   Install the official SDK for your language and connect to your database:

   TypeScript

   Install the libSQL client:

   npm install @libsql/client
   

   Connect and run queries:

   import { createClient } from "@libsql/client/web";
   
   const client = createClient({
     url: "libsql://your-database-id.lite.bunnydb.net",
     authToken: "your-access-token",
   });
   
   // Create a table
   await client.execute(`
     CREATE TABLE IF NOT EXISTS users (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       name TEXT NOT NULL,
       email TEXT UNIQUE NOT NULL
     )
   `);
   
   // Insert data
   await client.execute({
     sql: "INSERT INTO users (name, email) VALUES (?, ?)",
     args: ["Kit Hopkins", "[e-mail]"],
   });
   
   // Query data
   const result = await client.execute("SELECT * FROM users");
   console.log(result.rows);
   

   Rust

   Add the libSQL crate to your Cargo.toml:

   [dependencies]
   libsql = "0.6"
   tokio = { version = "1", features = ["full"] }
   

   Connect and run queries:

   use libsql::Builder;
   
   #[tokio::main]
   async fn main() -> Result<(), libsql::Error> {
       let db = Builder::new_remote(
           "libsql://your-database-id.lite.bunnydb.net".to_string(),
           "your-access-token".to_string(),
       )
       .build()
       .await?;
   
       let conn = db.connect()?;
   
       // Create a table
       conn.execute(
           "CREATE TABLE IF NOT EXISTS users (
               id INTEGER PRIMARY KEY AUTOINCREMENT,
               name TEXT NOT NULL,
               email TEXT UNIQUE NOT NULL
           )",
           (),
       )
       .await?;
   
       // Insert data
       conn.execute(
           "INSERT INTO users (name, email) VALUES (?1, ?2)",
           ("Kit Hopkins", "[e-mail]"),
       )
       .await?;
   
       // Query data
       let mut rows = conn.query("SELECT * FROM users", ()).await?;
       while let Some(row) = rows.next().await? {
           let id: i64 = row.get(0)?;
           let name: String = row.get(1)?;
           let email: String = row.get(2)?;
           println!("User: {} - {} ({})", id, name, email);
       }
   
       Ok(())
   }
   

   Go

   Install the libSQL driver:

   go get github.com/tursodatabase/libsql-client-go/libsql
   

   Connect and run queries:

   package main
   
   import (
       "database/sql"
       "fmt"
       "log"
   
       _ "github.com/tursodatabase/libsql-client-go/libsql"
   )
   
   func main() {
       url := "libsql://your-database-id.lite.bunnydb.net?authToken=your-access-token"
   
       db, err := sql.Open("libsql", url)
       if err != nil {
           log.Fatal(err)
       }
       defer db.Close()
   
       // Create a table
       _, err = db.Exec(`
           CREATE TABLE IF NOT EXISTS users (
               id INTEGER PRIMARY KEY AUTOINCREMENT,
               name TEXT NOT NULL,
               email TEXT UNIQUE NOT NULL
           )
       `)
       if err != nil {
           log.Fatal(err)
       }
   
       // Insert data
       _, err = db.Exec(
           "INSERT INTO users (name, email) VALUES (?, ?)",
           "Kit Hopkins", "[e-mail]",
       )
       if err != nil {
           log.Fatal(err)
       }
   
       // Query data
       rows, err := db.Query("SELECT * FROM users")
       if err != nil {
           log.Fatal(err)
       }
       defer rows.Close()
   
       for rows.Next() {
           var id int64
           var name, email string
           rows.Scan(&id, &name, &email)
           fmt.Printf("User: %d - %s (%s)\n", id, name, email)
       }
   }
   

   .NET

   Install the libSQL client package:

   dotnet add package Libsql.Client
   

   Connect and run queries:

   using Libsql.Client;
   
   var client = DatabaseClient.Create(opts =>
   {
       opts.Url = "libsql://your-database-id.lite.bunnydb.net";
       opts.AuthToken = "your-access-token";
   });
   
   // Create a table
   await client.Execute(@"
       CREATE TABLE IF NOT EXISTS users (
           id INTEGER PRIMARY KEY AUTOINCREMENT,
           name TEXT NOT NULL,
           email TEXT UNIQUE NOT NULL
       )
   ");
   
   // Insert data
   await client.Execute(
       "INSERT INTO users (name, email) VALUES (?, ?)",
       "Kit Hopkins", "[e-mail]"
   );
   
   // Query data
   var result = await client.Execute("SELECT * FROM users");
   foreach (var row in result.Rows)
   {
       Console.WriteLine($"User: {row["id"]} - {row["name"]} ({row["email"]})");
   }