// AI Platform Drift

Cloudflare Durable Objects now retry failed calls automatically

Cloudflare developer changelog · published 2026-11-11 06:24 UTC
ACTION NEEDED MIGRATE API
WHAT CHANGEDThe Cloudflare Workers runtime now automatically retries fetch() and RPC calls to Durable Objects when they fail with retryable errors before reaching the object. By default, the runtime retries up to 4 times within a 10-second window. Methods must be explicitly marked with the retryable() decorator from cloudflare:durable-objects to allow retries when the runtime cannot confirm whether the first attempt was received. The retry option on get() or getByName() accepts maxRetries (0-10) and timeoutMs (500-60000ms). Wrangler 4.158.0 or later is required to use retryable() and the retry option.
WHY IT MATTERSExisting retry loops in application code now trigger multiple layers of retries: each application-level attempt includes the runtime's 4 automatic retries. Non-idempotent methods that run twice will corrupt state unless marked retryable() or unless automatic retries are disabled. Code that relied on immediate failure for network errors will now experience up to 10 seconds of delay before seeing an error.
WHAT TO DOAudit Durable Object call sites for existing retry logic and either reduce application-level retry counts or set maxRetries: 0 on stubs where application code handles retries. Mark idempotent methods with retryable() to allow safe retries when delivery confirmation is unavailable. Update to Wrangler 4.158.0 or later to access the new API.
Model-reported confidence 95% (not measured accuracy) Primary source ↗ written by anthropic/claude-sonnet-4.5
Show the reasoning — raw diff, triage verdict, confidence
RAW DIFF
+## Durable Objects, Workers - Automatic retries for Durable Object calls
+https://developers.cloudflare.com/changelog/post/2026-11-05-durable-objects-automatic-retries/
+Thu, 05 Nov 2026 00:00:00 GMT
+
+The runtime now retries fetch() and RPC calls to a Durable Object when they fail with a retryable error before reaching it. This applies whether the caller is a Worker or another Durable Object. Short disruptions, such as brief network interruptions, no longer need a retry loop in your code.
+By default, the runtime retries a call up to four times, and starts no retry more than 10 seconds after the initial call starts. It does not retry errors thrown by your Durable Object code, or errors with .overloaded set to true.
+If the connection drops and the runtime cannot tell whether the Durable Object received the call, it still retries, but the Durable Object rejects the retry if the first attempt arrived. A method never runs twice because of a retry, unless you mark it with retryable() from cloudflare:durable-objects:
+src/index.jsjsimport { DurableObject } from "cloudflare:workers";
+import { retryable } from "cloudflare:durable-objects";
+
+export class Cart extends DurableObject {
+static {
+retryable(this.prototype.setQuantity);
+}
+// Idempotent: a second run sets the same quantity.
+async setQuantity(itemId, quantity) {
+await this.ctx.storage.put(itemId, quantity);
+}
+
+// Not retryable: a second run would add another item.
+async addOne(itemId) {
+const quantity = (await this.ctx.storage.get(itemId)) ?? 0;
+await this.ctx.storage.put(itemId, quantity + 1);
+}
+}src/index.tstsimport { DurableObject } from "cloudflare:workers";
+import { retryable } from "cloudflare:durable-objects";
+
+export class Cart extends DurableObject {
+static {
+retryable(this.prototype.setQuantity);
+}
+// Idempotent: a second run sets the same quantity.
+async setQuantity(itemId: string, quantity: number): Promise<void> {
+await this.ctx.storage.put(itemId, quantity);
+}
+
+// Not retryable: a second run would add another item.
+async addOne(itemId: string): Promise<void> {
+const quantity = (await this.ctx.storage.get<number>(itemId)) ?? 0;
+await this.ctx.storage.put(itemId, quantity + 1);
+}
+}
+To change the limits for one stub, pass a retry option to get() or getByName(). maxRetries accepts 0 to 10 retries, and timeoutMs accepts 500 to 60,000 milliseconds:
+src/index.jsjsconst stub = env.CART.getByName("user-123", {
+retry: { maxRetries: 1, timeoutMs: 2000 },
+});src/index.tstsconst stub = env.CART.getByName("user-123", {
+retry: { maxRetries: 1, timeoutMs: 2000 },
+});
+If you already retry Durable Object calls in your own code, each of your attempts now includes the runtime's retries. Lower your own attempt count, or set maxRetries: 0 on stubs where your code handles retries.
+To use retryable() and the retry option, update to Wrangler 4.158.0 or later.
+For more information, refer to Automatic retries.
HOW IT WAS JUDGED
Triage signals below are model-reported assertions, preserved verbatim; they are not independent arithmetic verification.
triage verdictMATERIAL at 0.92, needed 0.5
triage reasoningNew automatic retry behavior changes execution semantics and requires code changes to avoid double-retry loops.
signalsnew runtime behavior: automatic retries for Durable Object calls · default retry limit: 4 retries, 10-second window · new API: retryable() decorator from cloudflare:durable-objects · new parameter: retry option with maxRetries (0-10) and timeoutMs (500-60000) · breaking semantic change: existing retry loops now double-retry unless adjusted · tool requirement: Wrangler 4.158.0 or later · idempotency requirement: methods must be marked retryable() to safely retry
suppression—
triage modelanthropic/claude-haiku-4.5 ($0.00000)
writer modelanthropic/claude-sonnet-4.5 ($0.00000)