Supabase Pricing (October 2026): What a Solo Founder Actually Pays, From $0 to $100

Short answer: Supabase pricing for a solo founder comes down to two numbers. The Free plan is $0 for two active projects, but each one pauses after a week of low activity and gets restricted when it blows past 5 GB of egress. The Pro plan is $25 a month per organization, which covers one project on the smallest (Micro) compute size. Every extra project adds about $10 a month, a bigger instance costs more, and a handful of add-ons (IPv4, custom domain, point-in-time recovery, preview branches) are billed on top and are not stopped by the spend cap. A quiet app on Pro really does cost $25. A real launched app with a staging project and one or two add-ons usually lands between $35 and $60.

Last updated: October 28, 2026. Prices checked today against the Supabase pricing page and Supabase’s billing docs on compute, the spend cap and your monthly invoice. Supabase changes these pages, so re-check before you budget.

If you haven’t picked a backend yet, start with Supabase vs Firebase. This post assumes you’re already on Supabase (maybe because Lovable, Bolt or your coding agent picked it for you) and want to know what the bill will look like once real users show up.

Supabase pricing at a glance

	Free	Pro	Team	Enterprise
Price	$0	From $25/month per org	From $599/month	Custom
Projects	2 active	Unlimited, each pays for its own compute	Unlimited	Custom
Compute included	Shared CPU, 500 MB RAM	$10/month credit = one Micro (1 GB RAM)	$10/month credit	Custom
Database	500 MB	8 GB disk per project, then $0.125/GB	Same as Pro	Custom
Monthly active users	50,000	100,000, then $0.00325 each	Same as Pro	Custom
Egress	5 GB + 5 GB cached	250 GB + 250 GB cached, then $0.09 / $0.03 per GB	Same as Pro	Custom
File storage	1 GB, 50 MB max upload	100 GB, then $0.0213/GB	Same as Pro	Custom
Edge Function calls	500,000	2 million, then $2 per million	Same as Pro	Custom
Backups	None	Daily, kept 7 days	Daily, kept 14 days	Custom
Pausing	After 1 week of low activity	Never	Never	Never
Support	Community	Email	Priority email + SLA	Dedicated

All plans include unlimited API requests, so you’re never billed per query. That’s the biggest structural difference from Firebase, where every Firestore read is a line item.

What the Free plan really gives you

For building and testing, Free is generous. 500 MB of Postgres holds a lot more rows than most MVPs ever reach, and 50,000 monthly active users is far beyond a first launch. The limits that actually bite are different ones.

The one-week pause

Supabase pauses a Free project that doesn’t see enough database activity over seven days. Its docs say a few real requests a day is usually enough, and you get a warning email about a week before the pause. A paused project can be restored from the dashboard for up to a year, with data intact.

The r/Supabase threads about this are a little funny and a little sad. People run cron jobs that hit the API every couple of days and still get paused, then trade tricks: a daily Edge Function run, an uptime monitor pointed at a storage file, a scheduled workflow that inserts a row. Some of those work, some don’t, and none of them are something you want to depend on for a product with customers.

My rule: keep-alive hacks are fine for a hobby demo. The day someone else depends on the app, the pause risk alone justifies Pro.

The egress wall

Egress is data leaving Supabase: query results, auth responses, files downloaded from Storage. Free gives you 5 GB uncached plus 5 GB served from the CDN cache. Go over and, per Supabase’s docs, you get an email and a grace period, after which the organization can be restricted until the cycle resets or you upgrade.

One Ask HN post from a solo builder describes what that looks like in practice: a small SQL tutor app with maybe 10 to 20 sessions a day went about 15% over the free egress cap, API requests started failing with HTTP 402, login broke, and it happened shortly before a paid demo. They upgraded on the spot. Their complaint wasn’t the $25 itself but the gap: Pro gave them 50 times the egress they needed, with nothing in between.

Why your Supabase bill is more than $25

Supabase’s own invoice docs list the reasons, and they match what shows up in forum threads.

1. Every project is its own server

This is the line most people miss. Pricing is per organization, but compute is per project. The $10 compute credit covers exactly one Micro instance. Supabase’s billing FAQ spells it out:

• 1 project on Micro: $25 + $10 − $10 = $25/month
• 2 projects on Micro: $25 + $20 − $10 = $35/month
• 3 projects on Micro: $25 + $30 − $10 = $45/month

So a dev project plus a production project on Pro is $35, not $25. And if you run four small tools in one Pro org, you’re at $55, not “$25 per project” (a mistake someone made publicly in a popular r/Supabase thread, and the replies corrected the math). Paused projects don’t accrue compute, but on Pro you can’t pause a project without moving it to a Free org first.

2. Bigger compute

Compute is billed hourly, rounded up to the full hour:

Size	RAM	Approx. monthly	Hourly
Micro	1 GB	~$10	$0.01344
Small	2 GB	~$15	$0.0206
Medium	4 GB	~$60	$0.0822
Large	8 GB, 2 dedicated vCPUs	~$110	$0.1517

Moving from Micro to Small costs an extra $5 a month after the credit. Medium is where it jumps. If your agent suggests “just upgrade the instance” to fix slow queries, check for missing indexes first; that fix is free.

3. Add-ons the spend cap doesn’t stop

Pro ships with the spend cap on by default. With it on, going over a quota (egress, MAU, storage, disk, Edge Function calls, Realtime) restricts that item instead of billing you. That’s a good default. But Supabase’s cost-control docs list what it does not cover, because you opted into them:

• Compute, including preview branch and read replica compute
• IPv4 address: $4/month per database
• Custom domain: $10/month per project
• Point-in-time recovery (PITR): $100/month per 7 days of retention
• Advanced phone MFA: $75/month for the first project
• Log drains: $60/month per drain, plus events and egress
• Extra provisioned disk IOPS or throughput

PITR is the one to read twice. Daily backups are already included in Pro. PITR is a $100-a-month upgrade for minute-level restore, which almost no pre-revenue app needs.

4. Usage beyond the quota with the cap turned off

If you turn the spend cap off (Pro) or you’re on Team, overages are billed: egress at $0.09/GB, cached egress at $0.03/GB, disk at $0.125/GB, and so on. Supabase’s own example invoice shows a project that served about 2,370 GB of egress in a month and paid $190.75 for the 2,119 GB above the quota. That’s not typical for an indie app, but it shows how fast egress adds up once something goes viral or goes wrong.

The vibe coding trap: AI-written queries that eat egress

Egress is where AI-generated code costs real money. A July 2026 r/vibecoding post describes a rewrite where the agent “modernized” a working data layer: the dashboard re-downloaded the full document for every project card on each load, and background jobs polled entire rows every couple of seconds. The old version used about 0.1 GB of egress a month; the rewrite burned around 5 GB a day. Trimming the queries to the columns each screen needed and polling a tiny status field cut egress by about 99%.

Another thread on surprise bills says the same thing about Storage: serving images straight from a bucket with no caching headers was the expensive part, and putting a cache in front fixed most of it.

You can catch this before it ships. Paste this into Claude Code, Cursor or Codex at the root of your repo:

Audit this codebase for Supabase egress waste. List every place that:
1. Uses select('*') or selects columns the UI never renders.
2. Fetches a list without .limit() or pagination.
3. Polls the database on an interval (setInterval, refetchInterval, useSWR refreshInterval).
4. Downloads full rows or JSON blobs just to show a name, count or status.
5. Serves Supabase Storage files without Cache-Control headers or transformations.
For each one: file and line, what it fetches now, estimated payload per call,
and the smallest change that returns only what the screen needs.
Do not change any code yet. Output a table, then wait for my go-ahead.

Then check your org’s Usage page for a day or two after any big refactor. It shows egress per project and per service, which tells you whether the database, Auth or Storage is the source.

Estimate your own Supabase bill

Here’s a small script to sanity-check a plan before you turn features on. It uses the list prices above and ignores tax and smaller items like Realtime overages. Save it as supabase-estimate.py:

#!/usr/bin/env python3
"""Rough Supabase Pro bill estimate (list prices checked Oct 28, 2026).
usage: supabase-estimate.py PROJECTS COMPUTE EGRESS_GB CACHED_GB DISK_GB MAU [--ipv4] [--pitr] [--domain]
COMPUTE = micro|small|medium|large (applied to every project)"""
import sys
COMPUTE = {"micro": 10, "small": 15, "medium": 60, "large": 110}
a = [x for x in sys.argv[1:] if not x.startswith("--")]
flags = {x for x in sys.argv[1:] if x.startswith("--")}
if len(a) != 6 or a[1] not in COMPUTE:
    sys.exit(__doc__)
projects, size = int(a[0]), a[1]
egress, cached, disk, mau = map(float, a[2:])
lines = [("Pro plan", 25.0), (f"Compute {projects} x {size}", projects * COMPUTE[size]),
         ("Compute credit", -10.0)]
lines.append(("Egress over 250 GB", max(0, egress - 250) * 0.09))
lines.append(("Cached egress over 250 GB", max(0, cached - 250) * 0.03))
lines.append(("Disk over 8 GB/project", max(0, disk - 8 * projects) * 0.125))
lines.append(("MAU over 100k", max(0, mau - 100_000) * 0.00325))
if "--ipv4" in flags: lines.append(("IPv4 add-on", 4.0 * projects))
if "--pitr" in flags: lines.append(("PITR 7 days", 100.0 * projects))
if "--domain" in flags: lines.append(("Custom domain", 10.0))
for name, cost in lines:
    if cost: print(f"{name:<28} ${cost:>8.2f}")
print(f"{'Estimated total':<28} ${sum(c for _, c in lines):>8.2f}")

Two runs, both on hypothetical numbers. A dev and a prod project on Micro, well inside the quotas:

python3 supabase-estimate.py 2 micro 40 10 2 1000
# Estimated total  $35.00

One project on Small that went 50 GB over the uncached egress quota and 550 GB over the cached one:

python3 supabase-estimate.py 1 small 300 800 5 0
# Egress over 250 GB           $4.50
# Cached egress over 250 GB    $16.50
# Estimated total              $51.00

Both match the worked examples in Supabase’s own docs ($35 for two Micro projects, $51 for that egress case), which is how I checked the script. On Windows, run it with py instead of python3 if python3 isn’t on your PATH.

What real indie Supabase bills look like

I don’t run a paying app on Supabase Pro myself, so I won’t invent a bill. What I can share is what other people have posted, with one warning attached.

• The quiet app: one project on Micro, inside every quota. $25 a month, which is exactly what Supabase’s own docs quote for a single database-only Pro project.
• The “dev + prod” setup: two projects, $35. A May 2026 r/Supabase thread argued about whether you need this at all. The practical answers: use the Supabase CLI’s local stack for development, keep migrations in version control, and pay for a second cloud project only when you need a real staging copy. One commenter pointed out that the daily backups alone make Pro worth it once real users exist.
• The launched app: an April 2026 r/Supabase post broke down a $71 bill line by line for an app with around 1,200 monthly active users: Small compute, some egress overage, IPv4, a couple of preview branches and point-in-time recovery. The poster’s conclusion was that $25 is realistic only for quiet apps and $50 to $80 is closer once you add extras. Be careful with the exact figures, though: some of the line items in that post (PITR at $10, the Small compute hourly rate) don’t match Supabase’s current list prices, so treat it as a shape, not a quote.
• The portfolio of tiny tools: a January 2026 thread from someone with four small apps who moved them to SQLite on a single VPS for about $5 a month, giving up Realtime and managed Auth in the process. That’s a valid trade if you’re comfortable running a server. Most vibe coders aren’t, and that’s the real thing you’re paying Supabase for.

When to upgrade from Free to Pro

Stay on Free while:

• You’re building, and nobody but you and a few testers uses the app.
• Losing a day to a pause or an egress restriction wouldn’t hurt anyone.
• You can live without automatic backups (export with supabase db dump if you care about the data).

Upgrade to Pro when any of these is true:

• Someone pays you, or a demo, client or launch date depends on the app being up.
• Your Usage page shows egress past roughly half of the 5 GB free quota by mid-month.
• You want daily backups without scripting them yourself.
• You need uploads larger than 50 MB or more than 1 GB of file storage.

And when you upgrade:

1. Leave the spend cap on until you’ve seen two or three normal invoices.
2. Delete or pause what you don’t use before upgrading. Every active project in a paid org costs compute. Move side experiments to a separate Free organization.
3. Skip PITR, IPv4 and custom domains unless you have a specific reason. You only need IPv4 if you connect with the direct connection string from a network that can’t do IPv6; the connection pooler and client libraries work without it.
4. Delete preview branches once merged. Branch compute isn’t covered by the $10 credit or the spend cap.
5. Put the real number in your budget. If your stack is also paying for hosting and an AI coding tool, the full picture is in the real monthly cost of an AI indie dev stack, and the hosting side is in Vercel vs Netlify.

Keep your coding agent from creating surprise costs

Your agent can create projects, branches and add-ons for you if it’s connected through the Supabase MCP server (setup in the best MCP servers for Claude Code). Convenient, but each of those can cost money. I add a short block like this to CLAUDE.md or AGENTS.md:

## Supabase cost rules
- Never create a new Supabase project, preview branch, read replica or add-on
  (IPv4, PITR, custom domain, compute upgrade) without asking me first.
- Select only the columns a screen renders. No select('*') in client code.
- Every list query gets .limit() or pagination.
- No polling faster than every 30 seconds; prefer Realtime on a narrow channel.
- Storage downloads must set Cache-Control or use the CDN URL.

It won’t stop a determined agent, but it turns most silent cost decisions into a question you get to answer. Pair it with Row Level Security checks from the vibe-coded app security checklist, since an open table is both a data leak and an egress bill waiting to happen.

FAQ

Is Supabase free?

Yes, for up to two active projects, with 500 MB of database, 1 GB of file storage, 5 GB of egress and 50,000 monthly active users. Free projects pause after about a week of low activity, there are no automatic backups, and going over a quota can get the project restricted until the cycle resets.

How much does Supabase Pro cost?

$25 a month per organization. That includes $10 of compute credit, which covers one project on Micro compute. Each additional project adds about $10 a month on Micro, and larger instances or add-ons cost extra.

Does the Supabase spend cap protect me from every surprise?

No. It stops usage-based overages like egress, storage, disk size and monthly active users. It does not cover compute, preview branches, read replicas, IPv4, custom domains, point-in-time recovery, phone MFA or log drains.

Is Supabase cheaper than Firebase?

For most small apps the Supabase bill is more predictable, because it’s mostly a flat fee and API requests are unlimited, while Firebase bills Firestore per read, write and delete. Firebase can be cheaper at very low traffic since its Blaze plan has no monthly base fee. The full comparison, with a Firestore cost calculator, is in Supabase vs Firebase.

Can I self-host Supabase to avoid paying?

Yes. Supabase supports self-hosting with Docker or the Supabase CLI, including the Studio dashboard. You trade the $25 for running, updating and backing up the server yourself. For a first app built with an AI agent, I’d pay for Pro and spend that time on users instead.

My take

Supabase’s pricing is fair once you understand the one rule that surprises people: you pay for each running project, not for the account. Build on Free, upgrade the day someone depends on the app, keep the spend cap on, keep the number of projects small, and say no to add-ons until you have a reason. Do that and the bill is $25 to $35 for a long time.

If you’re still deciding whether to use Supabase through an app builder or directly, Replit vs Lovable covers the builder route, and Claude Code for non-developers walks through connecting Supabase yourself.