You can also check out this library: https://github.com/outerbase/browsable-durable-object?tab=readm

BBrayden You can also check out this library: https://github.com/outerbase/browsable-dura...

A

ac•4/4/25, 11:58 AM

Got it, thanks

S

sheffield•4/4/25, 10:13 PM

i'm running into an issue where i have a longer running task on a durable object that sometimes exceeds 30s. after the workers announcement on increased CPU time, i set my worker limit to 60s. it shows 60s in the worker settings page. however, for some reason, i'm still seeing the following error on my durable object at 32s:

Durable Object exceeded its CPU time limit and was reset

Durable Object exceeded its CPU time limit and was reset

Durable Object exceeded its CPU time limit and was reset

Durable Object exceeded its CPU time limit and was reset

is there another config that i'm missing to be able to run the durable object to the worker limit of 60s?

Ssheffield i'm running into an issue where i have a longer running task on a durable object...

U

Unsmart•4/6/25, 6:38 AM

Are you using the key-value storage backend? If so based on the limits page it seems that it is still limited to 30s (not sure if that is potentially mistaken - but sounds plausible based on what you described).

But the main cpu limit setting is the only thing that would need to be changed.

UUnsmart Are you using the key-value storage backend? If so based on the [limits page](ht...

S

sheffield•4/6/25, 2:20 PM

i’m using sqlite for this durable object

Ssheffield i’m using sqlite for this durable object

U

Unsmart•4/6/25, 8:25 PM

Hm weird no clue then havent tried any of that myself yet. Have you double checked that a normal worker route will allow for >30s of cpu time?

S

Stealth•4/7/25, 1:28 AM

is it possible to migrate a websocket from one durable object to another in a way that is transparent to the client?

P

plgingras88•4/7/25, 2:07 AM

Now that DO sqlite is GA, how to get a database and a table size ?

SELECT page_size * page_count AS size FROM pragma_page_size, pragma_page_count

returns me a Error: not authorized: SQLITE_AUTH

SStealth is it possible to migrate a websocket from one durable object to another in a wa...

H

Hello, I’m Allie!•4/7/25, 3:01 AM

No, you would need to reconnect from the client

B

Burrito•4/7/25, 4:58 AM

DO is now available in free plan which gets 100k requests per day which is 3 million requests per month, however paid plan is staying the same as before which is 1 million requests per month for free. Seems like an oversight?

BBurrito DO is now available in [free plan](<https://developers.cloudflare.com/durable-ob...

1

1984 Ford Laser•4/7/25, 5:24 AM

It used to be 30mil included with Paid right?

1

1984 Ford Laser•4/7/25, 5:24 AM

Seems like a mistake to me

B

Burrito•4/7/25, 5:24 AM

AFAIK it's always just 1 million included.

1

1984 Ford Laser•4/7/25, 5:25 AM

huh yeah okay

Pplgingras88 Now that DO sqlite is GA, how to get a database and a table size ? SELECT page...

L

lambrospetrou•4/7/25, 7:13 AM

You can get the database size already: https://developers.cloudflare.com/durable-objects/api/storage-api/#databasesize

ctx.storage.sql.databaseSize

ctx.storage.sql.databaseSize

ctx.storage.sql.databaseSize

ctx.storage.sql.databaseSize

Llambrospetrou You can get the database size already: https://developers.cloudflare.com/durable...

L

lambrospetrou•4/7/25, 7:16 AM

The pragmas you can use are these: https://developers.cloudflare.com/d1/sql-api/sql-statements/#compatible-pragma-statements
(yes it's on the D1 docs, but they apply to the SQLite DOs, it's the same SQLite under the hood)

BBurrito DO is now available in [free plan](<https://developers.cloudflare.com/durable-ob...

U

Unsmart•4/7/25, 7:40 AM

Not really just easier to make the limit of workers and DOs the same on free to avoid issue

U

Unsmart•4/7/25, 7:41 AM

I guess you still technically can hit the limit but allowing 1 per request seems reasonable

B

Burrito•4/7/25, 8:01 AM

Right, free plan DO matching free plan worker makes sense, I'm most pointing out that free plan DO has more than paid plan DO.

M

muqsit•4/7/25, 10:54 AM

hey

M

muqsit•4/7/25, 10:55 AM

im doing longpolling using an EventEmitter, will i incur idle costs as it keeps DO alive?

export class Emitters extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.default = new EventEmitter();
  }

  async send(command){
    this.default.emit("command", command)
  }

  async wait(){
    return await new Promise(resolve => {
      this.default.once("command", e => resolve(e), {once: true})
    })
  }
}

export class Emitters extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.default = new EventEmitter();
  }

  async send(command){
    this.default.emit("command", command)
  }

  async wait(){
    return await new Promise(resolve => {
      this.default.once("command", e => resolve(e), {once: true})
    })
  }
}

export class Emitters extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.default = new EventEmitter();
  }

  async send(command){
    this.default.emit("command", command)
  }

  async wait(){
    return await new Promise(resolve => {
      this.default.once("command", e => resolve(e), {once: true})
    })
  }
}

export class Emitters extends DurableObject {
  constructor(ctx, env) {
    super(ctx, env);
    this.default = new EventEmitter();
  }

  async send(command){
    this.default.emit("command", command)
  }

  async wait(){
    return await new Promise(resolve => {
      this.default.once("command", e => resolve(e), {once: true})
    })
  }
}

S

Silvan•4/7/25, 10:57 AM

I was actually wondering what the best way of doing

PRAGMA optimize

PRAGMA optimize

PRAGMA optimize

PRAGMA optimize is when using DO as dynamic DB :thinkies:

i already have migration logic but i dont really know if migrations got "skipped" because there was no change on that DO and running that command on every initialization seems silly

SSilvan I was actually wondering what the best way of doing ``PRAGMA optimize`` is when ...

L

lambrospetrou•4/7/25, 11:00 AM

Some guidelines from D1: https://developers.cloudflare.com/d1/sql-api/sql-statements/#pragma-optimize
Apply to the SQLite DOs too.

Llambrospetrou Some guidelines from D1: https://developers.cloudflare.com/d1/sql-api/sql-statem...

L

lambrospetrou•4/7/25, 11:03 AM

I haven't done it myself, but in theory you could also put the pragma in your migrations as well if you edit indices or the schema so your migrations run it for you in those cases. Then, it depends up to your case how often you want to run it after that.

Llambrospetrou I haven't done it myself, but in theory you could also put the pragma in your mi...

S

Silvan•4/7/25, 11:06 AM

from my understanding it would still run the pragma on every single DO init tho.it might skip the create/modify tables but the pragma will be ran and from what i know the pragma is "rather heavy" query

S

Silvan•4/7/25, 11:07 AM

for some context this is how i handle migrations

export class AuthDO extends DurableObject {
    storage: DurableObjectStorage;
    db: DrizzleSqliteDODatabase;
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        this.storage = ctx.storage;
        this.db = drizzle(this.storage, { logger: false });
        // Make sure all migrations complete before accepting queries.
        // Otherwise you will need to run `this.migrate()` in any function
        // that accesses the Drizzle database `this.db`.
        ctx.blockConcurrencyWhile(async () => {
            await this._migrate();
        });
    }
    async _migrate() {
        migrate(this.db, migrations);
    }
    async auth(req: Request) {
        return auth(this.db).handler(req);
    }
}

export class AuthDO extends DurableObject {
    storage: DurableObjectStorage;
    db: DrizzleSqliteDODatabase;
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        this.storage = ctx.storage;
        this.db = drizzle(this.storage, { logger: false });
        // Make sure all migrations complete before accepting queries.
        // Otherwise you will need to run `this.migrate()` in any function
        // that accesses the Drizzle database `this.db`.
        ctx.blockConcurrencyWhile(async () => {
            await this._migrate();
        });
    }
    async _migrate() {
        migrate(this.db, migrations);
    }
    async auth(req: Request) {
        return auth(this.db).handler(req);
    }
}

export class AuthDO extends DurableObject {
    storage: DurableObjectStorage;
    db: DrizzleSqliteDODatabase;
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        this.storage = ctx.storage;
        this.db = drizzle(this.storage, { logger: false });
        // Make sure all migrations complete before accepting queries.
        // Otherwise you will need to run `this.migrate()` in any function
        // that accesses the Drizzle database `this.db`.
        ctx.blockConcurrencyWhile(async () => {
            await this._migrate();
        });
    }
    async _migrate() {
        migrate(this.db, migrations);
    }
    async auth(req: Request) {
        return auth(this.db).handler(req);
    }
}

export class AuthDO extends DurableObject {
    storage: DurableObjectStorage;
    db: DrizzleSqliteDODatabase;
    constructor(ctx: DurableObjectState, env: Env) {
        super(ctx, env);
        this.storage = ctx.storage;
        this.db = drizzle(this.storage, { logger: false });
        // Make sure all migrations complete before accepting queries.
        // Otherwise you will need to run `this.migrate()` in any function
        // that accesses the Drizzle database `this.db`.
        ctx.blockConcurrencyWhile(async () => {
            await this._migrate();
        });
    }
    async _migrate() {
        migrate(this.db, migrations);
    }
    async auth(req: Request) {
        return auth(this.db).handler(req);
    }
}

SSilvan from my understanding it would still run the pragma on every single DO init tho....

L

lambrospetrou•4/7/25, 11:07 AM

Usually migration tools don't rerun statements and they keep track of what they already run. Not sure if Drizzle actually runs everything again though, that would be surprising (but I didn't verify).

Llambrospetrou Usually migration tools don't rerun statements and they keep track of what they ...

S

Silvan•4/7/25, 11:08 AM

wait no i get your point it probably keeps track of the migration file not the queries inside you are probably right

S

Silvan•4/7/25, 11:09 AM

yea fair point i will try just adding

pragma optimize

pragma optimize

pragma optimize

pragma optimize at the end of the migration. thanks!

M

Milan•4/7/25, 1:03 PM

https://blog.cloudflare.com/building-ai-agents-with-mcp-authn-authz-and-durable-objects/

https://developers.cloudflare.com/changelog/2025-04-07-durable-objects-free-tier/?cf_target_id=7E87D5888AFCB02EF885A3256A7C9828

The Cloudflare Blog

Piecing together the Agent puzzle: MCP, authentication & authorizat...

Cloudflare delivers the toolkit for AI agents with new Agents SDK support for MCP (Model Context Protocol) clients, authentication/authorization/hibernation for MCP servers, and Durable Objects free tier.

Cloudflare Docs

Durable Objects on Workers Free plan

Mmilwel gonna jump in and ask since im curious, but outside of cost etc, how come there ...

M

milwel•4/7/25, 1:36 PM

i predicted it!

M

milwel•4/7/25, 1:37 PM

time to build some DO projects

S

Silvan•4/7/25, 1:48 PM

Wow what did i go on the paid plan for then

(jk happily paying the 5 dollars for this insane infra)

V

veeque•4/7/25, 2:17 PM

now that the sql backend is the recommended backend, should i also assume the kv api is not something i should use unless i have to? i just like that api for things that don't really require me to have a schema

M

Matt•4/7/25, 2:17 PM

kv api will use the sqlite db behind the scenes

MMatt kv api will use the sqlite db behind the scenes

V

veeque•4/7/25, 2:20 PM

yes, but is that something they plan on dropping but don't say it yet? (just like pages will be dropped but they don't yet deprecate it)

Vveeque yes, but is that something they plan on dropping but don't say it yet? (just lik...

M

Matt•4/7/25, 2:24 PM

hope not

V

veeque•4/7/25, 2:26 PM

hope

M

Milan•4/7/25, 2:42 PM

I don't see why we would stop supporting the KV API for SQL backed DOs. It runs on the same infrastructure as SQL and already works fine. If we were going to drop it, we probably just wouldn't have supported it in SQL backed DOs in the first place.

I

Isaac McFadyen•4/7/25, 2:56 PM

^ That API is actually backed by an internal SQLite table if using SQLite DOs now, not the distributed DB that was backing it before

MMilan I don't see why we would stop supporting the KV API for SQL backed DOs. It runs ...

V

veeque•4/7/25, 3:02 PM

needed a little bit of reassurance

Original message was deleted

M

Milan•4/7/25, 3:54 PM

Hey 👋 I have a DO based off of this might help clear up confusion?

UUnsmart Hm weird no clue then havent tried any of that myself yet. Have you double check...

S

sheffield•4/7/25, 4:35 PM

good question. i haven't tested that, but will momentarily

UUnsmart Hm weird no clue then havent tried any of that myself yet. Have you double check...

S

sheffield•4/7/25, 5:16 PM

tested this with a worker with the same cpu_ms = 60000 limit and it runs to ~62s and times out, as expected

V

veeque•4/7/25, 5:18 PM

with the kv api how many row reads would a

list()

list()

list()

list() call incur?

V

veeque•4/7/25, 5:18 PM

in https://developers.cloudflare.com/durable-objects/platform/pricing/#sqlite-storage-backend

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.

D

DiamondDragon•4/7/25, 8:06 PM

It would be great to see more writing on what DO's enable compared to the "existing paradigms".

For example, I understand the "one DO per chat" use case well. That data likely scales well under the 10gb limit. I understand there's other benefits here like persistent WS connections and so forth.

But for use cases like one DO per user, having not built an app in a "one DB per user" architecture before, I wonder "why not just go the route of a multi-tenant DB... seems a lot more simple for most use cases". It's also a "standard" and easy to wrap your head around. Just spin up a relational DB on one of many vendors and go about your day

But then for other use cases where they are less granular, like "one DO per [insert large entity]", then I wonder if 10gb is too limited for this [larger scoped entity]. Like "one DO per Zip Code to store all Places like a google map place entity". Maybe 10gb is not enough when you are further zoomed out

On the other hand, when the entity is more granular/lower level, like "one DO per todo in a todo app" (i guess this is similar to the chat app use case mentioned above), I then wonder, is it worth the extra complexity for this todo app when the "todo" entity might be straight forward in a normal muti tenant db architecture.

I'm not a professional dev by day so perhaps I don't have the experience/knowledge to think outside the box for this new DO architecture... but I hope the above comments help explain where it's tougher for me to reason about DOs and I just bounce around thinking the above

DDiamondDragon It would be great to see more writing on what DO's enable compared to the "exist...

L

Larry•4/7/25, 8:58 PM

You are not the first person to struggle wrapping their head around it. Trying a new paradigm is not for everyone. You hit on one big advantage already-hibernatable WebSockets.

I'll add the one that is the biggest for me but not talked about much except by DO's father, Kenton Varga. Zero latency storage means you can treat it as almost as fast as memory, which means you can do many synchronous round trips using super simple SQL and do all the logic in code. This combined with single threaded execution as well as the DO system's input/output gates , means (by following a few easy patterns) you never have to think about all of the worries of systems with shared mutable state (race conditions, consistency, atomicity, etc.). See: https://sqlite.org/np1queryprob.html

Compare this to your alternative of "Just spin up a relational DB...". You either need to accept the user experience and complexity of eventual consistency or the complexity of transactions. It's a lot easier to write a "transaction" by interleaving simple SQL statement and JavaScript including loops and branching, than it is to compose a tranditional DB transaction where one step in the transaction is dervived from the results of earlier steps. Here's Kenton talking about that: https://blog.cloudflare.com/durable-objects-easy-fast-correct-choose-three/

If you do decide to use DOs, my advice is to go coarse grained and adjust later if need be. My first attempt was too fine grained and the cost of coordinating between entities was, as you said, too complex (and you lose the strong consistency benefits). In the fullness of time, my current approach of one DO per tenant might prove to be too coarse grained. However, I'm keeping an eye on how rapidly I approach the storage limit for each tenant. I think I'll be OK indefinetly and I have ideas on how (and plenty of time) to deal with that if not.

The Cloudflare Blog

Durable Objects: Easy, Fast, Correct — Choose three

When multiple clients access the same storage concurrently, race conditions abound. Durable Objects can make it easier. We recently rolled out improvements to Durable Objects that automatically correct many common race conditions while actually making your code faster.

DDiamondDragon It would be great to see more writing on what DO's enable compared to the "exist...

L

lambrospetrou•4/7/25, 9:01 PM

Thinking in sharding is not the straigtforward, most taught, common approach you find on tutorials, indeed.

I suggest taking a look at this page: https://developers.cloudflare.com/durable-objects/what-are-durable-objects/#durable-objects-in-cloudflare

Once you skim through it, read the blog posts we link at the bottom section "Durable Objects in Cloudflare". Each of those blog posts is selected because they describe well how DOs are used in building those products.

Those will give you a good overview of how to think about DOs and how to fit them in your architecture. Having said that, there could be some cases that won't fit well, and will need more mental gymnastics, so as any technology study learn and then decide based on your use-case.

Cloudflare Docs

What are Durable Objects? · Cloudflare Durable Objects docs

A Durable Object is a special kind of Cloudflare Worker which uniquely combines compute with storage. Like a Worker, a Durable Object is automatically provisioned geographically close to where it is first requested, starts up quickly when needed, and shuts down when idle. You can have millions of them around the world. However, unlike regular Wo...

G

gruntlord6•4/7/25, 9:12 PM

idk, every time I read about DO I always thinks its just more complicated then things like regular workers and D1

G

gruntlord6•4/7/25, 9:12 PM

It's mentioned a lot since its the backend that D1 uses but it seems like you take on a lot more complexity using it