---
title: Durable Objects Changelog
image: https://edgetunnel-b2h.pages.dev/cf-twitter-card.png
---

> Documentation Index  
> Fetch the complete documentation index at: https://edgetunnel-b2h.pages.dev/changelog/llms.txt  
> Use this file to discover all available pages before exploring further. 

[Skip to content](#%5Ftop) 

# Changelog

New updates and improvements at Cloudflare.

[ Subscribe to RSS ](https://edgetunnel-b2h.pages.dev/changelog/rss/index.xml) [ View RSS feeds ](https://edgetunnel-b2h.pages.dev/fundamentals/new-features/available-rss-feeds/) 

Durable Objects

![hero image](https://edgetunnel-b2h.pages.dev/_astro/hero.CVYJHPAd_26AMqX.svg) 

Jul 09, 2026
1. ### [New Durable Object namespaces must use the SQLite storage backend](https://edgetunnel-b2h.pages.dev/changelog/post/2026-07-09-restrict-new-kv-backed-namespaces/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
If your account does not already have a key-value (KV) backed Durable Object namespace, you can no longer create new ones. New Durable Object namespaces must use the [SQLite storage backend](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class), which has been recommended for all new Durable Objects since it became [generally available ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/) in 2024.  
Create a new class with a `new_sqlite_classes` migration:

  * [  wrangler.jsonc ](#tab-panel-3277)
  * [  wrangler.toml ](#tab-panel-3278)

**JSONC**  
```jsonc  
{  
  "$schema": "./node_modules/wrangler/config-schema.json",  
  "migrations": [  
    {  
      "tag": "v1",  
      "new_sqlite_classes": [  
        "MyDurableObject"  
      ]  
    }  
  ]  
}  
```

**TOML**  
```toml  
[[migrations]]  
tag = "v1"  
new_sqlite_classes = ["MyDurableObject"]  
```  
SQLite-backed Durable Objects have feature parity with the key-value backend — including the [key-value storage API](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#synchronous-kv-api) — and additionally support relational [SQL queries](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#sql-api) and [point-in-time recovery](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#pitr-point-in-time-recovery-api) to restore an object's storage to any point in the past 30 days.  
If you attempt to create a new key-value backed namespace (a `new_classes` migration) on an affected account, the deployment fails with the following error:  
```txt  
Creating new key-value backed Durable Object namespaces is no longer supported on this account. Please create a namespace using a `new_sqlite_classes` migration instead.  
```  
This change only affects accounts that are not already using the key-value storage backend. Accounts with at least one existing key-value backed namespace can still create new ones for now, and the Workers Free plan has only ever supported SQLite-backed Durable Objects. It is part of a broader move toward SQLite as the single storage backend for Durable Objects, ahead of a future migration path for existing key-value backed objects.  
For more information, refer to [Durable Objects migrations](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/).

Jul 04, 2026
1. ### [Declare Durable Object class lifecycle with \`exports\`](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-30-declarative-do-class-exports/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
A new declarative [exports](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/) field in your Wrangler configuration file replaces the imperative [migrations](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-object-class-migrations-legacy/) array for managing Durable Object class lifecycle. Instead of writing an ordered list of migration steps with unique tags, you declare each Durable Object class your Worker exports and Cloudflare compares that against what's already deployed to determine what Durable Object state needs to be created, renamed, or deleted.  
With legacy migrations, renaming `ChatRoom` to `Room` requires retaining both tagged steps:

**Before — legacy migrations**  
```jsonc  
{  
  "migrations": [  
    { "tag": "v1", "new_sqlite_classes": ["ChatRoom"] },  
    {  
      "tag": "v2",  
      "renamed_classes": [{ "from": "ChatRoom", "to": "Room" }],  
    },  
  ],  
}  
```  
With `exports`, you instead declare `Room` as the current class and mark `ChatRoom` as renamed:

**After — declarative exports**  
```jsonc  
{  
  "exports": {  
    "ChatRoom": {  
      "type": "durable-object",  
      "state": "renamed",  
      "renamed_to": "Room",  
    },  
    "Room": { "type": "durable-object", "storage": "sqlite" },  
  },  
}  
```  
Each entry is keyed by class name. The `state` field carries the lifecycle (`created` by default — a live class — plus tombstone states `deleted`, `renamed`, and `transferred`, and the `expecting-transfer` receiving state for cross-Worker transfers).  
Key improvements over the legacy `migrations` array:

  * **No migration tags.** The current `exports` map is the source of truth — there is no historical chain of `v1`, `v2`, `v3` entries to maintain.
  * **Structured deployment output.** Wrangler reports when it creates, updates, deletes, renames, or transfers Durable Object classes. It also identifies stale configuration entries that are safe to remove. Deployments with no changes or notices do not print this output.
  * **Zero-downtime rename and transfer patterns are first-class.** Tombstones may coexist with the source class still in code, enabling a [three-deploy rename](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/#avoid-downtime-during-a-rename) and a [four-deploy cross-Worker transfer](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/#transfer-a-durable-object-class-between-workers) without runtime errors during the rollout window.
  * **Cross-Worker safety.** When you delete or rename a class, Cloudflare lists every other Worker in your account whose bindings still reference the namespace, so you can redeploy them before the change goes live.  
Existing Workers using the legacy [migrations](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-object-class-migrations-legacy/) array continue to work unchanged. To move to `exports`, refer to the [migration guide](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/#migrate-from-the-legacy-migrations-flow). `exports` and `migrations` are mutually exclusive within a single Worker.  
For the full reference, refer to [Durable Object class exports](https://edgetunnel-b2h.pages.dev/durable-objects/reference/durable-objects-migrations/).

Jun 30, 2026
1. ### [Track memory usage for Workers and Durable Objects in the dashboard](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-30-memory-usage-metrics/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)  
You can now monitor how much memory your [Workers](https://edgetunnel-b2h.pages.dev/workers/) and [Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/) consume across invocations with the new **Memory Usage** chart in the Workers Metrics tab, broken down by P50, P90, P99, and P999 percentiles.  
![Memory usage chart showing P50, P90, P99, and P999 percentiles with deployment markers](https://edgetunnel-b2h.pages.dev/_astro/2026-06-26-memory-usage.B20y2uNp_2e7cPL.webp)  
Memory usage measures the V8 [isolate](https://edgetunnel-b2h.pages.dev/workers/reference/how-workers-works/#isolates) memory at the time of each invocation, subject to the [128 MB per-isolate limit](https://edgetunnel-b2h.pages.dev/workers/platform/limits/#memory) — a single isolate can handle many concurrent requests and shares memory across them.  
Use the Memory Usage chart to:

  * **Track memory trends** — Spot gradual increases that may indicate a memory leak before they cause `Exceeded Memory` errors.
  * **Correlate with deployments** — Deployment markers on the chart help you identify whether a new version introduced a memory regression.
  * **Right-size your Worker** — Understand your baseline memory footprint and how much headroom you have before hitting the 128 MB limit.  
For Durable Objects, memory usage reflects the in-memory state an object holds (class properties, caches, active WebSocket connections), which persists across invocations until the object is [hibernated or evicted](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/durable-object-lifecycle/). This state is not preserved across eviction, hibernation, or a crash, so persist anything important to [storage](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/access-durable-objects-storage/).  
To view memory usage, open the **Metrics** tab for your [Worker ↗](https://dash.cloudflare.com/?to=/:account/workers/services/view/:worker/production/metrics) or [Durable Object namespace ↗](https://dash.cloudflare.com/?to=/:account/workers/durable-objects). For Durable Objects, you can filter by DO ID or name to drill down into memory usage for a specific object. You can also query memory usage programmatically via the [GraphQL Analytics API](https://edgetunnel-b2h.pages.dev/analytics/graphql-api/tutorials/querying-workers-metrics/) using the `workersInvocationsAdaptive` dataset — the `quantiles.memoryUsageBytesP50` through `quantiles.memoryUsageBytesP999` fields return percentile values in bytes.  
For local memory debugging, you can also [profile memory with DevTools](https://edgetunnel-b2h.pages.dev/workers/observability/dev-tools/memory-usage/) to take heap snapshots and identify specific objects causing high memory usage.

Jun 26, 2026
1. ### [New \`us\` jurisdiction for Durable Objects](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-26-durable-objects-us-jurisdiction/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Durable Objects now supports a `us` [jurisdiction](https://edgetunnel-b2h.pages.dev/durable-objects/reference/data-location/#restrict-durable-objects-to-a-jurisdiction), letting you create Durable Objects that only run and store data within the United States. Use the `us` jurisdiction when you need to keep a Durable Object's compute and storage inside the United States to meet data residency requirements.  
Create a namespace restricted to the `us` jurisdiction the same way as any other jurisdiction:

**JavaScript**  
```js  
// Worker  
export default {  
  async fetch(request, env) {  
    const usSubnamespace = env.MY_DURABLE_OBJECT.jurisdiction("us");  
    const stub = usSubnamespace.getByName("general");  
    return stub.fetch(request);  
  },  
};  
```  
Workers may still access Durable Objects constrained to the `us` jurisdiction from anywhere in the world. The jurisdiction constraint only controls where the Durable Object itself runs and persists data.  
For the full list of supported jurisdictions, refer to [Data location — Restrict Durable Objects to a jurisdiction](https://edgetunnel-b2h.pages.dev/durable-objects/reference/data-location/#restrict-durable-objects-to-a-jurisdiction).

Jun 25, 2026
1. ### [Test Durable Object eviction with new cloudflare:test helpers](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-25-durable-object-eviction-test-helpers/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The `@cloudflare/vitest-pool-workers` package now includes `evictDurableObject` and `evictAllDurableObjects` test helpers, exported from `cloudflare:test`.  
These helpers let you test how a Durable Object behaves across evictions, simulating the production lifecycle where an idle Durable Object can be evicted from memory.  
For more context, refer to [Lifecycle of a Durable Object](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/durable-object-lifecycle/).

**TypeScript**  
```ts  
import { evictDurableObject, evictAllDurableObjects } from "cloudflare:test";  
import { env } from "cloudflare:workers";  
const id = env.COUNTER.idFromName("my-counter");  
const stub = env.COUNTER.get(id);  
// Evict the Durable Object instance pointed to by a specific stub  
await evictDurableObject(stub);  
// Close WebSockets instead of hibernating them  
await evictDurableObject(stub, { webSockets: "close" });  
// Evict all currently-running Durable Objects in evictable namespaces  
await evictAllDurableObjects();  
```  
These helpers are available in `@cloudflare/vitest-pool-workers@0.16.20` and later.  
Learn more in the [Test APIs reference](https://edgetunnel-b2h.pages.dev/workers/testing/vitest-integration/test-apis/#durable-objects) and the [Testing Durable Objects guide](https://edgetunnel-b2h.pages.dev/durable-objects/examples/testing-with-durable-objects/#testing-eviction).

Jun 19, 2026
1. ### [New Asia-Pacific location hints: apac-ne and apac-se](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-19-apac-ne-apac-se-location-hints/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Durable Objects now supports two new location hints for Asia-Pacific: `apac-ne` (Northeast Asia-Pacific) and `apac-se` (Southeast Asia-Pacific). Use `apac-ne` or `apac-se` when you want finer-grained placement within Asia-Pacific rather than the broader `apac` hint.  
Use the new hints the same way as any other `locationHint`:

**JavaScript**  
```js  
// Northeast Asia-Pacific (Japan, Korea, etc.)  
const stubNE = env.MY_DURABLE_OBJECT.get(id, { locationHint: "apac-ne" });  
// Southeast Asia-Pacific (Singapore, Indonesia, etc.)  
const stubSE = env.MY_DURABLE_OBJECT.get(id, { locationHint: "apac-se" });  
```  
If your users are spread across all of Asia-Pacific, the existing `apac` hint remains the right choice. Only reach for `apac-ne` or `apac-se` when your traffic is clearly concentrated in one sub-region and you want to minimize round-trip time to that audience. The default behavior and what we generally recommended is not adding a location hint unless absolutely needed, this will create the Durable Object as close to the initializing request as possible to reduce latency.  
As with all location hints, these are best-effort suggestions. Cloudflare will place the Durable Object in a nearby data center, not necessarily the exact hinted location.  
For the full list of supported hints, refer to [Data location — Provide a location hint](https://edgetunnel-b2h.pages.dev/durable-objects/reference/data-location/#provide-a-location-hint).

Jun 19, 2026
1. ### [Outbound connections keep Durable Objects alive](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-19-outbound-connections-keep-dos-alive/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)  
Durable Objects now remain alive for the duration of active outbound connections created via [connect()](https://edgetunnel-b2h.pages.dev/workers/runtime-apis/tcp-sockets/) or an outbound WebSocket. Previously, a Durable Object would be evicted after 70-140 seconds of no incoming traffic, even if the object had an open outbound connection, which is a common pattern when streaming responses from a large language model (LLM) over TCP or an outbound WebSocket.  
With this change, each active outbound connection prevents eviction. Once all outbound connections close, the standard 70-140 second inactivity window applies before the Durable Object is evicted.  
#### Before: streaming connections were cut off by eviction  
![Timeline showing a Durable Object evicted 70-140 seconds after the last incoming request, cutting off an in-flight LLM stream while the outbound connection is still open](https://edgetunnel-b2h.pages.dev/_astro/outbound-connection-before.DpePflZI_1djzQi.svg)  
#### After: active outbound connections keep the Durable Object alive  
![Timeline showing the same outbound stream completing because the active connection keeps the Durable Object alive, with the inactivity window starting only after the connection closes](https://edgetunnel-b2h.pages.dev/_astro/outbound-connection-after.Bn9BVcYz_1djzQi.svg)  
If you are [building agents on Cloudflare](https://edgetunnel-b2h.pages.dev/agents/), this is especially relevant. An agent that streams tokens from an LLM while [calling models](https://edgetunnel-b2h.pages.dev/agents/concepts/calling-llms/), or that performs [long-running tasks](https://edgetunnel-b2h.pages.dev/agents/concepts/agentic-patterns/long-running-agents/) over an outbound connection, now stays alive for the duration of that connection instead of being evicted mid-stream.

**Limits:**

  * Each outbound connection keeps the Durable Object alive for a maximum of **15 minutes**. After 15 minutes, the connection stops preventing eviction (the connection itself continues operating), and the [standard eviction rules](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/durable-object-lifecycle/) resume.
  * The Durable Object's existing [per-account instance limits](https://edgetunnel-b2h.pages.dev/durable-objects/platform/limits/) still apply.  
For more information, refer to [Lifecycle of a Durable Object](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/durable-object-lifecycle/).

Jun 12, 2026
1. ### [Filter Durable Objects metrics by object ID or name](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-12-durable-objects-metrics-filter-by-id-name/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
You can now filter the **Metrics** tab for a Durable Objects namespace by an individual Durable Object's [ID](https://edgetunnel-b2h.pages.dev/durable-objects/api/id/) or [name](https://edgetunnel-b2h.pages.dev/durable-objects/api/id/#name) in the Cloudflare dashboard. Previously, metrics charts only showed aggregate, namespace-level data, making it difficult to isolate the behavior of a specific object.  
[ Go to **Durable Objects** ](https://dash.cloudflare.com/?to=/:account/workers/durable-objects) ![The Durable Objects Metrics tab filtered to a single object by ID, showing per-object requests and errors by invocation status.](https://edgetunnel-b2h.pages.dev/_astro/durable-objects-metrics-dashboard.BFZTyhWU_Z2e46Sb.webp)  
Start typing an ID or name into the filter and select a match from the autocomplete dropdown. The autocomplete only shows objects with invocations during the selected time range, so an object that does not appear has not been invoked in that window. This does not necessarily mean the object has been deleted. Every chart on the page updates to reflect only the selected object. This makes it easier to identify and investigate a single Durable Object when debugging a high-traffic object, an error spike, or unexpected storage usage. Clear the filter to return to namespace-level metrics.  
Metrics are powered by the [GraphQL Analytics API](https://edgetunnel-b2h.pages.dev/analytics/graphql-api/), so standard analytics behavior such as ingestion delay and [sampling](https://edgetunnel-b2h.pages.dev/analytics/faq/graphql-api-inconsistent-results/) applies.  
For more information, refer to [Metrics and analytics](https://edgetunnel-b2h.pages.dev/durable-objects/observability/metrics-and-analytics/).

Jun 04, 2026
1. ### [Billable usage and budget alerts now in product sidebars](https://edgetunnel-b2h.pages.dev/changelog/post/2026-06-04-billable-usage-product-sidebar/)  
[ Cloudflare Fundamentals ](https://edgetunnel-b2h.pages.dev/fundamentals/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ D1 ](https://edgetunnel-b2h.pages.dev/d1/)[ R2 ](https://edgetunnel-b2h.pages.dev/r2/)[ KV ](https://edgetunnel-b2h.pages.dev/kv/)[ Queues ](https://edgetunnel-b2h.pages.dev/queues/)[ Vectorize ](https://edgetunnel-b2h.pages.dev/vectorize/)[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Containers ](https://edgetunnel-b2h.pages.dev/containers/)  
Pay-as-you-go customers can now view billable usage and create [budget alerts](https://edgetunnel-b2h.pages.dev/changelog/post/2026-04-13-billable-usage-dashboard-and-budget-alerts/) directly from the product overview pages for [Workers & Pages](https://edgetunnel-b2h.pages.dev/workers/), [D1](https://edgetunnel-b2h.pages.dev/d1/), [R2](https://edgetunnel-b2h.pages.dev/r2/), [Workers KV](https://edgetunnel-b2h.pages.dev/kv/), [Queues](https://edgetunnel-b2h.pages.dev/queues/), [Vectorize](https://edgetunnel-b2h.pages.dev/vectorize/), [Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/), and [Containers](https://edgetunnel-b2h.pages.dev/containers/). A new sidebar widget shows current-period spend and the billing cycle date range, alongside a button to create a budget alert.  
The widget pulls from the same data as the [Billable Usage dashboard](https://edgetunnel-b2h.pages.dev/changelog/post/2026-04-13-billable-usage-dashboard-and-budget-alerts/) and aligns to your billing cycle (or the current day on Free plans), so the numbers match your invoice. Enterprise contract accounts are not yet supported.  
![Billable usage widget in the Durable Objects product sidebar showing current-period spend and a breakdown by service](https://edgetunnel-b2h.pages.dev/_astro/2026-06-04-billable-usage-product-sidebar.BUuIokn__ZAx1o6.webp)  
Selecting **Create budget alert** opens the budget alert flow inline so you can set a dollar threshold in the same place you are reviewing usage. Budget alerts apply to your total account-level spend across all products, not just the product page you create them from.  
For more information, refer to the [Usage-based billing documentation](https://edgetunnel-b2h.pages.dev/billing/).

Mar 26, 2026
1. ### [Access Durable Object jurisdiction via \`ctx.id.jurisdiction\`](https://edgetunnel-b2h.pages.dev/changelog/post/2026-03-26-durable-object-id-jurisdiction/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
`ctx.id.jurisdiction` inside a Durable Object now reports the [jurisdiction](https://edgetunnel-b2h.pages.dev/durable-objects/reference/data-location/#restrict-durable-objects-to-a-jurisdiction) the object was created in — for example `"eu"` when accessed through `env.MY_DURABLE_OBJECT.jurisdiction("eu")` — so you can make region-aware decisions without passing the jurisdiction through method arguments or persisting it in storage. For the full list of ID-construction paths that preserve `jurisdiction`, refer to the [Durable Object ID documentation](https://edgetunnel-b2h.pages.dev/durable-objects/api/id/#jurisdiction).

**JavaScript**  
```js  
export class RegionalRoom extends DurableObject {  
  async fetch(request) {  
    // "eu" when accessed through env.MY_DURABLE_OBJECT.jurisdiction("eu")  
    const region = this.ctx.id.jurisdiction;  
    return new Response(`Hello from ${region ?? "the default region"}!`);  
  }  
}  
// Worker  
export default {  
  async fetch(request, env) {  
    const stub = env.MY_DURABLE_OBJECT.jurisdiction("eu").getByName("general");  
    return stub.fetch(request);  
  },  
};  
```  
`ctx.id.jurisdiction` is `undefined` for Durable Objects that were not created in a jurisdiction-restricted namespace. Alarms scheduled before 2026-03-15 also do not have `jurisdiction` stored; to backfill the value, reschedule the alarm from a `fetch()` or RPC handler.

Mar 15, 2026
1. ### [Access Durable Object name via \`ctx.id.name\`](https://edgetunnel-b2h.pages.dev/changelog/post/2026-03-15-durable-object-id-name/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
When your Worker accesses a Durable Object via `idFromName()` or `getByName()`, the same name is now available on `ctx.id.name` inside the object — no need to pass it through method arguments or persist it in storage. This brings the runtime behavior in line with the [Workers runtime types](https://edgetunnel-b2h.pages.dev/workers/languages/typescript/).  
This is especially useful for [alarms](https://edgetunnel-b2h.pages.dev/durable-objects/api/alarms/), where there is no calling client to pass the name as an argument. When an alarm handler runs, `ctx.id.name` will hold the same name the object was originally accessed with.

**JavaScript**  
```js  
import { DurableObject } from "cloudflare:workers";  
export class ChatRoom extends DurableObject {  
  async getRoomName() {  
    // ctx.id.name returns the name passed to getByName() or idFromName()  
    return this.ctx.id.name;  
  }  
}  
// Worker  
export default {  
  async fetch(request, env) {  
    const stub = env.CHAT_ROOM.getByName("general");  
    const roomName = await stub.getRoomName();  
    return new Response(`Welcome to ${roomName}!`);  
  },  
};  
```  
`ctx.id.name` is `undefined` in the following cases:

  * For Durable Objects created with `newUniqueId()`.
  * When accessed via `idFromString()`, even if the ID was originally created from a name.
  * For [names longer than 1,024 bytes](https://edgetunnel-b2h.pages.dev/durable-objects/api/id/#name).  
This works the same way in local development with `wrangler dev` as it does in production. Run `npm update wrangler` to ensure you are on a version with this support.  
For more information, refer to the [Durable Object ID documentation](https://edgetunnel-b2h.pages.dev/durable-objects/api/id/#name).

Feb 24, 2026
1. ### [deleteAll() now deletes Durable Object alarm](https://edgetunnel-b2h.pages.dev/changelog/post/2026-02-24-deleteall-deletes-alarms/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
`deleteAll()` now deletes a Durable Object alarm in addition to stored data for Workers with a compatibility date of `2026-02-24` or later. This change simplifies clearing a Durable Object's storage with a single API call.  
Previously, `deleteAll()` only deleted user-stored data for an object. Alarm usage stores metadata in an object's storage, which required a separate `deleteAlarm()` call to fully clean up all storage for an object. The `deleteAll()` change applies to both KV-backed and SQLite-backed Durable Objects.

**JavaScript**  
```js  
// Before: two API calls required to clear all storage  
await this.ctx.storage.deleteAlarm();  
await this.ctx.storage.deleteAll();  
// Now: a single call clears both data and the alarm  
await this.ctx.storage.deleteAll();  
```  
For more information, refer to the [Storage API documentation](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#deleteall).

Dec 15, 2025
1. ### [New Best Practices guide for Durable Objects](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-15-rules-of-durable-objects/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
A new [Rules of Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/rules-of-durable-objects/) guide is now available, providing opinionated best practices for building effective Durable Objects applications. This guide covers design patterns, storage strategies, concurrency, and common anti-patterns to avoid.  
Key guidance includes:

  * **Design around your "atom" of coordination** — Create one Durable Object per logical unit (chat room, game session, user) instead of a global singleton that becomes a bottleneck.
  * **Use SQLite storage with RPC methods** — SQLite-backed Durable Objects with typed RPC methods provide the best developer experience and performance.
  * **Understand input and output gates** — Learn how Cloudflare's runtime prevents data races by default, how write coalescing works, and when to use `blockConcurrencyWhile()`.
  * **Leverage Hibernatable WebSockets** — Reduce costs for real-time applications by allowing Durable Objects to sleep while maintaining WebSocket connections.  
The [testing documentation](https://edgetunnel-b2h.pages.dev/durable-objects/examples/testing-with-durable-objects/) has also been updated with modern patterns using `@cloudflare/vitest-pool-workers`, including examples for testing SQLite storage, alarms, and direct instance access:

  * [  JavaScript ](#tab-panel-3283)
  * [  TypeScript ](#tab-panel-3284)

**test/counter.test.js**  
```js  
import { env, runDurableObjectAlarm } from "cloudflare:test";  
import { it, expect } from "vitest";  
it("can test Durable Objects with isolated storage", async () => {  
  const stub = env.COUNTER.getByName("test");  
  // Call RPC methods directly on the stub  
  await stub.increment();  
  expect(await stub.getCount()).toBe(1);  
  // Trigger alarms immediately without waiting  
  await runDurableObjectAlarm(stub);  
});  
```

**test/counter.test.ts**  
```ts  
import { env, runDurableObjectAlarm } from "cloudflare:test";  
import { it, expect } from "vitest";  
it("can test Durable Objects with isolated storage", async () => {  
  const stub = env.COUNTER.getByName("test");  
  // Call RPC methods directly on the stub  
  await stub.increment();  
  expect(await stub.getCount()).toBe(1);  
  // Trigger alarms immediately without waiting  
  await runDurableObjectAlarm(stub);  
});  
```

Dec 12, 2025
1. ### [Billing for SQLite Storage](https://edgetunnel-b2h.pages.dev/changelog/post/2025-12-12-durable-objects-sqlite-storage-billing/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Storage billing for SQLite-backed Durable Objects will be enabled in January 2026, with a target date of January 7, 2026 (no earlier).  
To view your SQLite storage usage, go to the **Durable Objects** page  
[ Go to **Durable Objects** ](https://dash.cloudflare.com/?to=/:account/workers/durable-objects)  
If you do not want to incur costs, please take action such as optimizing queries or deleting unnecessary stored data in order to reduce your SQLite storage usage ahead of the January 7th target. Only usage on and after the billing target date will incur charges.  
Developers on the Workers Paid plan with Durable Object's SQLite storage usage beyond included limits will incur charges according to [SQLite storage pricing](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#sqlite-storage-backend) announced in September 2024 with the [public beta ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/). Developers on the Workers Free plan will not be charged.  
Compute billing for SQLite-backed Durable Objects has been enabled since the initial public beta. SQLite-backed Durable Objects currently incur [charges for requests and duration](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#compute-billing), and no changes are being made to compute billing.  
For more information about SQLite storage pricing and limits, refer to the [Durable Objects pricing documentation](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/#sqlite-storage-backend).

Oct 31, 2025
1. ### [Workers WebSocket message size limit increased from 1 MiB to 32 MiB](https://edgetunnel-b2h.pages.dev/changelog/post/2025-10-31-increased-websocket-message-size-limit/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Browser Run ](https://edgetunnel-b2h.pages.dev/browser-run/)  
Workers, including those using [Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/) and [Browser Rendering](https://edgetunnel-b2h.pages.dev/browser-run/), may now process WebSocket messages up to 32 MiB in size. Previously, this limit was 1 MiB.  
This change allows Workers to handle use cases requiring large message sizes, such as processing Chrome Devtools Protocol messages.  
For more information, please see the [Durable Objects startup limits](https://edgetunnel-b2h.pages.dev/durable-objects/platform/limits/#sqlite-backed-durable-objects-general-limits).

Oct 16, 2025
1. ### [View and edit Durable Object data in UI with Data Studio (Beta)](https://edgetunnel-b2h.pages.dev/changelog/post/2025-10-16-durable-objects-data-studio/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
![Screenshot of Durable Objects Data Studio](https://edgetunnel-b2h.pages.dev/_astro/do-data-studio.BfCcgtkq_Z4LLzm.webp)  
You can now view and write to each Durable Object's storage using a UI editor on the Cloudflare dashboard. Only Durable Objects using [SQLite storage](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class) can use Data Studio.  
[ Go to **Durable Objects** ](https://dash.cloudflare.com/?to=/:account/workers/durable-objects)  
Data Studio unlocks easier data access with Durable Objects for prototyping application data models to debugging production storage usage. Before, querying your Durable Objects data required deploying a Worker.  
To access a Durable Object, you can provide an object's unique name or ID generated by Cloudflare. Data Studio requires you to have at least the `Workers Platform Admin` role, and all queries are captured with audit logging for your security and compliance needs. Queries executed by Data Studio send requests to your remote, deployed objects and incur normal usage billing.  
To learn more, visit the Data Studio [documentation](https://edgetunnel-b2h.pages.dev/durable-objects/observability/data-studio/). If you have feedback or suggestions for the new Data Studio, please share your experience on [Discord ↗](https://discord.com/channels/595317990191398933/773219443911819284)

Aug 21, 2025
1. ### [New getByName() API to access Durable Objects](https://edgetunnel-b2h.pages.dev/changelog/post/2025-08-21-durable-objects-get-by-name/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
You can now create a client (a [Durable Object stub](https://edgetunnel-b2h.pages.dev/durable-objects/api/stub/)) to a Durable Object with the new `getByName` method, removing the need to convert Durable Object names to IDs and then create a stub.

**JavaScript**  
```js  
// Before: (1) translate name to ID then (2) get a client  
const objectId = env.MY_DURABLE_OBJECT.idFromName("foo"); // or .newUniqueId()  
const stub = env.MY_DURABLE_OBJECT.get(objectId);  
// Now: retrieve client to Durable Object directly via its name  
const stub = env.MY_DURABLE_OBJECT.getByName("foo");  
// Use client to send request to the remote Durable Object  
const rpcResponse = await stub.sayHello();  
```  
Each Durable Object has a globally-unique name, which allows you to send requests to a specific object from anywhere in the world. Thus, a Durable Object can be used to coordinate between multiple clients who need to work together. You can have billions of Durable Objects, providing isolation between application tenants.  
To learn more, visit the Durable Objects [API Documentation](https://edgetunnel-b2h.pages.dev/durable-objects/api/namespace/#getbyname) or the [getting started guide](https://edgetunnel-b2h.pages.dev/durable-objects/get-started/).

Jun 25, 2025
1. ### [@cloudflare/actors library - SDK for Durable Objects in beta](https://edgetunnel-b2h.pages.dev/changelog/post/2025-06-25-actors-package-alpha/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
The new [@cloudflare/actors ↗](https://www.npmjs.com/package/@cloudflare/actors) library is now in beta!  
The `@cloudflare/actors` library is a new SDK for Durable Objects and provides a powerful set of abstractions for building real-time, interactive, and multiplayer applications on top of Durable Objects. With beta usage and feedback, `@cloudflare/actors` will become the recommended way to build on Durable Objects and draws upon Cloudflare's experience building products/features on Durable Objects.  
The name "actors" originates from the [actor programming model](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/what-are-durable-objects/#actor-programming-model), which closely ties to how Durable Objects are modelled.  
The `@cloudflare/actors` library includes:

  * Storage helpers for querying embeddeded, per-object SQLite storage
  * Storage helpers for managing SQL schema migrations
  * Alarm helpers for scheduling multiple alarms provided a date, delay in seconds, or cron expression
  * `Actor` class for using Durable Objects with a defined pattern
  * Durable Objects [Workers API ↗](https://edgetunnel-b2h.pages.dev/durable-objects/api/base/) is always available for your application as needed  
Storage and alarm helper methods can be combined with [any Javascript class ↗](https://github.com/cloudflare/actors?tab=readme-ov-file#storage--alarms-with-durableobject-class) that defines your Durable Object, i.e, ones that extend `DurableObject` including the `Actor` class.

**JavaScript**  
```js  
import { Storage } from "@cloudflare/actors/storage";  
export class ChatRoom extends DurableObject<Env> {  
    storage: Storage;  
    constructor(ctx: DurableObjectState, env: Env) {  
        super(ctx, env)  
        this.storage = new Storage(ctx.storage);  
        this.storage.migrations = [{  
            idMonotonicInc: 1,  
            description: "Create users table",  
            sql: "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY)"  
        }]  
    }  
    async fetch(request: Request): Promise<Response> {  
        // Run migrations before executing SQL query  
        await this.storage.runMigrations();  
        // Query with SQL template  
        let userId = new URL(request.url).searchParams.get("userId");  
        const query = this.storage.sql`SELECT * FROM users WHERE id = ${userId};`  
        return new Response(`${JSON.stringify(query)}`);  
    }  
}  
```  
`@cloudflare/actors` library introduces the `Actor` class pattern. `Actor` lets you access Durable Objects without writing the Worker that communicates with your Durable Object (the Worker is created for you). By default, requests are routed to a Durable Object named "default".

**JavaScript**  
```js  
export class MyActor extends Actor<Env> {  
    async fetch(request: Request): Promise<Response> {  
        return new Response('Hello, World!')  
    }  
}  
export default handler(MyActor);  
```  
You can [route](https://edgetunnel-b2h.pages.dev/durable-objects/get-started/#3-instantiate-and-communicate-with-a-durable-object) to different Durable Objects by name within your `Actor` class using [nameFromRequest ↗](https://github.com/cloudflare/actors?tab=readme-ov-file#actor-with-custom-name).

**JavaScript**  
```js  
export class MyActor extends Actor<Env> {  
    static nameFromRequest(request: Request): string {  
        let url = new URL(request.url);  
        return url.searchParams.get("userId") ?? "foo";  
    }  
    async fetch(request: Request): Promise<Response> {  
        return new Response(`Actor identifier (Durable Object name): ${this.identifier}`);  
    }  
}  
export default handler(MyActor);  
```  
For more examples, check out the library [README ↗](https://github.com/cloudflare/actors?tab=readme-ov-file#getting-started). `@cloudflare/actors` library is a place for more helpers and built-in patterns, like retry handling and Websocket-based applications, to reduce development overhead for common Durable Objects functionality. Please share feedback and what more you would like to see on our [Discord channel ↗](https://discord.com/channels/595317990191398933/773219443911819284).

May 16, 2025
1. ### [Durable Objects are now supported in Python Workers](https://edgetunnel-b2h.pages.dev/changelog/post/2025-05-14-python-worker-durable-object/)  
[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)  
You can now create [Durable Objects](https://edgetunnel-b2h.pages.dev/durable-objects/) using [Python Workers](https://edgetunnel-b2h.pages.dev/workers/languages/python/). A Durable Object is a special kind of Cloudflare Worker which uniquely combines compute with storage, enabling stateful long-running applications which run close to your users. For more info see [here](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/what-are-durable-objects/).  
You can define a Durable Object in Python in a similar way to JavaScript:

**Python**  
```python  
from workers import DurableObject, Response, WorkerEntrypoint  
from urllib.parse import urlparse  
class MyDurableObject(DurableObject):  
    def __init__(self, ctx, env):  
        self.ctx = ctx  
        self.env = env  
    def fetch(self, request):  
        result = self.ctx.storage.sql.exec("SELECT 'Hello, World!' as greeting").one()  
        return Response(result.greeting)  
class Default(WorkerEntrypoint):  
    async def fetch(self, request):  
        url = urlparse(request.url)  
        id = env.MY_DURABLE_OBJECT.idFromName(url.path)  
        stub = env.MY_DURABLE_OBJECT.get(id)  
        greeting = await stub.fetch(request.url)  
        return greeting  
```  
Define the Durable Object in your Wrangler configuration file:

  * [  wrangler.jsonc ](#tab-panel-3279)
  * [  wrangler.toml ](#tab-panel-3280)

**JSONC**  
```jsonc  
{  
  "durable_objects": {  
    "bindings": [  
      {  
        "name": "MY_DURABLE_OBJECT",  
        "class_name": "MyDurableObject"  
      }  
    ]  
  }  
}  
```

**TOML**  
```toml  
[[durable_objects.bindings]]  
name = "MY_DURABLE_OBJECT"  
class_name = "MyDurableObject"  
```  
Then define the storage backend for your Durable Object:

  * [  wrangler.jsonc ](#tab-panel-3281)
  * [  wrangler.toml ](#tab-panel-3282)

**JSONC**  
```jsonc  
{  
  "migrations": [  
    {  
      "tag": "v1", // Should be unique for each entry  
      "new_sqlite_classes": [ // Array of new classes  
        "MyDurableObject"  
      ]  
    }  
  ]  
}  
```

**TOML**  
```toml  
[[migrations]]  
tag = "v1"  
new_sqlite_classes = [ "MyDurableObject" ]  
```  
Then test your new Durable Object locally by running `wrangler dev`:  
```bash  
npx wrangler dev  
```  
Consult the [Durable Objects documentation](https://edgetunnel-b2h.pages.dev/durable-objects/) for more details.

Apr 07, 2025
1. ### [Durable Objects on Workers Free plan](https://edgetunnel-b2h.pages.dev/changelog/post/2025-04-07-durable-objects-free-tier/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
Durable Objects can now be used with zero commitment on the [Workers Free plan](https://edgetunnel-b2h.pages.dev/workers/platform/pricing/) allowing you to build AI agents with [Agents SDK](https://edgetunnel-b2h.pages.dev/agents/), collaboration tools, and real-time applications like chat or multiplayer games.  
Durable Objects let you build stateful, serverless applications with millions of tiny coordination instances that run your application code alongside (in the same thread!) your durable storage. Each Durable Object can access its own SQLite database through a [Storage API](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/access-durable-objects-storage/). A Durable Object class is defined in a Worker script encapsulating the Durable Object's behavior when accessed from a Worker. To try the code below, click the button:  
[![Deploy to Cloudflare](https://deploy.workers.cloudflare.com/button)](https://deploy.workers.cloudflare.com/?url=https://github.com/cloudflare/templates/tree/main/hello-world-do-template)

**JavaScript**  
```js  
import { DurableObject } from "cloudflare:workers";  
// Durable Object  
export class MyDurableObject extends DurableObject {  
  ...  
  async sayHello(name) {  
    return `Hello, ${name}!`;  
  }  
}  
// Worker  
export default {  
  async fetch(request, env) {  
    // Every unique ID refers to an individual instance of the Durable Object class  
    const id = env.MY_DURABLE_OBJECT.idFromName("foo");  
    // A stub is a client used to invoke methods on the Durable Object  
    const stub = env.MY_DURABLE_OBJECT.get(id);  
    // Methods on the Durable Object are invoked via the stub  
    const response = await stub.sayHello("world");  
    return response;  
  },  
};  
```  
Free plan [limits](https://edgetunnel-b2h.pages.dev/durable-objects/platform/pricing/) apply to Durable Objects compute and storage usage. Limits allow developers to build real-world applications, with every Worker request able to call a Durable Object on the free plan.  
For more information, checkout:

  * [Documentation](https://edgetunnel-b2h.pages.dev/durable-objects/concepts/what-are-durable-objects/)
  * [Zero-latency SQLite storage in every Durable Object blog ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/)

Apr 07, 2025
1. ### [SQLite in Durable Objects GA with 10GB storage per object](https://edgetunnel-b2h.pages.dev/changelog/post/2025-04-07-sqlite-in-durable-objects-ga/)  
[ Durable Objects ](https://edgetunnel-b2h.pages.dev/durable-objects/)[ Workers ](https://edgetunnel-b2h.pages.dev/workers/)  
SQLite in Durable Objects is now generally available (GA) with 10GB SQLite database per Durable Object. Since the [public beta ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/) in September 2024, we've added feature parity and robustness for the SQLite storage backend compared to the preexisting key-value (KV) storage backend for Durable Objects.  
SQLite-backed Durable Objects are recommended for all new Durable Object classes, using `new_sqlite_classes` [Wrangler configuration](https://edgetunnel-b2h.pages.dev/durable-objects/best-practices/access-durable-objects-storage/#create-sqlite-backed-durable-object-class). Only SQLite-backed Durable Objects have access to Storage API's [SQL](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#sql-api) and [point-in-time recovery](https://edgetunnel-b2h.pages.dev/durable-objects/api/sqlite-storage-api/#pitr-point-in-time-recovery-api) methods, which provide relational data modeling, SQL querying, and better data management.

**JavaScript**  
```js  
export class MyDurableObject extends DurableObject {  
  sql: SqlStorage  
  constructor(ctx: DurableObjectState, env: Env) {  
    super(ctx, env);  
    this.sql = ctx.storage.sql;  
  }  
  async sayHello() {  
    let result = this.sql  
      .exec("SELECT 'Hello, World!' AS greeting")  
      .one();  
    return result.greeting;  
  }  
}  
```  
KV-backed Durable Objects remain 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.  
For more details on SQLite storage, checkout [Zero-latency SQLite storage in every Durable Object blog ↗](https://blog.cloudflare.com/sqlite-in-durable-objects/).

```json
{"@context":"https://schema.org","@type":"BlogPosting","@id":"https://edgetunnel-b2h.pages.dev/changelog/product/durable-objects/#page","headline":"Durable Objects Changelog | Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/changelog/product/durable-objects/","inLanguage":"en","image":"https://edgetunnel-b2h.pages.dev/cf-twitter-card.png","publisher":{"@type":"Organization","name":"Cloudflare","url":"https://www.cloudflare.com/"},"isPartOf":{"@type":"WebSite","@id":"https://edgetunnel-b2h.pages.dev/#website","name":"Cloudflare Docs","url":"https://edgetunnel-b2h.pages.dev/"}}
```