pm edits for pricing & limits

vy-ton · vy-ton · commit 3e38d21d22da · 2025-03-30T20:52:06.000-04:00
diff --git a/src/content/docs/durable-objects/best-practices/access-durable-objects-storage.mdx b/src/content/docs/durable-objects/best-practices/access-durable-objects-storage.mdx
@@ -14,11 +14,11 @@ A Durable Object's [in-memory state](/durable-objects/reference/in-memory-state/
 
 ## Access storage
 
-We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. Key-value storage backend remains for backwards compatibility, and a migration path from key-value storage to SQL storage for existing Durable Object classes will be offered in the future. 
+We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. [Key-value storage backend](/durable-objects/reference/durable-objects-migrations/#create-durable-object-class -with-key-value-storage) remains for backwards compatibility, and a migration path from key-value storage to SQL storage for existing Durable Object classes will be offered in the future. 
 
 [Storage API methods](/durable-objects/api/storage-api/#methods) are available on `ctx.storage` parameter passed to the Durable Object constructor. Storage API has SQL APIs and key-value APIs. Only Durable Object classes with a SQLite storage backend can access SQL API.
 
-### Wrangler configuration for SQLite-backed Durable Objects
+### Create SQLite-backed Durable Object class
 
 Use `new_sqlite_classes` on the migration in your Worker's Wrangler file:
 
diff --git a/src/content/docs/durable-objects/platform/limits.mdx b/src/content/docs/durable-objects/platform/limits.mdx
@@ -10,54 +10,28 @@ import { Render, GlossaryTooltip, Details, WranglerConfig } from "~/components";
 
 Durable Objects are a special kind of Worker, so [Workers Limits](/workers/platform/limits/) apply according to your Workers plan. In addition, Durable Objects have specific limits as listed in this page.
 
-- If you exceed any one of these limits, further operations of that type will fail with an error.
-- Daily free limits reset at 00:00 UTC.
+## SQLite-backed Durable Objects general limits
 
-## SQlite Durable Object general limits
-
-| Feature                                  | Limit for class with SQLite storage backend                                                                    |
-| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
-| Number of Objects                        | Unlimited (within an account or of a given class)                                                              |
-| Maximum Durable Object namespaces        | 500 (identical to the [script limit](/workers/platform/limits/))                                               |
-| Storage per class                        | Unlimited                                                                                                      |
-| Storage per Durable Object               | 10 GB                                                                                                          |
-| Key size                                 | Key and value combined cannot exceed 2 MB                                                                      |
-| Value size                               | Key and value combined cannot exceed 2 MB                                                                      |
-| WebSocket message size                   | 1 MiB (only for received messages)                                                                             |
-| CPU per request                          | 30 seconds (default) / configurable to 5 minutes of [active CPU time](/workers/platform/limits/#cpu-time) [^1] |
-
-[^1]: Each incoming HTTP request or WebSocket *message* resets the remaining available CPU time to 30 seconds. This allows the Durable Object to consume up to 30 seconds of compute after each incoming network request, with each new network request resetting the timer. If you consume more than 30 seconds of compute between incoming network requests, there is a heightened chance that the individual Durable Object is evicted and reset.
-
-[^2]: Durable Objects both bills and measures storage based on a gigabyte <br/> (1 GB = 1,000,000,000 bytes) and not a gibibyte (GiB). <br/>
+| Feature                                  | Limit |
+| ---------------------------------------- | ----------------------------------------------------------- |
+| Number of Objects                        | Unlimited (within an account or of a given class) |
+| Maximum Durable Object namespaces        | 500 (identical to the [script limit](/workers/platform/limits/)) |
+| Storage per class                        | Unlimited |
+| Storage per Durable Object               | 10 GB [^1] |
+| Key size                                 | Key and value combined cannot exceed 2 MB |
+| Value size                               | Key and value combined cannot exceed 2 MB |
+| WebSocket message size                   | 1 MiB (only for received messages) |
+| CPU per request                          | 30 seconds (default) / configurable to 5 minutes of [active CPU time](/workers/platform/limits/#cpu-time) [^2] |
+
+<Details header="Footnotes" open={true}>
+1: Durable Objects both bills and measures storage based on a gigabyte <br/> (1 GB = 1,000,000,000 bytes) and not a gibibyte (GiB). <br/>
 
-<Details header="Footnotes">
-1: Each incoming HTTP request or WebSocket *message* resets the remaining available CPU time to 30 seconds. This allows the Durable Object to consume up to 30 seconds of compute after each incoming network request, with each new network request resetting the timer. If you consume more than 30 seconds of compute between incoming network requests, there is a heightened chance that the individual Durable Object is evicted and reset.
+2: Each incoming HTTP request or WebSocket *message* resets the remaining available CPU time to 30 seconds. This allows the Durable Object to consume up to 30 seconds of compute after each incoming network request, with each new network request resetting the timer. If you consume more than 30 seconds of compute between incoming network requests, there is a heightened chance that the individual Durable Object is evicted and reset. CPU time per request invocation [can be increased](/durable-objects/platform/limits/#increasing-durable-object-cpu-limits).
 </Details>
 
-### Increase Durable Object CPU limits
-
-Durable Objects are Worker scripts, and share the same [per invocation CPU limits](/workers/platform/limits/#worker-limits) as any Workers do. Note that CPU time is active processing time: not time spent waiting on network requests, storage calls, or other general I/O, which do not count towards your CPU time or Durable Objects compute consumption.
+### SQL storage limits
 
-By default, the maximum CPU time per Durable Objects invocation (HTTP request, WebSocket message, or Alarm) is set to 30 seconds, but can be increased for all Durable Objects associated with a Durable Object definition by setting `limits.cpu_ms` in your Wrangler configuration:
-
-<WranglerConfig>
-
-```jsonc
-{
-  // ...rest of your configuration...
-  "limits": {
-    "cpu_ms": 300000, // 300,000 milliseconds = 5 minutes
-  },
-  // ...rest of your configuration...
-}
-```
-
-</WranglerConfig>
-
-
-## SQL storage limits
-
-For Durable Object classes with [SQLite storage](/durable-objects/api/sql-storage/) backend these SQL limits apply:
+For Durable Object classes with [SQLite storage](/durable-objects/api/sql-storage/) these SQL limits apply:
 
 | SQL                                                      | Limit                                           |
 | -------------------------------------------------------- | ----------------------------------------------- |
@@ -69,26 +43,26 @@ For Durable Object classes with [SQLite storage](/durable-objects/api/sql-storag
 | Maximum arguments per SQL function                       | 32                                              |
 | Maximum characters (bytes) in a `LIKE` or `GLOB` pattern | 50 bytes                                        |
 
-<Render file="do-plans-note"/>
+## Key-value backed Durable Objects general limits
 
-## Key-value Durable Object general limits
+<Render file="do-plans-note"/>
 
 | Feature                                  | Limit for class with key-value storage backend                   |
 | ---------------------------------------- | ---------------------------------------------------------------- |
 | Number of Objects                        | Unlimited (within an account or of a given class)                |
 | Maximum Durable Object namespaces        | 500 (identical to the [script limit](/workers/platform/limits/)) |
-| Storage per account                      | 50 GB (can be raised by contacting Cloudflare) [^2]              |
+| Storage per account                      | 50 GB (can be raised by contacting Cloudflare) [^1]              |
 | Storage per class                        | Unlimited                                                        |
 | Storage per Durable Object               | Unlimited                                                        |
 | Key size                                 | 2 KiB (2048 bytes)                                               |
 | Value size                               | 128 KiB (131072 bytes)                                           |
 | WebSocket message size                   | 1 MiB (only for received messages)                               |
-| CPU per request                          | 30s (including WebSocket messages) [^1]                          |
+| CPU per request                          | 30s (including WebSocket messages) [^2]                          |
 
 <Details header="Footnotes">
 1: Durable Objects both bills and measures storage based on a gigabyte <br/> (1 GB = 1,000,000,000 bytes) and not a gibibyte (GiB). <br/>
 
-2: Each incoming HTTP request or WebSocket *message* resets the remaining available CPU time to 30 seconds. This allows the Durable Object to consume up to 30 seconds of compute after each incoming network request, with each new network request resetting the timer. If you consume more than 30 seconds of compute between incoming network requests, there is a heightened chance that the individual Durable Object is evicted and reset.
+2: Each incoming HTTP request or WebSocket *message* resets the remaining available CPU time to 30 seconds. This allows the Durable Object to consume up to 30 seconds of compute after each incoming network request, with each new network request resetting the timer. If you consume more than 30 seconds of compute between incoming network requests, there is a heightened chance that the individual Durable Object is evicted and reset. CPU time per request invocation [can be increased](/durable-objects/platform/limits/#increasing-durable-object-cpu-limits).
 </Details>
 
 <Render file="limits_increase" product="workers" />
diff --git a/src/content/docs/durable-objects/platform/pricing.mdx b/src/content/docs/durable-objects/platform/pricing.mdx
@@ -7,10 +7,10 @@ sidebar:
 
 import { Render } from "~/components"
 
-<Render file="do-plans-note"/>
-
 Durable Objects can incur two types of billing: compute and storage.
 
+<Render file="do-plans-note"/>
+
 <Render file="durable-objects-pricing" product="durable-objects" params={{product:"durable-objects"}}/>
 
 ## Compute billing examples
diff --git a/src/content/docs/durable-objects/reference/durable-objects-migrations.mdx b/src/content/docs/durable-objects/reference/durable-objects-migrations.mdx
@@ -73,6 +73,22 @@ new_sqlite_classes = ["DurableObjectAClass"]
 
 </Details>
 
+### Create Durable Object class with key-value storage
+
+We recommend all new <GlossaryTooltip term="Durable Object class">Durable Object classes</GlossaryTooltip> use the SQLite storage backend. Key-value storage backend remains for backwards compatibility. 
+
+Use `new_classes` on the migration in your Worker's Wrangler file:
+
+<WranglerConfig>
+
+```toml
+[[migrations]]
+tag = "v1" # Should be unique for each entry
+new_classes = ["MyDurableObject"] # Array of new classes
+```
+
+</WranglerConfig>
+
 ## Delete migration
 
 Running a Delete migration will delete all Durable Objects associated with the deleted class, including all of their stored data.
diff --git a/src/content/partials/durable-objects/do-plans-note.mdx b/src/content/partials/durable-objects/do-plans-note.mdx
@@ -5,8 +5,8 @@
 :::note
 Durable Objects are available both on Workers Free and Workers Paid plans.
 
-- **Workers Free plan**: Only Durable Objects with SQLite storage backend are available.
+- **Workers Free plan**: Only Durable Objects with [SQLite storage](/durable-objects/best-practices/access-durable-objects-storage/#wrangler-configuration-for-sqlite-backed-durable-objects) are available.
 - **Workers Paid plan**: Durable Objects with both SQLite storage and key-value storage are available.
 
-If you wish to downgrade from a Workers Paid plan to a Workers Free plan, you must first ensure that you have deleted all namespaces for Durable Objects with key-value storage backend.
+If you wish to downgrade from a Workers Paid plan to a Workers Free plan, you must first ensure that you have deleted all Durable Object namespaces with key-value storage backend.
 :::
diff --git a/src/content/partials/durable-objects/durable-objects-pricing.mdx b/src/content/partials/durable-objects/durable-objects-pricing.mdx
@@ -7,12 +7,16 @@ import { Markdown, GlossaryTooltip, Details, AnchorHeading } from "~/components"
 { props.product === "durable-objects" && <><AnchorHeading title="Compute billing" depth={2}/></> }
 { props.product === "workers" && <><AnchorHeading title="Compute billing" depth={3}/></> }
 
+On Workers Free plan:
+- If you exceed any one of these limits, further operations of that type will fail with an error.
+- Daily free limits reset at 00:00 UTC.
+
 Durable Objects are billed only while the Durable Object is active (includes the <GlossaryTooltip term="request context"> request context</GlossaryTooltip>).
 
 |                      | 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>                                                                                       |
+| Requests             | 100,000 / 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> | 13,000 GB-s / day                   | 400,000 GB-s, + $12.50/million GB-s<sup>4,5</sup>                                                                                       |
 
 <Details header="Footnotes" open={true}>
 
@@ -42,26 +46,30 @@ await durableObjectStub.cat(); // billed as a request
 
 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.
+- **SQLite-backed Durable Objects (recommended)**: This is the recommended storage for new Durable Object classes. Workers Free plan can only create and access SQLite-backed Durable Objects. 
 - **Key-value storage backed Durable Objects**: This is only available on the Workers Paid plan.
 
 { props.product === "durable-objects" && <><AnchorHeading title="SQLite storage backend" depth={3}/></> }
 { props.product === "workers" && <><AnchorHeading title="SQLite storage backend" depth={4}/></> }
 
-|                             | 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                             |
+|                               | Workers Free plan         | Workers Paid plan                                         |
+| ----------------------------- | ------------------------- | --------------------------------------------------------- |
+| Rows reads <sup>1,2</sup>     | 5 million / day           | First 25 billion / month included + $0.001 / million rows |
+| Rows written <sup>1,2,3,4</sup> | 100,000 / day             | First 50 million / month included + $1.00 / million rows  |
+| SQL Stored data <sup>5</sup>  | 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>1</sup> Rows read and rows written included limits and rates match [D1 pricing](/d1/platform/pricing/), Cloudflare's serverless SQL database.
 
 <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.
 
+<sup>4</sup>  Deletes are counted as rows_written.
+
+<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.
+
 </Details>
 
 { props.product === "durable-objects" && <><AnchorHeading title="Key-value storage backend" depth={3}/></> }
