How to Provision Turso Databases Using the Stripe CLI

When you're building an application that needs a database, the usual workflow involves signing up for a provider, navigating a dashboard, copying connection strings, and pasting them into your environment. Stripe Projects collapses all of that into a few terminal commands. It lets you discover services, subscribe to plans, provision resources, and pull credentials without ever leaving your editor.

In this guide, you'll use the Stripe CLI to set up a Turso project from scratch. Turso is a database solution that enables you to deploy upwards of millions of isolated and independent Databases, one per user, agent or tenant. It expands on the legendary SQLite database, but adds support for features like offline writes, native vector search, local-first replication, branching, and point-in-time recovery. By the end, you'll have a working project with two provisioned databases, auto-injected credentials, and a clear understanding of how to manage it all going forward.

#Prerequisites

Before you begin, you'll need:

• The Stripe CLI installed and authenticated on your machine. If you haven't set it up yet, follow Stripe's CLI installation docs.

And that's it! You don't even need a Turso Account. If you have one, your Turso account will be linked to your Stripe account with your email. If not, one will be created for you.

#Step 1: Creating the Project Directory

Every Stripe-managed project lives in its own directory. Start by creating one and moving into it:

mkdir human-project && cd human-project

This is just a regular folder for now. In the next step, you'll turn it into a Stripe project.

#Step 2: Initializing the Stripe Project

With your directory ready, run the initialization command:

stripe projects init

The CLI will ask you to confirm your Stripe account. Type Y to continue.

Once confirmed, the command scaffolds several files and directories inside your project:

File / Directory	Purpose
.projects/	Internal Stripe project config and vault
.gitignore	Keeps secrets and vault files out of version control
.agents/skills/stripe-projects-cli/	Skill definitions for AI agents (Cursor, etc.)
.claude/skills/stripe-projects-cli	Skill definitions for Claude Code
.cursor/rules/	Cursor IDE rules
AGENTS.md	Instructions for AI coding agents
CLAUDE.md	Instructions for Claude Code

You'll notice that the init command sets up integrations for AI coding assistants out of the box. This means tools like Claude Code and Cursor can understand your Stripe project context and help you work with it, a nice touch if you use agent-assisted development.

Once the scaffolding is done, the CLI prints a confirmation:

✓ Authenticated with Stripe
  Your project is ready.

At this point, the project is connected to your Stripe account but doesn't have any services attached yet. That's what you'll do next.

#Step 3: Browsing the Turso Catalog

Before provisioning anything, it's worth seeing what Turso offers through Stripe. The catalog command gives you a full breakdown:

stripe projects catalog turso

The output lists one service — database — and seven pricing plans. Here's a summary:

Plan	Price	Highlights
starter	Free	100 DBs, 5 GB storage, 500M reads, 10M writes
developer	$5.99/month	Unlimited DBs (500 active), 9 GB storage
developer_overages	$5.99/month + overages	Same as developer, with pay-as-you-go overages
scaler	$29/month	Unlimited DBs (2,500 active), 24 GB storage
scaler_overages	$29/month + overages	Same as scaler, with pay-as-you-go overages
pro	$499/month	Unlimited DBs (10,000 active), 50 GB storage
pro_overages	$499/month + overages	Same as pro, with pay-as-you-go overages

The free starter plan is generous enough for prototyping, personal projects, and small production workloads. Right out of the box, it includes 100 databases. That's what you'll use in this guide.

#Step 4: Subscribing to the Turso Starter Plan

Now that you know what's available, subscribe to the starter plan:

stripe projects add turso/starter

The CLI displays the plan details — 100 databases, 5 GB of storage, 500 million rows read, 10 million rows written, 3 GB of syncs, and 1-day point-in-time recovery — and asks you to confirm. Type Y.

Behind the scenes, several things happen in quick succession. The CLI requests the resource from Turso, provisions it, syncs your credentials, and updates the project configuration. When it's done, you'll see:

● turso/starter ready

  ✓ Created turso/starter
  ✓ Injected 2 environment variables
  ~ Modified .projects/vault/vault.json
  ~ Modified .env

  ✓ 2 credentials created for Turso:
    TURSO_OVERAGES=••••••••
    TURSO_PLAN=••••••••

Two things are worth noting here. First, the credentials are stored securely in .projects/vault/vault.json and mirrored into your .env file for easy access. Second, you now have a billing relationship with Turso managed through Stripe with no separate billing dashboard to worry about.

#Step 5: Provisioning Your First Database (Interactive)

Having a plan is one thing; having an actual database is another. Add one now:

stripe projects add turso/database

The CLI prompts you for two pieces of information:

1. Primary location: Choose the AWS region closest to your users. The available options include aws-us-east-1, aws-us-east-2, aws-us-west-2, aws-eu-west-1, aws-ap-south-1, aws-ap-northeast-1, and others. For this guide, select aws-eu-west-1.

2. Database name: Enter a name for your database. The default is your project name, but you can pick something more descriptive. Enter human-db.

Confirm the provisioning prompt with Y, and the CLI takes care of the rest:

● turso/database ready

  ✓ Created turso/database
  ✓ Injected 4 environment variables
  ~ Modified .projects/vault/vault.json
  ~ Modified .env

  ✓ 2 credentials created for Turso:
    TURSO_AUTH_TOKEN=eyJh••••••••
    TURSO_DATABASE_URL=libs••••••••

Your .env file now contains TURSO_AUTH_TOKEN and TURSO_DATABASE_URL, everything you need to connect from your application code. These credentials are specific to the human-db database you just created.

#Step 6: Provisioning a Second Database (Non-Interactive)

Interactive prompts are great for exploration, but they don't work well in scripts, CI/CD pipelines, or when you already know exactly what you want. For those cases, you can pass the configuration inline using the --config flag and skip confirmation with --yes:

stripe projects add turso/database \
  --config '{"name":"agent-db", "location": "aws-eu-west-1"}' \
  --yes

This creates a second database called agent-db in the same region without any prompts. The CLI automatically prefixes the new environment variables with the database name to avoid collisions:

✓ 2 credentials created for Turso:
  AGENT_DB_AUTH_TOKEN=eyJh••••••••
  AGENT_DB_DATABASE_URL=libs••••••••

This naming convention is helpful when your project has multiple databases with different roles, for example, one for user-facing data and another for background agent workflows.

#Step 7: Verifying the Project Status

With everything provisioned, it's a good idea to take a step back and verify the full picture:

stripe projects status

The output gives you a consolidated view of your project:

human-project
  Project    project_61UNze388x27ho...
  Account    Turso (acct_1T47F9Qu12hXQs3J)
  Created    Mar 25, 2026

Providers (1)
  Turso    ✓ Linked    23 hours ago

Services (2)
  agent-db    Turso    database    Free with starter
  human-db    Turso    database    Free with starter

Plans (1)
  turso-plan    Turso    starter    Free

Everything is linked, both databases are active, and the plan is free. If anything looked off — an unlinked provider, a missing service — this is where you'd catch it.

#Step 8: Opening the Turso Dashboard

Sometimes you want a visual interface to inspect your databases, run queries, or check usage metrics. The CLI can open the Turso dashboard directly:

stripe projects open turso

Your browser will open to the Turso Cloud console, where you'll see both agent-db and human-db listed as Active under the agentic-aws-eu-west-1 group. From here, you can use the Edit Data button to run SQL queries, inspect tables, or monitor storage and row counts.

#Quick Reference

Here's a cheat sheet of the commands covered in this guide, plus a few extras:

Command	What it does
stripe projects init	Scaffold a new Stripe project in the current directory
stripe projects catalog turso	List available Turso services and plans
stripe projects add turso/starter	Subscribe to the Turso starter plan
stripe projects add turso/database	Provision a new database (interactive)
stripe projects add turso/database --config '...' --yes	Provision a database non-interactively
stripe projects status	Show project details, providers, and services
stripe projects env	View all environment variables for the project
stripe projects open turso	Open the Turso dashboard in your browser

#Environment Variables Reference

After completing this guide, your .env file will contain six variables across the plan and the two databases:

Variable	Source	Purpose
TURSO_OVERAGES	Starter plan	Overage billing configuration
TURSO_PLAN	Starter plan	Current plan identifier
TURSO_AUTH_TOKEN	human-db	Auth token for the human-db database
TURSO_DATABASE_URL	human-db	Connection URL for human-db
AGENT_DB_AUTH_TOKEN	agent-db	Auth token for the agent-db database
AGENT_DB_DATABASE_URL	agent-db	Connection URL for agent-db

These are managed securely through .projects/vault/vault.json and synced automatically into .env whenever you add or modify services.

#Conclusion

In this guide, you went from an empty directory to a fully configured project with a Turso subscription and two provisioned databases, all without touching a web dashboard or manually copying credentials. The Stripe CLI handled plan selection, resource provisioning, credential injection, and environment setup in a handful of commands.

From here, you can connect to your databases using the TURSO_DATABASE_URL and TURSO_AUTH_TOKEN values in your application code (the @tursodatabase/serverless is a good starting point for TypeScript/JavaScript projects), add more databases as your architecture grows, or upgrade your plan when you need more capacity — all manageable from the same CLI workflow.