A backend for small teams shipping more than one idea

Three Postgres backends. $10 a month.

Database, API, Auth, files, realtime, and logs—already wired.

Start with one free database. Move to three for $10 a month, with no seat fee. Keep direct SQL access and export whenever you want.

1
database free
3
databases on Pro
$0
per teammate
$10
Pro per month

New for your next build

Less setup. More time for your next idea.

Go from your first working request to a separate project for testing, without stitching together more tools. Coding agents get a disposable database that cannot touch a real one.

Agent database sandbox

Break a database that is not yours

An agent gets a disposable SQLite database and fills it from the ready-made list. Reset it and try again.

MCP, for coding agents

Free plan: one sandbox, deleted after 3 hours. Paid plans: three sandboxes, up to 72 hours. DROP and ALTER stay off the app database.

Connect an agent

Guided setup

Make your first API request

Create a sample table, insert a row, and verify a real API read. The checklist tracks what you actually completed.

Project overview

Take the next step with copyable Next.js, Node.js, and cURL connection examples.

See the connection guide

API request playground

Test it before you wire it up

Try reads, filters, and writes from your dashboard. Inspect the response, then copy the matching cURL or JavaScript request into your app.

API tab

Uses your live project and server key, not end-user RLS permissions. Writes require confirmation.

Explore the API playground

Project cloning & recovery

Give your next change its own project

Copy your schema, optionally include data, or restore a snapshot into a new project. Get fresh credentials without overwriting the source.

Project settings

Data is not anonymized. File bytes and project settings are not copied. New projects count toward your plan limits.

See multi-project pricing

Ready-made data

Generate a dataset in one call

An agent passes one of these names to the sandbox. Each set creates its tables and rows. Related rows point at each other.

  • Users

    20 people with a name, an email, and a signup time.

  • Products

    20 products with a price and an active flag.

  • Tasks

    20 tasks with an assignee, a due time, and a done flag.

  • Blog

    10 authors, 20 posts, and 40 comments. Each comment points at a post.

  • Shop

    20 users, 20 products, and 40 orders. Each order points at a user and a product.

  • Contacts

    25 people with a company and a city.

  • Notes

    25 notes with a title, a body, and a pinned flag.

  • Invoices

    15 customers and 25 invoices. Each invoice points at a customer.

  • Support

    8 agents and 32 tickets. Each ticket points at an agent.

  • Events

    10 events and 30 RSVPs. Each RSVP points at an event.

  • CRM

    10 companies, 20 people, and 20 deals. People and deals point at a company.

  • Courses

    8 courses, 24 lessons, and 20 enrollments. Lessons and enrollments point at a course.

  • Messages

    6 channels and 40 messages. Each message points at a channel.

  • Bookings

    8 rooms and 24 reservations. Each reservation points at a room.

  • Reviews

    15 items and 30 reviews. Each review points at an item.

  • Inventory

    5 warehouses, 20 products, and 40 stock rows. Stock points at a warehouse and a product.

  • Employees

    6 departments and 24 employees. Each employee points at a department.

  • Library

    20 books and 30 loans. Each loan points at a book.

Have a look

The dashboard, without signing up

Filter the table and watch the REST URL change — it is the same query grammar the real endpoint parses. The rows are an example, and the preview says so.

todos · publicInteractive preview · example data
5 rows
idtaskdoneprioritycreated_at
1Design the schema12026-02-03
2Add row-level security12026-02-04
3Wire up the webhook—22026-02-08
4Write the migration—12026-02-09
5Ship it—32026-02-11

The real editor edits cells in place and writes straight to Postgres. The filters above are the same ones the REST tab turns into a URL.

Everything per project

One project, every door

Each project is a complete backend: tables, REST, RLS, Auth, files, realtime, durable webhooks, request logs, vectors, functions, and snapshots you can restore.

Real Postgres

An isolated Postgres database with its own role and connection string. Use Prisma, Drizzle, psql, or any driver you already know.

Instant REST API

Create tables over HTTP or SQL. Every table becomes an endpoint with filters, ordering, pagination and batch writes.

SQL editor

Run migrations and queries from the browser as your own database role. No hidden layer between you and Postgres.

Auth built in

Email and password accounts, rotating refresh tokens, logout, and per-project JWTs that work directly with row-level security.

File storage

Public or private buckets, signed uploads and downloads, MIME rules, and file metadata in your own database.

Realtime

Postgres changes, filtered subscriptions, Broadcast, and Presence over WebSocket.

Logs you can use

See API status, latency, request IDs, Auth outcomes, and every webhook attempt without storing bodies, tokens, or credentials.

Invite other accounts

Included on every plan, including Free. No Team SKU, no seat fee, and no organisation surcharge — unlike Supabase’s $25 org.

Vector search

One toggle adds pgvector. Send your own floats, or turn Embed on and POST ?embed=true with a string — we fill vector(768). Search is POST /vector.

Postgres functions

Write a function in SQL. Call it over HTTP: POST /rpc/your_function. No edge runtime — it runs in your database, as your role.

Invoke URL

Paste any HTTPS URL. We POST signed row and schema changes, with visible retries. Same delivery as a webhook, not an edge runtime.

Snapshots

Download a snapshot, restore in place, or recover into a new project from Settings. Pro and above also keep a daily copy. Not point-in-time recovery — only those snapshots.

Schema migrations

Deploy an ordered group of schema changes once. Safe retries skip migrations that already succeeded.

One project, many doors

Reach it however you like

Create a table once. It is a REST resource, a realtime stream, a vector index if you want one, and a table in psql. Functions you write are POST /rpc.

SDK way

Fastest setup

Use a native client

Query rows, authenticate users, manage storage, and call functions with language-friendly methods and consistent errors.

const { data } = await db
  .from("todos")
  .select("id,task")
  .eq("done", false);

REST API way

Call HTTP directly

Use fetch, cURL, or any HTTP client. There is no SDK dependency, and your live OpenAPI document describes the current schema.

GET /rest/todos?select=id,task&done=eq.false
apikey: YOUR_API_KEY
in the SQL editor
create table todos (
  id         serial primary key,
  task       text not null,
  done       boolean not null default false,
  created_at timestamptz not null default now()
);

How it works

Three steps, then you are writing product code

  1. 01

    Create a project

    Name it and choose a starter schema. An isolated Postgres database and scoped login role are provisioned in seconds.

  2. 02

    Make your first request

    Use Get connected to create a sample table, insert a row, and verify a real API read. Each step reflects actual progress.

  3. 03

    Connect your app

    Copy a Next.js, Node.js, or cURL example. Test more requests in the API playground, then bring the working code into your app.

Pricing

Pay for capacity, not features

Every plan includes the complete product. Free can dump and restore a project; Pro and above also keep a daily snapshot — the last two copies. That is not point-in-time recovery. Plan allowances are hard caps, so more databases, storage, or egress requires an upgrade. Inviting teammates and vector search are included. There is no Team SKU and no seat fee.

One idea or five. Know the monthly total.

One subscription, not a separate bill for every project.

Try your first idea

1 project

$0/ month total

Free includes 1 project

Shared plan allowances

  • 1 GB Postgres
  • 1 GB file storage
  • 1 GB egress / month

Keep a few ideas running

3 projects

$10/ month total

Pro includes 3 projects

Shared plan allowances

  • 2 GB Postgres
  • 5 GB file storage
  • 3 GB egress / month

Build a small portfolio

5 projects

$29/ month total

Pro+ includes 8 projects

Shared plan allowances

  • 10 GB Postgres
  • 20 GB file storage
  • 10 GB egress / month

Monthly prices in USD, before any applicable taxes. These examples assume all projects fit within the shared plan allowances, not that each project gets its own allowance. More projects or capacity requires a plan upgrade. No per-seat fee. Free projects are subject to inactivity limits.

Need a different setup? Adjust the calculator.

2
2 GB
5 GB

Database size includes indexes, so it reads higher than your rows alone. Storage grows automatically as you fill it — there is nothing to provision.

You, on Pro$10.00 / mo
  • Pro base$10.00
Supabase, same setup$35.00
You save$25.00 / mo

starterpg plan allowances are hard caps; the calculator chooses the lowest plan that includes the requested capacity. Supabase figures estimated from their published rates: $25 base, ~$10 per additional project, 8 GB of database included per project then $0.125/GB, 100 GB of file storage then $0.021/GB. Check their pricing page for the current numbers.

Free

Free

  • 1 database
  • 500 MB database, up to 1 GB
  • 1 GB file storage
  • 1 GB egress / month
  • 20k embed tokens / month
  • Invite other accounts
  • Agent playground, one SQLite sandbox for 3 hours
  • Paused after 7 days idle
  • Manual snapshot, download or restore
  • Community support
Start free
Most popular

Pro

$10/ month

  • 3 databases
  • 2 GB Postgres
  • 5 GB files
  • 3 GB egress / month
  • 200k embed tokens / month
  • Invite other accounts
  • Agent sandbox, three live for 72 hours
  • Daily snapshots, download or restore
  • Email support
Choose Pro

Pro+

$29/ month

  • 8 databases
  • 10 GB Postgres
  • 20 GB files
  • 10 GB egress / month
  • 1M embed tokens / month
  • Invite other accounts
  • Agent sandbox, three live for 72 hours
  • Daily snapshots, download or restore
Choose Pro+

Ultra

$399/ month

  • 15 databases
  • 300 GB Postgres
  • 2 TB files
  • 750 GB egress / month
  • 10M embed tokens / month
  • Invite other accounts
  • Agent sandbox, three live for 72 hours
  • Daily snapshots, download or restore
Choose Ultra

Scale

$799/ month

  • 25 databases
  • 700 GB Postgres
  • 4 TB files
  • 1.5 TB egress / month
  • 20M embed tokens / month
  • Invite other accounts
  • Agent sandbox, three live for 72 hours
  • Daily snapshots, download or restore
Choose Scale

Snapshots you can restore

Free can take a snapshot in Settings, download it, or put it back. Pro and above keep the last two daily copies. Not a restore SLA, and not point-in-time recovery.

Read the FAQ

Invite other accounts

Included on every plan, including Free. There is no Team SKU, no seat fee, and no organisation surcharge — unlike Supabase’s $25 org. Create a team and invite people from the dashboard.

Start free

Against Supabase Pro

Supabase includes much more traffic and storage in Pro. starterpg is priced for teams with several small databases: three projects are $10 here versus an estimated $45 there. Teammates are included.

DatabasesstarterpgSupabase Pro, Micro
1$10 / Pro$25
3$10 / Pro$45
8$29 / Pro+$95

Supabase: $25 organisation + $10 Micro per project − $10 credit that covers one project, from supabase.com/pricing. Their Pro includes 8 GB disk per project, 100 GB files, and 250 GB egress. Ours starts smaller: Pro includes 2 GB / 5 GB / 3 GB, enforced as plan caps. If you run one high-traffic database, Supabase may be the better value. If you ship several small products or environments, starterpg is designed for that shape.

Questions

Yes — a real Postgres database, with its own login role and connection string. Point psql, Prisma, Drizzle or any Postgres driver at it. Nothing about your schema is proprietary.

Settings can dump the project, download the file, or restore it. Pro and above also get a daily snapshot. That is not point-in-time recovery — only those copies. You can still pg_dump the connection string yourself.

You skip provisioning, connection handling, and writing a CRUD API. Creating a project gives you a database plus generated REST endpoints, email/password auth, file storage, change subscriptions, vector search, and HTTP calls to your own Postgres functions.

Yes, optional. Secret API keys (sk_) bypass RLS. Publishable keys (pk_) are subject to whatever policies you write. If you enable RLS and add no policy, publishable keys cannot read or write that table.

In the United States, on a shared Postgres instance, as its own database with its own role. Other tenants cannot CONNECT to it. Dedicated instances are not offered. There is no uptime SLA.

Free is one database, 500 MB growing to 1 GB, 1 GB of files, 1 GB egress, 20k embed tokens, paused after 7 days idle, and a manual snapshot. Pro is $10/month for 3 databases with 2 GB Postgres, 5 GB files, 3 GB egress, and 200k embed tokens. Pro+ is $29 for 8 databases with 10 GB / 20 GB / 10 GB / 1M tokens. Those allowances are hard caps; more capacity requires the next plan. Your own vector floats do not consume embed tokens.

Supabase Pro includes much more storage and traffic for one busy project. starterpg is optimized for several small projects: Pro is $10 for three databases and Pro+ is $29 for eight, with teammates included. Choose Supabase for its larger ecosystem, edge runtime, and high included traffic; choose starterpg when direct Postgres plus several inexpensive backends is the better fit.

Yes. The project Logs tab shows seven days of API status, latency, normalized paths, request IDs, and end-user Auth outcomes. Responses include X-Starterpg-Request-Id for correlation. Bodies, query strings, credentials, tokens, and email addresses are not stored. Webhook delivery history has separate status filters, delivery-ID search, payload inspection, and replay.

Only if you turn Embed on in the project and pass ?embed=true. Otherwise you send floats yourself. Hosted embed uses Google’s gemini-embedding-001 into vector(768) and counts against the plan’s monthly token wall.

Yes. A secret key installs one with POST /schema and kind create_function, or you can create it in the schema playground. Open the project Functions tab to see the list, run one, or delete it. From your server, POST /rpc/<name> with named arguments, or POST /schema with kind drop_function to remove it. The function runs in that project only. There is no separate edge-function runtime. For outbound work, paste an invoke URL: we POST signed row-change events to your HTTPS endpoint and show every retry.

Immediately. Switch plans and the new allowances apply at once. Unused time on the old plan is credited on the next invoice.

Yes, on every plan — including Free. Create a team in the dashboard and invite accounts by email. There is no Team SKU, no seat fee, and no organisation surcharge — unlike Supabase’s $25 org.

More questions, including backups, liability, and HIPAA

Your first database is free

Create a project and query it in under a minute.

Get started
starterpg.com — Postgres for startups