See a Cloud Firestore pricing example

Use this real-world example of a basic chat app to gauge your Cloud Firestore usage and costs. This is not an exact estimate, but it can help you better understand how your Cloud Firestore usage is billed.

Overview: Costs by usage level

To illustrate typical costs, consider an example chat app, where users can initiate chats with two or more participants. Users can see their active chats in a list, read messages, and send messages. For this example, we're using pricing for the North America multi-region (specifically nam5).

Assumptions

Consider the following assumptions about usage and data storage:

• Daily Active Users (DAUs) are 10% of total app installations. You can estimate your daily costs using a rough estimate of your Daily Active Users (DAUs). These are the users that actively open and use your app on a given day, which is typically a small subset of your total app installations. For the calculations below, we estimated DAUs as 10% of the total number of app installations.
• Document sizes are relatively small. See the table below for a breakdown of document size by type.
• Data is only stored for three months. The messages in the example chat app are only stored for a three-month period. To account for the delete operations, the calculations below show a daily delete for every daily write.
• These cost estimates reflect the bulk of the example app's costs, but not all of them. We've accounted for the bulk of an app's costs by calculating operations, user and message storage, and egress for the most frequent user tasks outlined in this guide. However, you might need to take into account additional costs, depending on your app's structure and data needs. Use this example to guide your calculations, but refer to the pricing page for more thorough explanations of Cloud Firestore costs.

For a breakdown of operations by user task, see the Breakdown: Billed usage by user task section.

A benefit of the Cloud Firestore billing model worth considering is that you only pay for what you use. As a result, your bill may grow and shrink with your DAU count.

Breakdown: Billed usage by user task

For our example chat app, the data structure is as follows:

• users/{userId} — User records
• groups/{groupId} — Chats between 2 or more users
  • messages/{messageId} — Each message in a chat.

Data storage

To calculate the storage costs for storing the app's data, apply the following assumptions about document sizes:

*This size calculation includes indexes for the message fields, but assumes indexing is disabled for message content.

The app also only stores messages that are up to three months old, to lower storage costs.

For more information on calculating storage costs, see Understanding storage size calculations.

Operations

Users typically complete the following common tasks in the app:

• See the list of chats: Users open the home screen of the app and see a list of chats (group and direct) ordered by the most recent message posted.
• Read messages in a chat: Users select chats from the home screen and read recent messages from chats.
• Send a message to a chat: Users send messages to chats (group or direct).

The example app's total estimated operations in Cloud Firestore for the three typical user tasks are as follows:

• Reads: (5 * 10) + (30) = 80 reads / user / day
• Writes: (10 * 2) = 20 writes / user / day
• Network Egress: (50 * 0.25KB) + (30 * 0.25KB) = 20KB / user / day
• Storage: (20 * 0.75KB) = 15 KB / user / day

Total usage by user task

Select each user task to see a full description and breakdown of the operations, storage, and networking costs in the app.

db.collection('groups')
  .where('participants', 'array-contains', 'user123')
  .where('lastUpdated', '>', lastFetchTimestamp)
  .orderBy('lastUpdated', 'desc')
  .limit(25)

db.collection('groups')
  .doc('group234')
  .collection('messages')
  .where('sentTime', '>', lastFetchTimestamp)
  .orderBy('sentTime', 'desc')
  .limit(50)

Billed usage for administrator tasks

As an app owner or administrator you probably want to generate reports from your app's data. For example, you might want to keep a daily count of the number of messages sent by your users. You can accomplish this with a count() aggregation of the messages collection group.

For aggregation queries such as count(), you are charged one document read for each batch of up to 1,000 index entries matched by the query. Running this daily aggregation adds the following monthly charges:

Included benefits: No-cost services for your app

While Cloud Firestore operations, storage, and network bandwidth are all considered billable usage, you also get a variety of other benefits at no additional cost. Consider the following services that are at no cost as you compare Cloud Firestore to other database options:

• Direct client access: Cloud Firestore is accessed directly from your client code using our native SDKs. This means you don't need to build and run an API server to connect your mobile clients to the database.
• Load balancing: Since Cloud Firestore scales automatically to support traffic to your database, you don't have to run a load balancer.
• Server uptime: Cloud Firestore databases operate on Google Cloud servers, offering over 99% monthly uptime.
• Authentication: Authenticate unlimited users simply and securely with Firebase Authentication. Firebase Authentication integrates directly with Cloud Firestore so you don't need to run your own authentication service.
• Push notifications: Send messages and notifications with Cloud Messaging.
• Other Firebase products: Integrate other Firebase products at no cost, including A/B Testing, Analytics, Crashlytics, Performance Monitoring, and Remote Config. Learn more about other Firebase products and Firebase pricing.