Updating pricing table, removing beta SQLite DO

Oxyjun · Oxyjun · commit b7691a6661f3 · 2025-03-13T12:30:20.000Z
notes from some pages, WIP.
diff --git a/src/content/docs/durable-objects/api/sql-storage.mdx b/src/content/docs/durable-objects/api/sql-storage.mdx
@@ -33,7 +33,7 @@ export class MyDurableObject extends DurableObject {
 }
 ```
 
-:::note[SQLite in Durable Objects Beta]
+:::note[SQLite in Durable Objects]
 SQL API methods accessed with `ctx.storage.sql` are only allowed on [Durable Object classes with SQLite storage backend](/durable-objects/reference/durable-objects-migrations/#enable-sqlite-storage-backend-on-new-durable-object-class-migration) and will return an error if called on Durable Object classes with a key-value storage backend.
 :::
 
@@ -161,7 +161,7 @@ Providing a type parameter does _not_ validate that the query result matches you
 
 Your type must conform to the shape of a TypeScript [Record](https://www.typescriptlang.org/docs/handbook/utility-types.html#recordkeys-type) type representing the name (`string`) of the column and the type of the column. The column type must be a valid `SqlStorageValue`: one of `ArrayBuffer | string | number | null`.
 
-For example, 
+For example,
 
 ```ts
 type User = {
diff --git a/src/content/docs/durable-objects/api/storage-api.mdx b/src/content/docs/durable-objects/api/storage-api.mdx
@@ -51,10 +51,10 @@ export class Counter extends DurableObject {
 
 ## Methods
 
-:::note[SQLite in Durable Objects Beta]
-
-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](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend) to access the new [SQL API](/durable-objects/api/sql-storage/#exec). Otherwise, a Durable Object class has a key-value storage backend.
+:::note[SQLite in Durable Objects]
+SQLite-backed Durable Objects can have a private, embedded SQLite database. When deploying a new Durable Object class, users can [use a SQLite storage backend](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend) to access the [SQL API](/durable-objects/api/sql-storage/#exec).
 
+Otherwise, a Durable Object class has a key-value storage backend.
 :::
 
 The Durable Object Storage API comes with several methods, including key-value (KV) API, SQL API, and point-in-time-recovery (PITR) API.
@@ -263,4 +263,4 @@ The `put()` method returns a `Promise`, but most applications can discard this p
 
 - [Durable Objects: Easy, Fast, Correct – Choose Three](https://blog.cloudflare.com/durable-objects-easy-fast-correct-choose-three/)
 - [WebSockets API](/durable-objects/best-practices/websockets/)
-```
+
diff --git a/src/content/docs/durable-objects/get-started/tutorial-with-sql-api.mdx b/src/content/docs/durable-objects/get-started/tutorial-with-sql-api.mdx
@@ -16,12 +16,6 @@ This guide will instruct you through:
 
 If you wish to learn more about Durable Objects, refer to [What are Durable Objects?](/durable-objects/what-are-durable-objects/).
 
-:::note[SQLite in Durable Objects Beta]
-
-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](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend) in order to access new [SQL API](/durable-objects/api/sql-storage/#exec), part of Durable Objects Storage API.
-
-:::
-
 ## Prerequisites
 
 <Render file="prereqs" product="workers" />
diff --git a/src/content/docs/durable-objects/index.mdx b/src/content/docs/durable-objects/index.mdx
@@ -31,14 +31,6 @@ For more information, refer to the full [What are Durable Objects?](/durable-obj
 
 <LinkButton href="/durable-objects/get-started/tutorial/">Get started</LinkButton>
 
-:::note[SQLite in Durable Objects Beta]
-
-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](/durable-objects/best-practices/access-durable-objects-storage/#sqlite-storage-backend) in order to access new [SQL API](/durable-objects/api/sql-storage/#exec) and [point-in-time-recovery API](/durable-objects/api/sql-storage/#point-in-time-recovery), part of Durable Objects Storage API.
-
-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](/durable-objects/platform/pricing/#billing-metrics). 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 following [pricing](/durable-objects/platform/pricing/#sqlite-storage-backend).
-
-:::
-
 ***
 
 ## Features
diff --git a/src/content/docs/durable-objects/platform/pricing.mdx b/src/content/docs/durable-objects/platform/pricing.mdx
@@ -8,18 +8,20 @@ sidebar:
 
 import { Render } from "~/components"
 
-## Billing metrics
+Durable Objects can incur two types of billing: compute and storage.
 
-<Render file="durable_objects_pricing" product="durable-objects" />
+## Compute billing
 
-## Durable Objects billing examples
+<Render file="durable-objects-pricing" product="durable-objects" />
+
+### Compute 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](/durable-objects/best-practices/websockets/#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
+#### Example 1
 
 This example represents a simple Durable Object used as a co-ordination service invoked via HTTP.
 
@@ -39,7 +41,7 @@ In this scenario, the estimated monthly cost would be calculated as:
 
 **Estimated total**: \~$0.075 (requests) + $0.00 (compute duration) + minimum $5/mo usage = $5.08 per month
 
-### Example 2
+#### 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:
 
@@ -63,7 +65,7 @@ In this scenario, the estimated monthly cost would be calculated as:
 
 **Estimated total**: $0.41 (requests) + $133.24 (compute duration) + minimum $5/mo usage = $138.65 per month.
 
-### Example 3
+#### 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.
 
@@ -87,7 +89,7 @@ In this scenario, the estimated monthly cost would be calculated as:
 
 **Estimated total**: $1.79 (requests) + $409.72 (compute duration) + minimum $5/mo usage = $416.51 per month
 
-### Example 4
+#### 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:
 
@@ -117,7 +119,7 @@ In this scenario, the estimated monthly cost would be calculated as:
 
 ## Storage API billing
 
-<Render file="storage_api_pricing" product="workers" />
+<Render file="do_storage_api_pricing" product="workers" />
 
 ## Frequently Asked Questions
 
diff --git a/src/content/docs/durable-objects/reference/durable-objects-migrations.mdx b/src/content/docs/durable-objects/reference/durable-objects-migrations.mdx
@@ -272,12 +272,6 @@ You can rename the `DurableObjectExample` class to `UpdatedName` and delete an o
 
 ## Enable SQLite storage backend on new Durable Object class migration
 
-:::note[SQLite in Durable Objects Beta]
-
-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](/durable-objects/api/sql-storage/#exec). Otherwise, a Durable Object class has a key-value storage backend.
-
-:::
-
 To allow a new Durable Object class to use a SQLite storage backend, use `new_sqlite_classes` on the migration in your Worker's `wrangler` configuration file:
 
 <WranglerConfig>
diff --git a/src/content/docs/workers/platform/pricing.mdx b/src/content/docs/workers/platform/pricing.mdx
@@ -162,7 +162,7 @@ To learn more about Queues pricing and review billing examples, refer to [Queues
 
 ## D1
 
-D1 is available on both the [Workers Free](#workers) and [Workers Paid](#workers) plans.
+D1 is available on both the Workers Free and Workers Paid plans.
 
 <Render file="d1-pricing" />
 
@@ -174,7 +174,7 @@ Refer to [D1 Pricing](/d1/platform/pricing/) to learn more about how D1 is bille
 
 ## Durable Objects
 
-Durable Objects are available on both the [Workers Free](#workers) and [Workers Paid](#workers) plans.
+Durable Objects are available on both the Workers Free and Workers Paid plans.
 
 <Render file="durable_objects_pricing" product="durable-objects" />
 
@@ -186,7 +186,7 @@ For more information and [examples of Durable Objects billing](/durable-objects/
 
 ## Durable Objects Storage API
 
-<Render file="storage_api_pricing" />
+<Render file="do_storage_api_pricing" />
 
 ## Vectorize
 
diff --git a/src/content/docs/workers/platform/storage-options.mdx b/src/content/docs/workers/platform/storage-options.mdx
@@ -207,12 +207,6 @@ To get started with Vectorize:
 
 <Render file="durable-objects-vs-d1" product="durable-objects" />
 
-:::note[SQLite in Durable Objects Beta]
-
-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 using SQL storage in order to access [Storage SQL API methods](/durable-objects/api/sql-storage/#exec). Otherwise, a Durable Object class has the standard, private key-value storage.
-
-:::
-
 <Render file="kv-vs-d1" product="kv" />
 
 ## D1 vs Hyperdrive
diff --git a/src/content/partials/durable-objects/durable-objects-pricing.mdx b/src/content/partials/durable-objects/durable-objects-pricing.mdx
@@ -2,14 +2,16 @@
 {}
 ---
 
-import { Markdown, GlossaryTooltip } from "~/components";
+import { Markdown, GlossaryTooltip, Details } from "~/components";
 
-[Durable Objects](/durable-objects/) are available on both the Workers Free and [Workers Paid plans](/workers/platform/pricing/#workers), and are billed while the Durable Object is active (including the <GlossaryTooltip term="request context"> request context</GlossaryTooltip>).
+Durable Objects are billed only while the Durable Object is active (includes the <GlossaryTooltip term="request context"> request context</GlossaryTooltip>).
 
-|                      | Paid plan                                                                                                                               |
-| -------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
-| Requests             | 1 million, + $0.15/million<br/> Includes HTTP requests, RPC sessions<sup>1</sup>, WebSocket messages<sup>2</sup>, and alarm invocations |
-| Duration<sup>3</sup> | 400,000 GB-s, + $12.50/million GB-s<sup>4,5</sup>                                                                                       |
+|                      | Free plan                           | Paid plan                                                                                                                               |
+| -------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| Requests             | Capped at 100,000 per day           | 1 million, + $0.15/million<br/> Includes HTTP requests, RPC sessions<sup>1</sup>, WebSocket messages<sup>2</sup>, and alarm invocations |
+| Duration<sup>3</sup> | Capped at <br/> 13,000 GB-s per day | 400,000 GB-s, + $12.50/million GB-s<sup>4,5</sup>                                                                                       |
+
+<Details header="Footnotes" open={true}>
 
 <sup>1</sup> Each [RPC session](/workers/runtime-apis/rpc/lifecycle/) is billed as one request to your Durable Object. Every [RPC method call](/durable-objects/best-practices/create-durable-object-stubs-and-send-requests/) on a [Durable Objects stub](/durable-objects/) is its own RPC session and therefore a single billed request.
 
@@ -29,3 +31,5 @@ await durableObjectStub.cat(); // billed as a request
 <sup>4</sup> 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. Calling `accept()` on a WebSocket in an Object will incur duration charges for the entire time the WebSocket is connected. Note that the request context for a Durable Object extends at least 60 seconds after the last client disconnects. If you prefer, use the [WebSocket hibernation API](/durable-objects/best-practices/websockets/#websocket-hibernation-api) to avoid incurring duration charges once all event handlers finish running.
 
 <sup>5</sup> 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.
+
+</Details>
diff --git a/src/content/partials/durable-objects/durable-objects-vs-d1.mdx b/src/content/partials/durable-objects/durable-objects-vs-d1.mdx
@@ -22,4 +22,4 @@ Durable Objects require a bit more effort, but in return, give you more flexibil
 
 With SQLite in Durable Objects, you may also need to build some of your own database tooling that comes out-of-the-box with D1.
 
-SQL query pricing and limits are intended to be identical between D1 ([pricing](/d1/platform/pricing/), [limits](/d1/platform/limits/)) and SQLite in Durable Objects ([pricing](/durable-objects/platform/pricing/#sql-storage-billing), [limits](/durable-objects/platform/limits/)). During SQLite in Durable Objects beta, Storage per Durable Object is 1GB, which will be raised to mirror storage per D1 database (10GB) by general availability.
+SQL query pricing and limits are intended to be identical between D1 ([pricing](/d1/platform/pricing/), [limits](/d1/platform/limits/)) and SQLite in Durable Objects ([pricing](/durable-objects/platform/pricing/#sql-storage-billing), [limits](/durable-objects/platform/limits/)).
diff --git a/src/content/partials/workers/do_storage_api_pricing.mdx b/src/content/partials/workers/do_storage_api_pricing.mdx
@@ -0,0 +1,54 @@
+---
+{}
+
+---
+
+import { Details } from "~/components";
+
+The [Durable Objects Storage API](/durable-objects/api/storage-api) is only accessible from within Durable Objects. Pricing depends on the type of storage your Durable Objects use.
+
+- **SQLite-storage backed Durable Objects (recommended)**: This is the default storage used by Durable Objects. You can use SQLite-storage backed Durable Objects without a Workers Paid plan, or unlock higher limits with a Workers paid plan.
+- **Key-value storage backed Durable Objects**: This is only available on the Workers Paid plan.
+
+### SQLite storage backend
+
+|                             | Workers Free plan         | Workers Paid plan                                         |
+| ----------------------------| ------------------------- | --------------------------------------------------------- |
+| Rows reads <sup>1,2</sup>   | Capped at 5 million / day | First 25 billion / month included + $0.001 / million rows |
+| Rows written <sup>1,2</sup> | Capped at 100,000 / day   | First 50 million / month included + $1.00 / million rows  |
+| SQL Stored data             | 5 GB (total)              | 5 GB-month, + $0.20/ GB-month                             |
+
+<Details header="Footnotes" open={true}>
+
+<sup>1</sup> Rows read and rows written included limits and rates match D1, Cloudflare's serverless SQL database, [pricing](/d1/platform/pricing/).
+
+<sup>2</sup> 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.
+
+<sup>3</sup>  Each `setAlarm` is billed as a single row written.
+
+</Details>
+
+### Key-value storage backend
+
+|                                  | Workers Paid plan          |
+| -------------------------------- | -------------------------- |
+| Read request units<sup>1,2</sup> | 1 million, + $0.20/million |
+| Write request units<sup>3</sup>  | 1 million, + $1.00/million |
+| Delete requests<sup>4</sup>      | 1 million, + $1.00/million |
+| Stored data<sup>5</sup>          | 1 GB, + $0.20/ GB-month    |
+
+<Details header="Footnotes" open={true}>
+
+<sup>1</sup> 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.
+
+<sup>2</sup>  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.
+
+<sup>3</sup>  Each `setAlarm` is billed as a single write request unit.
+
+<sup>4</sup>  Delete requests are unmetered. For example, deleting a 100 KB value will be charged one delete request.
+
+<sup>5</sup>  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](/durable-objects/reference/in-memory-state/) or that use the [multi-key versions of `get()`/`put()`/`delete()` methods](/durable-objects/api/storage-api/) are billed the same as if they were a normal, individual request for each key.
+
+</Details>
diff --git a/src/content/partials/workers/storage_api_pricing.mdx b/src/content/partials/workers/storage_api_pricing.mdx

Original file line number	Diff line number	Diff line change
`@@ -22,4 +22,4 @@ Durable Objects require a bit more effort, but in return, give you more flexibil`
`22`	`22`
`23`	`23`	`With SQLite in Durable Objects, you may also need to build some of your own database tooling that comes out-of-the-box with D1.`
`24`	`24`
`25`		`-SQL query pricing and limits are intended to be identical between D1 ([pricing](/d1/platform/pricing/), [limits](/d1/platform/limits/)) and SQLite in Durable Objects ([pricing](/durable-objects/platform/pricing/#sql-storage-billing), [limits](/durable-objects/platform/limits/)). During SQLite in Durable Objects beta, Storage per Durable Object is 1GB, which will be raised to mirror storage per D1 database (10GB) by general availability.`
	`25`	`+SQL query pricing and limits are intended to be identical between D1 ([pricing](/d1/platform/pricing/), [limits](/d1/platform/limits/)) and SQLite in Durable Objects ([pricing](/durable-objects/platform/pricing/#sql-storage-billing), [limits](/durable-objects/platform/limits/)).`