The Best Free Database Tiers in 2026 (15 Compared)

TL;DR: If you want SQL and don’t want to think about it, Neon (100 projects × 0.5 GB Postgres) or Supabase (500 MB Postgres + auth/storage bundled) are the safest picks - both are no-credit-card, sustained free tiers. If you want the single largest free storage number, CockroachDB gives 10 GiB. If you’re on Cloudflare Workers, use D1 - 5 GB, 5M rows read/day. If you need NoSQL, Amazon DynamoDB’s 25 GB Always Free tier beats every document database’s free storage by a wide margin. Full comparison and gotchas below.

What’s in this list, and what isn’t

This list covers databases with a sign-up-and-go free tier: create an account, get a working database, keep it for as long as you want, no expiration clock. That rule quietly disqualifies two products that otherwise look like they belong here:

Render advertises a free Postgres database, but it isn’t a sustained free tier - Render’s own docs confirm the free database expires 30 days after creation, with a 14-day grace period to upgrade before it’s deleted. That’s a free trial with a countdown, not a free tier, so it isn’t in the table below.
Xata markets itself as having a free option, but the only perpetual free path is the self-hosted open-source edition - you run it yourself on your own Kubernetes cluster. There’s no hosted “sign up and get a free database” plan; Xata Cloud starts with a 14-day trial that requires a credit card to continue. Also excluded from the table for the same reason.

Everything else below is a real, ongoing, no-expiration-date free tier, checked against each vendor’s current pricing page as of August 2026.

The comparison

Product	Engine	Free storage	Free ops/compute	Credit card?	Gotcha
Cloudflare D1	SQLite (edge)	5 GB	5M rows read/day, 100K rows written/day	No	Daily caps with no rollover, and metered in rows - one query can read many rows
Supabase	Postgres	500 MB × 2 projects	Unlimited API requests	No	Projects pause after 1 week idle
Turso	SQLite (libSQL)	5 GB	500M rows read/mo, 10M rows written/mo	No	100 databases max on free plan
Neon	Postgres (serverless)	0.5 GB × 100 projects	100 CU-hours/project/mo	No	Per-project cap, not a shared pool
CockroachDB	Distributed SQL	10 GiB	50M request units/mo	No	Usage priced in Request Units, not simple ops
Amazon Aurora DSQL	Distributed SQL	1 GB/mo	100,000 DPUs/mo	Yes (AWS account)	Requires an AWS account and org setup
Amazon DynamoDB	NoSQL (key-value)	25 GB	25 WCU + 25 RCU/mo	Yes (AWS account)	Provisioned-capacity model, not the request-based on-demand mode
Cloud Firestore	NoSQL (document)	1 GiB	50K reads/day, 20K writes/day	No (Google account)	Daily caps reset at midnight Pacific, not UTC
Firebase Realtime Database	NoSQL (realtime)	1 GB	10 GB downloads/mo, 100 concurrent connections	No (Google account)	One database per project on the free plan
MongoDB Atlas	NoSQL (document)	512 MB	Throttled above 100 ops/sec	No	Shared RAM/vCPU - noisy-neighbor risk under load
Prisma Postgres	Postgres	500 MB	100K Prisma ops/mo, 60K Accelerate ops/mo	No	Up to 50 databases on the free plan, but 100K Prisma ops/mo is the real ceiling
Upstash	Redis (in-memory KV)	256 MB	500K commands/mo	No	1 database limit on the free Redis plan
Aiven	Postgres / MySQL / Kafka / OpenSearch	Varies by service	Varies by service	No	Per-service quotas don’t combine - see below
Nile	Postgres (multi-tenant)	1 GB	50M query tokens/mo	No	Priced in “query tokens,” not raw ops
Convex	Reactive document store	0.5 GB	1M function calls/mo	No	Backend-as-a-service model, not a bare SQL/NoSQL endpoint

The relational (SQL) options

If your app thinks in tables, foreign keys, and joins, you have more free options than ever. Supabase and Neon are both full Postgres, both free with no credit card, and both solve the “which project gets the free tier” problem differently - Supabase caps you at 2 active projects with 500 MB each, Neon lets you spread across 100 projects at 0.5 GB each. If you’re building one app, Supabase’s bundled auth and storage save you integration work. If you’re managing many small apps or client projects, Neon’s per-project branching model fits better.

Prisma Postgres is worth a specific mention if you’re already using Prisma’s ORM - the free tier gives you up to 50 separate databases, which is unusually generous for spinning up a fresh database per feature branch or per test suite run.

CockroachDB and Amazon Aurora DSQL step up to distributed SQL - the same relational model, but built to survive a full region going down. CockroachDB’s 10 GiB free storage is the largest plain-SQL free allowance on this list; Aurora DSQL’s free tier is smaller (1 GB/month) but comes with AWS’s operational backing if you’re already in that ecosystem.

Nile is a newer entrant worth watching if you’re building multi-tenant SaaS specifically - it’s Postgres under the hood, but built around per-tenant database isolation as a first-class feature rather than something you bolt on yourself.

The SQLite / edge options

Cloudflare D1 and Turso both run SQLite (Turso via its libSQL fork) and both target low-latency, edge-adjacent workloads. The practical difference that matters most: D1’s caps are daily (5M rows read, 100K rows written) while Turso’s are monthly (500M rows read, 10M rows written). Both meter rows, not requests, so a query that scans a lot of rows costs proportionally more on either - budget by rows touched, not by traffic. A monthly allowance also smooths out bursty days better than a daily one that resets to zero at midnight UTC regardless of how much you used yesterday. If you’re already on Cloudflare Workers, D1’s native binding wins on convenience; otherwise Turso runs anywhere.

The NoSQL options

Amazon DynamoDB’s Always Free tier is the outlier on this whole list: 25 GB of storage, free forever, no expiration - more free storage than any SQL option here. The tradeoff is DynamoDB’s provisioned-capacity model (25 read and 25 write capacity units per month) is a different mental model from “requests per second,” and you’ll need an AWS account to get it.

Cloud Firestore and Firebase Realtime Database are Google’s pair of NoSQL options, both requiring a Google/Firebase account but no credit card for the free Spark plan. Firestore is the more modern of the two (structured documents, richer queries); Realtime Database is the older, simpler key-tree model, still useful for things like live presence or chat where you want raw realtime sync without Firestore’s query overhead.

MongoDB Atlas’s free M0 cluster is the most recognizable name on this list, and its 512 MB storage cap is honest about what it’s for: learning and prototyping, not production. Atlas also throttles free clusters above 100 operations per second rather than hard-stopping them - a detail that’s genuinely on MongoDB’s own pricing FAQ, not a rumor, and worth knowing before you load-test against a free cluster and wonder why response times climb.

Convex is the one entry here that isn’t a bare database in the traditional sense - it’s a reactive backend platform where the database, functions, and realtime subscriptions are one system. 1 million function calls a month on the free plan is generous if your app is doing meaningful logic per request rather than simple CRUD.

The specialty options

Upstash’s free tier is specifically for its Redis product - 256 MB and 500K commands a month, capped at one database per account. If you need a fast in-memory cache or session store alongside a “real” database from this list, Upstash Redis is the natural pairing rather than a standalone replacement.

Aiven deserves a callout for structure, not just numbers: it gives one free instance per service type, and each service has its own separate quota - 1 GB for PostgreSQL, 1 GB for MySQL, 250 kb/s throughput with 3-day retention for Kafka, and 20 GB for OpenSearch. These don’t add up into one combined “Aiven free tier” number; you get up to four small free services, each governed by its own limit, one per type per account.

Which one should you actually use?

Building a typical CRUD app, no strong opinions on engine: Supabase or Neon. Both are full Postgres, both free with no card, and both will outlast a hobby project’s realistic data volume.
Already on Cloudflare Workers: D1. The native binding removes a network hop that every other option on this list would add.
Need the most free storage, don’t care about the interface: DynamoDB’s 25 GB, if you’re comfortable with NoSQL and an AWS account, or CockroachDB’s 10 GiB if you want that much space in SQL.
Multi-tenant SaaS from day one: Nile, since tenant isolation is built into the data model rather than something you enforce in application code.
Just need a cache or session store next to a real database: Upstash Redis.

Whichever you pick, the free tier is a starting point, not a permanent home - track your actual usage against the numbers in the table above, and revisit the choice once you’re consistently within striking distance of a cap.

FAQ

What’s the single most generous free database by storage? Amazon DynamoDB, at 25 GB, if NoSQL fits your data model. For SQL specifically, CockroachDB’s 10 GiB is the largest.

Which free database tiers don’t require a credit card? Cloudflare D1, Supabase, Turso, Neon, CockroachDB, MongoDB Atlas, Prisma Postgres, Upstash, Aiven, Nile, and Convex all let you start with just an email. Cloud Firestore and Firebase Realtime Database also need no card - both run on Firebase’s Spark plan, which states plainly that no payment method is needed, though you will need a Google account. Only DynamoDB and Aurora DSQL require an AWS account, which typically means card details on file at the account level even if the database service itself is free.

Is Render Postgres actually free? Only for 30 days. Render’s free Postgres database expires a month after creation with a two-week grace period to upgrade before deletion - it’s a free trial, not a sustained free tier, which is why it isn’t in the comparison table above.

Does Xata have a free hosted database? Not a perpetual one. Xata’s only ongoing free option is the self-hosted open-source edition you deploy and run yourself; the hosted Xata Cloud product starts with a 14-day trial that requires a credit card to continue.

Can I combine more than one of these for a real project? Commonly, yes - a Postgres option (Supabase or Neon) for primary data, paired with Upstash Redis for caching or rate-limiting, is a normal free-tier stack for a small production app.