This document explainsCloud Firestore pricing details.

If you pay in a currency other than USD, the prices listed in your currency onCloud Platform SKUs apply.

Pricing overview

When you useCloud Firestore, you are charged for the following:

• The number of documents you read, write, and delete.
• The number of index entries read to satisfy a query.See more details about index reads.
• The amount of storage that your database uses, including overhead formetadata and indexes.
• The amount of network bandwidth that you use.

Storage and bandwidth usage are calculated in gibibytes (GiB), where 1 GiB =2³⁰ bytes. All charges accrue daily.

The following sections provide details about how you are charged for yourCloud Firestore usage.

Free quota

Cloud Firestore offers free quota that lets you get started at no cost.If you need more quota, you mustenable billing for yourGoogle Cloud project.

Quotas are applied daily and reset around midnight Pacific time.

Important:Cloud Firestore allowsexactly one free database perproject.

The following table summarizes free quota amounts:

Free tier	Quota
Stored data	1 GiB
Document reads	50,000 per day
Document writes	20,000 per day
Document deletes	20,000 per day
Outbound data transfer	10 GiB per month

The following operations and features don't include free usage. You must enablebilling to use these features:

• TTL deletes
• PITR data
• Backup data
• Restore operations
• Clone operations

For more information about how these features are billed, seeStorage pricing.

Pricing by location

To view pricing for reads, writes, deletes, and storage foreachCloud Firestore location, seeGoogle Cloud pricing.

If you pay in a currency other than USD, the prices listed in your currency onCloud Platform SKUs apply.

Free quota applies only to one database per project

Projects can have only one database that qualifies for the free quota.

To create additional databases, you must upgrade your project's billingplan.

The first database you create (regardless of its ID) qualifies for the freequota. If you delete that database, the next database you create becomes the newdatabase eligible for the free quota.

There's no additional cost to you for creating or deleting databases.All subsequent database will be charged on usage incurred on those databases.

Reads, writes, and deletes

You are charged for documents and index entries read to satisfy a query. You arecharged for each document write and delete that you perform.

Charges for writes and deletes are straightforward. For writes, eachset orupdate operation counts as a single write.

Charges for read operations have somenuances that you should keep in mind. The following sections explain thesenuances in detail.

Index entry reads

You are charged one read operation for each batch of up to 1000 index entriesread by a query except in the following:

Note: You can useFirestore Query Explain to confirm if aquery charges index entries read.

• For K-nearest neighbor vector search queries, you are charged oneread operation for each batch of up to 100 kNN vector index entries read by the query.

  For example, if the following vector search query withlimit: 5returns 5 documents and reads 1550 kNN vector index entries,you are billed 5 read operations for the documents returned and 16 readoperations for the index entries:

  //Requiressingle-fieldvectorindexconstvectorQuery:VectorQuery=db.collection('cities').findNearest('embedding_field',FieldValue.vector([3.0,1.0,2.0]),{limit:5,distanceMeasure:'EUCLIDEAN'});

• Queries that have up to one range field are not charged for index entriesread.

  For example, the following query contains one equality field (age) and onerange field (start_date) and is not charged for index entries read:

  db.collection("employees").whereEqualTo("age", 35)                          .whereGreaterThanOrEqualTo("start_date", new Date(2020, 1, 1))

  The following query contains two range fields (age andstart_date) and ischarged for index entries reads:

  db.collection("employees").whereGreaterThanOrEqualTo("age", 35)                          .whereGreaterThanOrEqualTo("start_date", new Date(2020, 1, 1))

  A field that appears in the order by clause is considered a range field whenthere is at least one other range field in the query.Therefore the following query contains two range fields(age andstart_date) and is charged for index entries reads:

  db.collection("employees").whereGreaterThanOrEqualTo("age", 35)                          .orderBy("start_date")

  The__name__ field is always considered a range field, even if it is onlyused in an equality filter. Therefore the following query contains two rangefields (age and__name__) and is charged for index entries reads:

  db.collection("employees").whereIn("__name__", Arrays.asList("/employees/Alice", "/employees/Bob"))                          .orderBy("age")

Aggregation queries

Foraggregation queriessuch ascount(),sum(), andavg(),you are charged for index entries read by the query asdescribed above. For aggregation queries that read 0 indexentries, there is a minimum charge of one document read.

For example,count() operations that read between 0 and 1000 index entriesare billed for one document read. For acount() operation that reads 1500index entries, you are billed 2 document reads.

To learn more about the indexes used and the index entries read, useQuery Explain.

Listening to query results

Cloud Firestore allows you tolisten to the results of aquery and get realtime updates when the query results change.

When you listen to the results of a query, you are charged for a read each timea document in the result set is added or updated. You are also charged for aread when a document is removed from the result set because the document haschanged. (In contrast, when a document is deleted, you are not charged for aread.)

Billing of listeners in the mobile and web SDKS also depends on whetheroffline persistence is enabled or not:

• If offline persistence is enabled and the listener is disconnected formore than 30 minutes (for example, if the user goes offline), you will becharged for documents and index entries read as if you had issued a brand-newquery.

• If offline persistence is disabled, you will be charged for documents andindex entries read as if you had issued a brand-new query whenever thelistener disconnects and reconnects.

Note: Queries with up to one range field are exempted from charging for indexentries read. Seehere for details.

Managing large result sets

Cloud Firestore has several features to help you manage queries thatreturn a large number of results:

• Cursors, which allow you to resume a long-running query.
• Page tokens, which help you paginate the query results.
• Limits, which specify how many results to retrieve.
• Offsets, which allow you to skip a fixed number of documents.

There are no additional costs for using cursors, page tokens, and limits. Infact, these features can help you save money by reading only the documents thatyou actually need.

However, when you send a query that includes an offset, you are charged a readfor each skipped document. For example, if your query uses an offset of 10, andthe query returns 1 document, you are charged for 11 reads. Because of thisadditional cost, you should use cursors instead of offsets whenever possible.

Queries other than document reads

For queries other than document reads, such as a request for a list ofcollection IDs, you are billed for one document read. If fetching the completeset of results requires more than one request (for example, if you are usingpagination), you are billed once per request.

Minimum charge for queries

There is a minimum charge of one document read for each query that you perform,even if the query returns no results.

Cloud Firestore Security Rules

For mobile and web client libraries, if yourCloud Firestore Security Rules useexists(),get(), orgetAfter() to readone or more documents from your database, you are charged for additional readsas follows:

• You are charged for reads that are necessary to evaluate yourCloud Firestore Security Rules.

  For example, if your rules refer to three documents, butCloud Firestore only has to read two of those documents to evaluateyour rules, you will be charged for two additional reads for the dependentdocuments.

  You are only charged one read per dependent document even if your rulesrefer to that document more than once.

• You are charged for rule evaluation only once per request.

  As a result, it can cost less to read multiple documents than to readdocuments one at a time, because reading multiple documents requires fewerrequests.

• When you listen to the results of a query, you are charged for rule evaluationin all of the following cases:

  • When you issue the query.
  • Each time the query results are updated.
  • Any time the user's device goes offline, then comes back online.
  • Any time you update your rules.
  • Any time you update the dependent documents in your rules.

Database storage size

You are charged for the amount of data that you store inCloud Firestore,including storage overhead. The amount of overhead includes metadata, automaticindexes, and composite indexes.

Each document stored inCloud Firestore requires the following metadata:

• The document ID, including the collection ID and the document name.
• The name and value of each field. BecauseCloud Firestore isschemaless, the name of each field in a document must be stored with the fieldvalue.
• Any single-field and composite indexes that refer to the document. Each indexentry contains the collection ID; any number of field values, depending on theindex definition; and the document name.

Storage costs are in GiB/month and calculated daily.Cloud Firestoremeasures the database size daily. Over the period of a month,these sample points are averaged to calculate the database storage size.This average value is multiplied by the unit price of storage (GiB-month)

Learn howCloud Firestore storage is calculated atStorage SizeCalculations.

PITR data

If you enablePITR, you are charged for the storage of PITRdata. Most customers will find that the overall cost of PiTR data storage issimilar to the storage cost of the database.

Note: PITR data is billed separately from the database storage size billing. PITR data doesn't affect yourdata storage size costs.

Storage costs for PITR are in GiB/month andcalculated daily.Cloud Firestore measures the database size daily. Overthe period of a month, these sample points are averaged to calculate thedatabase storage size. This average value is multiplied by the unit price ofPITR (GiB-month).

For example, if the average size of your database during amonth is 1 GiB and PITR is enabled for the whole month, then the billable PITRdata size is 1 GiB as well.

Minimum billing: You may be charged up to 1 day of PITR storage cost even if youdisable PITR within a day after enablement.

Backup data and restore operations

If you enablebackups, you are charged for the storage ofyour database backups. The storage size for a backup is equal to the storagesize of the database when the backup was taken.

Storage costs for backups are in GiB/month. Over the period of a month, thenumber of days for which each backup is retained, averaged over the month is alsocalculated. The cost of each backup is calculated using the storage size of thebackup multiplied by the proportion of the month the backup is retained,multiplied by the unit price. Day boundaries are defined by the America/Los_Angeles time zone forbilling purposes.

When you perform a restore operation,Cloud Firestore measures thesize of the backup for the restore operation. The size of the backup ismultiplied by the unit price of restore operations (GiB).

Query Explain

Use ofFirestore Query Explain incurs costs.

When a query is explained with the default option, no index read operations areperformed. Regardless of query complexity, one read operation is charged.

When a query is explained with the analyze option, index and readoperations are performed, so you are charged for the query as usual. There is noadditional charge for the explain and analyze activity, only the usual chargefor the query being executed.

Network bandwidth

You are charged for the network bandwidth used by yourCloud Firestorerequests, as shown in the following sections. The network bandwidth cost of aCloud Firestore request depends on the request’s response size, thelocation of yourCloud Firestore database, and the destination of theresponse.

Cloud Firestore calculates response size based on a serialized messageformat. Protocol overhead, such as SSL overhead, does not count towards networkbandwidth usage. Requests denied by yourCloud Firestore Security Rules do not counttowards network bandwidth usage.

To learn how much networkbandwidth you have used, you can use the Google Cloud console toexport yourbilling data to a file.

General network pricing

For requests that originate within Google Cloud Platform (for example, from anapplication running on Google Compute Engine), you are charged as follows:

Traffic type	Price
Inbound data transfer	Free
Data transfer within a region	Free
Data transfer between regions in the same multi-region	Free
Data transfer between regions within the US (per GiB)	$0.01 (first 10 GiB per month are free)
Data transfer between regions, not including traffic between US regions	Google Cloud Platform outbound internet data transfer rates

If you pay in a currency other than USD, the prices listed in your currency onCloud Platform SKUs apply.

Cloud Firestore is also subject to additional internet egress charges forthe following:

• Google Cloud requests between regions, not including traffic between USregions
• Requests from outside ofGoogle Cloud (for example, from a user's mobiledevice)

SeeGoogle Cloud internet egress rates.

See a pricing example

To see howCloud Firestore billing costs accrue in a real-world sampleapp, see theCloud Firestore billing example.

Manage spending

To help avoid unexpected charges on your bill, setmonthly budgets and alerts usingGoogle Cloud's billing console.

To monitor yourCloud Firestore usage, open theCloud FirestoreUsage tabin the Firebase Console. Use the dashboard to gauge your usageover different time periods.