Firestore · April 2026

Cloud Firestore Pricing: Reads, Writes, Storage, and Free Tier Explained (2026)

Firestore charges per operation — reads, writes, and deletes. The free tier is generous for small apps. The traps emerge at scale. Here's everything you need to know to predict your Firestore bill.

Quick Answer — Firestore Free Tier
50,000
Reads / day
20,000
Writes / day
20,000
Deletes / day
1 GiB
Storage

Daily limits reset at midnight Pacific Time. Storage and egress limits are monthly.

Free Tier in Plain Terms — Is Your App Free?

50,000 reads per day sounds like a lot. Whether it's enough depends entirely on how your app is structured. Here are three real examples:

News reader app
500 users, each loading a feed of 20 articles per day
500 users × 20 reads = 10,000 reads/day
Comfortably within free tier. $0/month.
Social app — moderate usage
500 users, each loading 200 posts per session, 1 session per day
500 users × 200 reads = 100,000 reads/day
2× the free tier. ~$0.06–$0.12/day ≈ $2–$4/month on Blaze.
Social app — heavy usage
500 users, loading 200 posts per session, 3 sessions per day
500 users × 600 reads = 300,000 reads/day
6× over free tier. ~$0.15/day ≈ $4.50/month. Reads are $0.06/100K beyond free.

Firestore Cost by Operation — Complete Pricing Table

OperationSpark free tierBlaze — price beyond free tier
Document reads50,000 / day
Document writes20,000 / day
Document deletes20,000 / day
Storage1 GiB
Network egress10 GB / month (shared)

Source: firebase.google.com/pricing · Verified April 2026 · Prices may vary by GCP region (above are default multi-region)

The Reads Problem: How Fanout Queries Create Unexpected Costs

The most common cause of unexpected Firestore bills is a real-time listener attached to a large collection. Here's how the numbers escalate faster than most developers expect:

Fanout read scenario

A collection of 5,000 documents with a real-time listener. Each time any document in the collection changes, Firestore re-delivers all changed documents. With 10 writes per minute: 5,000 affected reads × 10 writes/minute × 60 minutes/hour = 3,000,000 reads/hour. The entire daily free tier consumed every minute.

Here's the difference between an expensive pattern and an efficient one:

Expensive — collection listener
// Listens to ALL documents in the
// collection. Every write triggers
// a re-read of every document.
const unsub = db
  .collection("messages")
  .onSnapshot(snapshot => {
    // snapshot contains ALL docs
    renderMessages(snapshot.docs);
  });
Efficient — targeted query
// Listens only to messages after
// a timestamp. Reads scale with
// new messages, not collection size.
const unsub = db
  .collection("messages")
  .where("createdAt", ">", lastRead)
  .orderBy("createdAt")
  .onSnapshot(snapshot => {
    appendMessages(snapshot.docs);
  });
Multi-database note (Blaze only)

Only the first Firestore database in a project qualifies for the free tier quota. If you create additional databases — a Blaze-only feature — those are billed at pay-as-you-go rates from the very first operation with no free tier applied.

Firestore Cost Optimisation Tips

1
Enable offline persistence
Firebase's offline persistence caches documents locally using IndexedDB. Subsequent reads of cached documents don't count against your Firestore read quota. High impact for apps where users repeatedly view the same data.
High impact
2
Use targeted queries instead of collection listeners
Replace real-time listeners on large collections with .get() calls or listeners scoped to specific documents or small subsets. The difference in reads can be orders of magnitude.
Very high impact
3
Paginate large queries
Use startAfter() and limit() to paginate through large collections. Loading 20 documents at a time costs 20 reads; loading 10,000 documents costs 10,000 reads. Never load more than you need to display.
High impact
4
Use composite indexes for queries
Properly indexed queries scan only matching documents. Without indexes, Firestore may scan an entire collection to satisfy a query. Check the Firebase console for suggested indexes.
Medium impact
5
Denormalise data to reduce reads
In a NoSQL database, it's often better to store pre-aggregated data in a document rather than making multiple reads to compute a value. Example: store a message count in a user document rather than counting all messages in a subcollection.
Medium impact
6
Use the Firestore emulator to test locally
The Firebase Emulator Suite shows real-time read and write counts as you develop. Use it to catch read-heavy patterns before they reach production.
Diagnostic

Estimate Your Firestore Cost

Firebase Cost CalculatorNo login required
Blaze planPay-as-you-go
$0.00 / month
Estimate. Excludes taxes and additional GCP charges.

Monthly reads: 750,000 · Monthly writes: 150,000 · Free tier: 50,000 reads/day, 20,000 writes/day

Frequently Asked Questions

Yes, within the free tier limits. The Spark (free) plan includes 50,000 document reads/day, 20,000 writes/day, 20,000 deletes/day, and 1 GiB of storage. These limits reset daily. If your app stays within these limits, you pay nothing — no credit card required.
← Firebase Pricing CalculatorSpark vs Blaze comparisonHidden Costs Guide →Cloud Functions Pricing →