Software economics and Korea inbound research, from Seoul.

Bar chart comparing monthly Cloudflare Durable Objects bills of 203, 572 and 4,268 dollars at 10, 100 and 1,000 always-on objects against 129, 206 and 978 dollars for the same code on AWS

Cloudflare Durable Objects Pricing 2026: $4.11 per Awake Object vs AWS

30-Second Verdict — Direct Answer

Cloudflare bills 128 MB for every Durable Object that stays awake, used or not, so Cloudflare Durable Objects pricing works out to 4.11 USD a month per awake object at 12.50 USD per million GB-seconds. The 400,000 GB-seconds inside Workers Paid cover 1.2 objects. Moving the same code to AWS is cheaper until egress passes about 5 TB a month.

Your Durable Objects bill, and the AWS bill beside it

interactive

Defaults are assumptions, not readings from your account: Cloudflare list rates of 13 Nov 2026, Rivet’s published OpenOrange model on AWS, and S3 egress at 0.09 USD per GB.

objects
TB
GB
M rows
M
One always-on object—128 MB for 730 h at $12.50 per million GB-s
Cloudflare: duration—328,500 GB-s per object-month, less the 400,000 included
Cloudflare: total—$5 Workers Paid plus duration, requests, storage and rows
OpenOrange on AWS: total—Compute, S3 storage, rows, and egress after 100 GB
Monthly difference—Positive means moving to AWS saves this much a month
Egress where it flips—TB a month of egress at $0.09 per GB before AWS costs more

Arithmetic only. Every object in the first field is assumed active for all 730 hours. Ignores the Free plan, D1, R2, Enterprise contracts, AWS support plans, savings plans, VAT and the engineering hours of a migration.

What Cloudflare meters, in its own numbers

The Workers Paid plan starts at 5 USD a month per account and includes 10 million requests plus 30 million CPU-milliseconds. Workers pricing adds one line that decides most cloud comparisons before they start: there is no charge for data transfer out of a Worker. Durable Objects sit on their own sheet, and three meters on it decide whether a migration is worth the trouble at all.

Durable Objects pricing gives 400,000 GB-seconds of duration a month, then charges 12.50 USD per million. Requests get 1 million free, then 0.15 USD per million. Rows written get 50 million free, then 1.00 USD per million. Rows read get 25 billion free, then 0.001 USD per million. Stored SQLite data gets 5 GB-months free, then 0.20 USD per GB-month.

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.

Cloudflare, Durable Objects pricing, read 17 November 2026

That paragraph is the whole article in miniature. A room holding a 3 KB counter and a room holding 120 MB of warm objects pay the same duration rate. An isolate that hosts forty small objects bills as forty full allocations. The unit of cost is the object, not the byte.

The rounding rule then compounds it. Billable usage rounds up to the next unit before the rate applies, so 500,000 GB-seconds of billable duration become 1,000,000 and bill as such. At one object that rounding is a curiosity. At a hundred it is a line item you can see.

MeterRateIncluded each month
Durable Object duration12.50 USD per million GB-s400,000 GB-s
Memory billed per active object128 MB, used or notnone
Durable Object requests0.15 USD per million1 million
SQLite rows written1.00 USD per million50 million
SQLite rows read0.001 USD per million25 billion
SQLite stored data0.20 USD per GB-month5 GB-month
Workers Paid plan5.00 USD minimum10M requests, 30M CPU-ms
Egressno chargenone needed
Table 1. Cloudflare's Durable Objects meters, read from its price list on 17 November 2026. Storage billing for SQLite-backed objects began on 7 January 2026.

The 128 MB floor in three lines of arithmetic

Take one object that stays active for the whole month. Seven hundred and thirty hours is the average month, and 128 MB is 0.125 GB.

  • 0.125 GB x 730 hours = 91.25 GB-hours
  • 91.25 GB-hours x 3,600 = 328,500 GB-seconds
  • 328,500 divided by 1,000,000, times 12.50 USD = 4.11 USD

Then divide the included allowance by that figure. 400,000 divided by 328,500 is 1.22, so a Workers Paid account keeps roughly one object awake for a month before duration costs a cent. Everything above 1.2 objects bills at 4.11 USD per object per month, and requests and rows sit on top of that.

What surprised me in the price list is how narrow that floor actually is. An object that is idle and eligible for hibernation is not billed for duration at all; the meter runs only while the object is active, or idle in memory and unable to sleep.

So the 128 MB charge applies to the hours a room is awake, not to the hours it exists. A document app with ten thousand documents and forty of them open at once pays for forty objects, not ten thousand.

WebSockets are where that reasoning goes wrong quietly. Calling accept() on a socket inside an object incurs duration charges for the entire time the connection is open, and the pricing notes say so directly. A 30-second heartbeat from every client stops the object from ever being eligible to sleep. The cost then scales with concurrent users, which is the one number most products cannot keep flat.

Where the Durable Objects bill is decided

diagram
Where the Durable Objects bill is decided
Figure 1. Five measurements turn Cloudflare's 128 MB floor and AWS's egress meter into a single compare-and-decide line.

Where the bill lands at 10, 100 and 1,000 objects

Here is the same workload on both sides. The assumptions, stated once and used everywhere below: 50 GB of SQLite data, 200 million rows written a month, 20 million requests, 1 TB of egress, a 730-hour month, and every object in the first column awake for all of it.

Always-on objectsCloudflare durationCloudflare totalSame code on AWSMultiple
1036.06 USD202.91 USD128.89 USD1.6x
100405.63 USD572.48 USD206.09 USD2.8x
1,0004,101.25 USD4,268.10 USD978.06 USD4.4x
Table 2. Monthly bill at three fleet sizes. Cloudflare columns are list rates applied to the assumptions above. The AWS column is Rivet's published OpenOrange cost model, not a quote.

Read the multiple, not the totals. The gap widens from 1.6x to 4.4x as object count climbs, because duration is the only line that scales with objects, and duration is where the two rate cards differ most.

The AWS column is not a quote and should not be read as one. It is Rivet's published model for OpenOrange, which prices Durable Object compute against Graviton EC2 in us-east-1 with 40 percent headroom, storage against S3 in your own account, and rows at about 0.18 USD per million.

Everything else about that workload, including the machine you rent whether it is busy or not, is already inside those three rates.

The 4.8x claim is right, and answers a different question

OpenOrange is a new open-source project from Rivet that runs an existing Worker and its Durable Objects on AWS, Google Cloud, Azure or your own machines without code changes, under Apache 2.0 when you self-host it.

Its README states the comparison plainly: compute at 0.0094 USD per GB-hour against 0.045, storage at 0.023 against 0.20, rows at about 0.18 per million against 1.00. That is 4.8x, 8.7x and 5.7x.

The arithmetic holds against Cloudflare's own sheet. 12.50 USD per million GB-seconds times 3,600 seconds is 0.045 USD per GB-hour, and 0.045 divided by 0.0094 is 4.79. So the number is not marketing. It is the same measurement taken on both sides.

What it compares, though, is memory-hours against memory-hours, and that is the point where a ratio stops being a bill. Cloudflare charges only for objects that are active, so a fleet that sleeps 80 percent of the day has no comparable duration line for a ratio to divide.

Two thirds of the saving in that table can vanish simply because the objects were never awake for it to apply to.

Then there is the part the ratio cannot price. OpenOrange hands you machines, a control plane, container images and S3 buckets. Running that yourself, or paying Rivet to run it, is a real cost in hours or in support, and it does not appear in any per-GB figure. The comparison is honest about rates and silent about operations, which is normal for a README and dangerous for a decision.

Egress is the counterweight

Cloudflare charges nothing for data transfer out of Workers or R2. AWS charges 0.09 USD per GB out of S3 to the internet after the first 100 GB a month, per the S3 rate card. One terabyte out is 924 billable GB, or 83.16 USD. Ten terabytes is 921.60 USD, which is more than the compute saving at a hundred objects.

Egress a monthCloudflare totalSame code on AWSCheaper
0.1 TB572.48 USD123.14 USDAWS, by 4.7x
1 TB572.48 USD206.09 USDAWS, by 2.8x
5 TB572.48 USD574.73 USDlevel
10 TB572.48 USD1,035.53 USDCloudflare, by 1.8x
Table 3. Egress sensitivity at 100 always-on objects with the other assumptions held fixed. The Cloudflare total does not move because egress is not a Worker meter.

At a hundred objects the two bills cross at about 5 TB of egress a month. Solve it directly rather than eyeballing the table: the cost difference between the two sides, with egress held at zero, is 449.55 USD; divide by 0.09 and add the free 100 GB, and the answer is 4,980 GB. That is the breakeven volume for this workload.

Which side of that line you sit on is a product question. A CRDT document app, a chat product or a JSON API is byte-light and lands on the left. A file product, a media app, or anything serving images from the same origin lands on the right, and no amount of compute arbitrage pulls it back. If the bytes are the product, the egress meter is the business model.

There is a middle path that gets overlooked: keep Workers, and move only the bytes to R2, which has no egress charge. That removes 83.16 USD from the AWS column instead of 405.63 USD from the duration column, and it costs a weekend rather than a migration.

The same shape of question in a wider frame is what the Vercel Pro vs Cloudflare Workers billing teardown works through, where one traffic pattern turns into two invoices.

What moves, and what does not

The claim worth the most suspicion is the one about migration being free. It is true for code. It is not true for data, and the migration guide says so in a table of its own.

  • KV-backed Durable Object classes: the prepare step fails and names the class, because Cloudflare exports no data for them.
  • Classes the migrator cannot reach through a binding: prepare stops with an error.
  • FTS5 virtual tables inside an object: the export of that object fails.
  • Objects that sit in a jurisdiction: they fail to start on the other side.
  • Facets: not exported, so the parent object moves without them.
  • KV and R2 data: listed on a Not moved line, and you copy it yourself.
  • D1 databases: writes fail from the start of the move until the switch, about 3 minutes per GB, and every query fails during export, about 47 seconds per GB.

Plenty does survive, and the list is worth reading before you plan around a fear. Alarms move and are removed on the old side. SQL tables keep rowids, indexes, triggers, views and AUTOINCREMENT counters. Values keep their types, including Date, Map and BigInt. An id stored from newUniqueId() survives as the same string, while an id derived from idFromName() keeps its name but not its string, so anything that stored that string needs a lookup.

Rollback is real too: point the domain back at Cloudflare, then set MIGRATOR_DISABLED on the prepared Worker. One caveat is stated plainly and matters more than it looks, because a D1 database that moved stays moved.

Fix the socket before you re-platform

Before pricing another cloud, test whether the duration line survives contact with the Hibernation API. Both blocks below are Cloudflare's own, from its WebSocket guide, and both are standard API that keeps working wherever the code ends up.

Two copy-ready blocks from Cloudflare’s guide

copy-ready

Both blocks are from Cloudflare's Durable Objects WebSocket guide, read on 17 November 2026. The first changes one method call; the second keeps ping traffic off the meter.

src/room.js
import { DurableObject } from "cloudflare:workers";

export class Room extends DurableObject {
  async fetch() {
    const pair = new WebSocketPair();
    const [client, server] = Object.values(pair);
    // not ws.accept(): acceptWebSocket() lets the object sleep
    this.ctx.acceptWebSocket(server);
    return new Response(null, { status: 101, webSocket: client });
  }
  async webSocketMessage(ws, message) {
    ws.send("connections: " + this.ctx.getWebSockets().length);
  }
}
constructor or fetch
// no wall-clock time is billed for these replies
this.ctx.setWebSocketAutoResponse(
  new WebSocketRequestResponsePair("ping", "pong")
);

Hibernation resets in-memory state and re-runs the constructor on the next event, so keep it small and store per-connection state with serializeAttachment().

The first block replaces ws.accept() with this.ctx.acceptWebSocket(server). Same connection, same handlers, and the object becomes eligible for eviction while it sits idle. The second answers pings inside the edge, and the pricing sheet confirms that application-level auto-responses handled this way add no wall-clock time to the object.

The trade is state. A hibernated object loses its in-memory state and re-runs its constructor on the next event, so anything kept per connection belongs on the socket through serializeAttachment(). Two minutes of refactoring here is usually worth more than the entire rate-card difference for a small fleet.

Where the rest of the bill hides

Row writes are the second surprise, and they hide in two details. Deletes count as writes, and every setAlarm() is one row written. A chat product that writes three rows per message and sends 20 million messages a month writes 60 million rows, so 10 million of them bill at 1.00 USD per million.

Alarms are the quieter leak. A scheduler that calls setAlarm() on every tick, once a second across 50 objects, books 129.6 million writes a month on its own. That is 130 USD of bookkeeping, and it never shows up as alarm traffic on a dashboard, because the meter counts writes and not wakes.

Storage is the third. SQLite Durable Objects started billing stored data on 7 January 2026: 5 GB-months free, then 0.20 USD per GB-month, which is 8.7x the S3 rate for the same bytes. Rows read are rarely the problem, since 25 billion a month are free and 0.001 USD per million after that is a rounding error beside a single row-write mistake.

How to get your own five numbers

The calculator at the top of this page does arithmetic. It cannot read your account, so collect five numbers first, and resist the urge to estimate them from your architecture diagram.

  1. Always-on objects. The Durable Objects tab in the Workers dashboard reports object and duration metrics; take GB-seconds for a representative week and divide by 328,500 to get full-time-equivalent objects.
  2. Egress. Total bytes served to browsers for the month, from your Worker metrics or your access logs.
  3. Stored data. Gigabytes of SQLite rows kept for the month, not the size of the database file on a laptop.
  4. Rows written. Millions per month, counting deletes and every alarm.
  5. Requests. Millions per month, counting each RPC method call as one and 100 incoming WebSocket messages as five.

Put those five in and the difference line answers the migration question in a way a README cannot. If the answer is under a few hundred dollars a month, the migration is a hobby, and the hibernation blocks above are the better weekend.

For a wider frame that folds in machine rental, backups and admin hours, the site's TCO decision calculator takes the same meters as inputs, and the self-hosted chat playbook prices what running the box yourself actually costs in hours. The prepay break-even calculator covers the other half of the question, which is when paying a year up front beats a monthly bill.

The Honest Catch

To be honest, there are two limits on this analysis. It does not price your time, and it assumes every object in the model is awake for the whole month. If half the fleet sleeps, the Cloudflare column falls roughly in half and the AWS column does not move at all, because the machines are rented whether the objects are busy or not.

It also cannot see a contract. Workers Enterprise pricing is negotiated, an existing committed discount can swing the comparison further than any published rate, and no public sheet will tell you what yours says. If you are on Enterprise, treat both columns as the starting point of a conversation rather than its conclusion.

Who should skip the migration

Skip it if egress is measured in terabytes, if KV-backed classes or FTS5 tables are load-bearing, if a D1 window of minutes per gigabyte is unacceptable, or if the saving lands under about 300 USD a month. In each of those cases the code is not the expensive part, and the move buys a smaller number on a bill you were already going to pay.

Keep the platform and fix the object lifecycle instead. Hibernation, auto-responses and an alarm audit are risk-free changes against a published API, they cut the two lines that scale with objects, and they survive any later migration because they are standard.

FAQ

Does an idle Durable Object cost anything?

No duration charge while it is idle and eligible for hibernation. It still costs storage for the rows it holds, at 0.20 USD per GB-month after the first 5 GB-months, and the billing notes confirm that stored data bills until the data is removed.

Is 128 MB really billed when the object uses 1 MB?

Yes. Cloudflare's sheet says the charge applies regardless of actual usage, and objects that share an isolate still bill as full 128 MB allocations each. A hundred tiny objects cost the same duration as a hundred large ones.

Why is the AWS comparison 4.8x when the final bill is 2.8x?

Because 4.8x covers duration only. Once 1 TB of egress enters at 0.09 USD per GB, the AWS total at a hundred objects lands at 206.09 USD against 572.48 USD on Cloudflare. That is 2.8x, and at 10 TB the same comparison flips in Cloudflare's favour.

Can I run both platforms at once?

Yes, and it is the least risky route: prepare the Worker, deploy it to the other side with no traffic, move D1 at a quiet hour, then point DNS over once the backfill reports zero moved and zero failed. Cloudflare stays untouched until you delete it yourself.

The short version

  • 4.11 USD is one awake object for a month, and 1.2 of them are free inside Workers Paid.
  • Duration scales with object count, not with the memory those objects use.
  • The 4.8x compute ratio is real arithmetic; the bill gap at a hundred objects is 2.8x once egress is counted.
  • The two bills cross at roughly 5 TB of egress a month, and bytes are the deciding variable.
  • Code moves with no changes; KV, R2, FTS5 objects and a D1 window do not.
Line chart: the Cloudflare bill stays flat at 572 dollars a month while the AWS bill rises with egress and crosses it at 4.98 terabytes
Figure 2. With 100 always-on objects the two bills cross at 4.98 TB of egress a month.

Leave a Reply