Pricing

Billing metrics

Durable Objects are only available on the Workers Paid plan.

	Paid plan
Requests	1 million, + $0.15/million Includes HTTP requests, RPC sessions¹, WebSocket messages², and alarm invocations
Duration³	400,000 GB-s, + $12.50/million GB-s^4,5

¹ Each RPC session is billed as one request to your Durable Object. Every RPC method call on a Durable Objects stub is its own RPC session and therefore a single billed request.

RPC method calls can return objects (stubs) extending RpcTarget and invoke calls on those stubs. Subsequent calls on the returned stub are part of the same RPC session and are not billed as separate requests. For example:

let durableObjectStub = OBJECT_NAMESPACE.get(id); // retrieve Durable Object stub
using foo = await durableObjectStub.bar(); // billed as a request
await foo.baz(); // treated as part of the same RPC session created by calling bar(), not billed as a request
await durableObjectStub.cat(); // billed as a request

² A request is needed to create a WebSocket connection. There is no charge for outgoing WebSocket messages, nor for incoming WebSocket protocol pings ↗. For compute requests billing-only, a 20:1 ratio is applied to incoming WebSocket messages to factor in smaller messages for real-time communication. For example, 100 WebSocket incoming messages would be charged as 5 requests for billing purposes. The 20:1 ratio does not affect Durable Object metrics and analytics, which reflect actual usage.

³ Application level auto-response messages handled by state.setWebSocketAutoResponse() will not incur additional wall-clock time, and so they will not be charged.

⁴ Duration is billed in wall-clock time as long as the Object is active, but is shared across all requests active on an Object at once. Once your Object finishes responding to all requests, it will stop incurring duration charges. Calling accept() on a WebSocket in an Object will incur duration charges for the entire time the WebSocket is connected. If you prefer, use state.acceptWebSocket() instead, which will stop incurring duration charges once all event handlers finish running.

⁵ Duration billing charges for the 128 MB of memory your Durable Object is allocated, regardless of actual usage. If your account creates many instances of a single Durable Object class, Durable Objects may run in the same isolate on the same physical machine and share the 128 MB of memory. These Durable Objects are still billed as if they are allocated a full 128 MB of memory.

Durable Objects billing examples

These examples exclude the costs for the Workers calling the Durable Objects. When modelling the costs of a Durable Object, note that:

Inactive objects receiving no requests do not incur any duration charges.
The WebSocket Hibernation API can dramatically reduce duration-related charges for Durable Objects communicating with clients over the WebSocket protocol, especially if messages are only transmitted occasionally at sparse intervals.

Example 1

This example represents a simple Durable Object used as a co-ordination service invoked via HTTP.

A single Durable Object was called by a Worker 1.5 million times
It is active for 1,000,000 seconds in the month

In this scenario, the estimated monthly cost would be calculated as:

Requests:

(1.5 million requests - included 1 million requests) x $0.15 / 1,000,000 = $0.075

Compute Duration:

1,000,000 seconds * 128 MB / 1 GB = 128,000 GB-s
(128,000 GB-s - included 400,000 GB-s) x $12.50 / 1,000,000 = $0.00

Estimated total: ~$0.075 (requests) + $0.00 (compute duration) + minimum $5/mo usage = $5.08 per month

Example 2

This example represents a moderately trafficked Durable Objects based application using WebSockets to broadcast game, chat or real-time user state across connected clients:

100 Durable Objects have 50 WebSocket connections established to each of them.
Clients send approximately one message a minute for eight active hours a day, every day of the month.

In this scenario, the estimated monthly cost would be calculated as:

Requests:

50 WebSocket connections * 100 Durable Objects to establish the WebSockets = 5,000 connections created each day * 30 days = 150,000 WebSocket connection requests.
50 messages per minute * 100 Durable Objects * 60 minutes * 8 hours * 30 days = 72,000,000 WebSocket message requests.
150,000 + (72 million requests / 20 for WebSocket message billing ratio) = 3.75 million billing request.
(3.75 million requests - included 1 million requests) x $0.15 / 1,000,000 = $0.41.

Compute Duration:

100 Durable Objects * 60 seconds * 60 minutes * 8 hours * 30 days = 86,400,000 seconds.
86,400,000 seconds * 128 MB / 1 GB = 11,059,200 GB-s.
(11,059,200 GB-s - included 400,000 GB-s) x $12.50 / 1,000,000 = $133.24.

Estimated total: $0.41 (requests) + $133.24 (compute duration) + minimum $5/mo usage = $138.65 per month.

Example 3

This example represents a horizontally scaled Durable Objects based application using WebSockets to communicate user-specific state to a single client connected to each Durable Object.

100 Durable Objects each have a single WebSocket connection established to each of them.
Clients sent one message every second of the month so that the Durable Objects were active for the entire month.

In this scenario, the estimated monthly cost would be calculated as:

Requests:

100 WebSocket connection requests.
1 message per second * 100 connections * 60 seconds * 60 minutes * 24 hours * 30 days = 259,200,000 WebSocket message requests.
100 + (259.2 million requests / 20 for WebSocket billing ratio) = 12,960,100 requests.
(12.9 million requests - included 1 million requests) x $0.15 / 1,000,000 = $1.79.

Compute Duration:

100 Durable Objects * 60 seconds * 60 minutes * 24 hours * 30 days = 259,200,000 seconds
259,200,000 seconds * 128 MB / 1 GB = 33,177,600 GB-s
(33,177,600 GB-s - included 400,000 GB-s) x $12.50 / 1,000,000 = $409.72

Estimated total: $1.79 (requests) + $409.72 (compute duration) + minimum $5/mo usage = $416.51 per month

Example 4

This example represents a moderately trafficked Durable Objects based application using WebSocket Hibernation to broadcast game, chat or real-time user state across connected clients:

100 Durable Objects each have 100 Hibernatable WebSocket connections established to each of them.
Clients send one message per minute, and it takes 10ms to process a single message in the webSocketMessage() handler. Since each Durable Object handles 100 WebSockets, cumulatively each Durable Object will be actively executing JS for 1 second each minute (100 WebSockets * 10ms).

In this scenario, the estimated monthly cost would be calculated as:

Requests:

100 WebSocket connections * 100 Durable Objects to establish the WebSockets = 10,000 initial WebSocket connection requests.
100 messages per minute¹ * 100 Durable Objects * 60 minutes * 24 hours * 30 days = 432,000,000 requests.
10,000 + (432 million requests / 20 for WebSocket billing ratio) = 21,610,000 million requests.
(21.6 million requests - included 1 million requests) x $0.15 / 1,000,000 = $3.09.

Compute Duration:

100 Durable Objects * 1 second² * 60 minutes * 24 hours * 30 days = 4,320,000 seconds
4,320,000 seconds * 128 MB / 1 GB = 552,960 GB-s
(552,960 GB-s - included 400,000 GB-s) x $12.50 / 1,000,000 = $1.91

Estimated total: $3.09 (requests) + $1.91 (compute duration) + minimum $5/mo usage = $10.00 per month

¹ 100 messages per minute comes from the fact that 100 clients connect to each DO, and each sends 1 message per minute.

² The example uses 1 second because each Durable Object is active for 1 second per minute. This can also be thought of as 432 million requests that each take 10 ms to execute (4,320,000 seconds).

Storage API billing

The Durable Objects Storage API is only accessible from within Durable Objects.

Durable Objects do not have to use the Storage API, but if your code does call methods on ctx.storage, it will incur additional charges.

Pricing depends on whether a Durable Object class has default, key-value storage backend or opt-in SQLite storage backend.

Key-value storage backend

	Workers Paid plan
Read request units^1,2	1 million, + $0.20/million
Write request units³	1 million, + $1.00/million
Delete requests⁴	1 million, + $1.00/million
Stored data⁵	1 GB, + $0.20/ GB-month

¹ A request unit is defined as 4 KB of data read or written. A request that writes or reads more than 4 KB will consume multiple units, for example, a 9 KB write will consume 3 write request units.

² List operations are billed by read request units, based on the amount of data examined. For example, a list request that returns a combined 80 KB of keys and values will be billed 20 read request units. A list request that does not return anything is billed for 1 read request unit.

³ Each setAlarm is billed as a single write request unit.

⁴ Delete requests are unmetered. For example, deleting a 100 KB value will be charged one delete request.

⁵ Durable Objects will be billed for stored data until the data is removed. Once the data is removed, the object will be cleaned up automatically by the system.

Requests that hit the Durable Objects in-memory cache or that use the multi-key versions of get()/put()/delete() methods are billed the same as if they were a normal, individual request for each key.

SQLite storage backend

The new beta version of Durable Objects is available where each Durable Object has a private, embedded SQLite database. When deploying a new Durable Object class, users can opt-in to a SQLite storage backend in order to access new SQL API.

During the initial beta, Storage API billing is not enabled for Durable Object classes using SQLite storage backend. SQLite-backed Durable Objects will incur charges for requests and duration. We plan to enable Storage API billing for Durable Objects using SQLite storage backend in the first half of 2025 after advance notice with the below pricing.

You can introspect rows read and rows written using cursor.rowsRead and cursor.rowsWritten on the cursor returned by a SQL query and using GraphQL analytics. ctx.storage.sql.databaseSize returns the current SQL database size for a Durable Object.

For Durable Objects classes with SQLite storage backend via ctx.storage.sql the following pricing is used instead:

	Workers Paid plan
Rows reads ^1,2	First 25 billion / month included + $0.001 / million rows
Rows written ^1,2	First 50 million / month included + $1.00 / million rows
SQL Stored data	5 GB-month, + $0.20/ GB-month

¹ Rows read and rows written included limits and rates match D1, Cloudflare’s serverless SQL database, pricing.

² Key-value methods like get(), put(), delete(), or list() store and query data in a hidden SQLite table and are billed as rows read and rows written.

³ Each setAlarm is billed as a single row written.

Cloudflare Dashboard Discord Community Learning Center Support Portal

Cookie Settings