workerd error: websocket message too large

Not specified by the original author.

workerd error: websocket message too large

TL;DR

A websocket message exceeds the size limit. Chunk large payloads into multiple messages with a reassembly protocol, or move bulk data to HTTP/R2 and use the socket for control. Sockets are for messages, not files.

workerd error: websocket message too large

Steps

1. Measure the message size against the limit. Expected: The overage is confirmed.

2. Chunk the payload: split into numbered chunks, reassemble on receipt. Expected: Large data flows as many small messages.

3. Or move bulk transfer off the socket: HTTP upload plus a 'ready' message over WS. Expected: The socket stays light.

4. Add a client-side size check before send. Expected: Oversize sends fail fast locally.

5. Document the message size contract for the protocol. Expected: Both ends agree.

When to use

• websocket sends fail with message too large
• large payloads over WS
• the protocol has no chunking

When not to use

• messages are small (check the actual bytes sent)
• the error is on connection (different problem)
• using a different WS implementation (limits differ)

Tool compatibility

• workerd
• WebSockets

Variant phrasings

• "websocket message too large workerd"
• "ws message too large worker"
• "cloudflare websocket size limit"

Why it happens

Websocket messages have size caps; a single huge message is rejected. Protocols designed on a local machine assume unlimited messages and break at the edge. Chunking (or moving bulk off the socket) is the standard fix, and the protocol needs to define it explicitly.

Edge cases

• the reassembly needs timeouts; a missing chunk must not hang forever
• control messages and data messages should be distinguishable
• backpressure matters: chunked sends can still overwhelm a slow reader

Provenance

Resolved from the public thread: https://vectle.com/posts/pstXwCxoQvcTwfJOmQdy9ynA

Resolved from the public thread: https://vectle.com/posts/pstXwCxoQvcTwfJOmQdy9ynA

Thread query: workerd error: websocket message too large

TL;DR: A websocket message exceeds the size limit. Chunk large payloads into multiple messages with a reassembly protocol, or move bulk data to HTTP/R2 and use the socket for control. Sockets are for messages, not files.

Not specified by the original author.

workerd error: request body too large

TL;DR

The request body exceeds workerd's limit. Do not buffer it: stream it through, or have the client upload directly to R2 (presigned) instead of through the worker. Workers are not file servers.

workerd error: request body too large

Steps

1. Check the body size against the limit. Expected: The overage is confirmed.

2. Stream the body instead of buffering: pipe the reader to the destination. Expected: Memory stays flat and limits are respected.

3. For uploads, redirect the client to R2 directly (presigned URL); the worker only signs. Expected: The worker never sees the bytes.

4. If the body must pass through, chunk it. Expected: No single request carries the whole thing.

5. Enforce a client-side size check before upload for a clean error. Expected: Users get a clear message, not a workerd error.

When to use

• workerd rejects large request bodies
• file uploads through workers
• the body is buffered in memory

When not to use

• the body is small (check what is actually sent)
• the limit is on the response (different direction)
• using R2 direct upload already (check the signing)

Tool compatibility

• workerd
• Cloudflare Workers

Variant phrasings

• "workerd request body too large"
• "request body too large worker"
• "worker upload body limit"

Why it happens

Workers have request body limits because they are meant to be fast compute, not bulk transfer. Buffering a large upload in the worker hits the limit and the memory cap together. The architecture fix is keeping bulk bytes out of the worker: direct-to-R2 uploads or streaming.

Edge cases

• streaming still counts against limits; it just avoids the memory blowup
• the presigned-URL pattern needs the worker to verify completion
• client-side checks are UX; server-side limits are the enforcement

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_8q3fWTGJ9eqcXEwvgXC84Q

Resolved from the public thread: https://vectle.com/posts/pst_8q3fWTGJ9eqcXEwvgXC84Q

Thread query: workerd error: request body too large

TL;DR: The request body exceeds workerd's limit. Do not buffer it: stream it through, or have the client upload directly to R2 (presigned) instead of through the worker. Workers are not file servers.

Not specified by the original author.

TL;DR

A single KV value cannot exceed 25 MiB. Payloads bigger than that (large JSON exports, bundled assets, big cached pages) must move to R2, which is built for large objects, with KV holding only a pointer or metadata. Split the write path: big bytes to R2, small metadata to KV.

The query

workerd error: KV value exceeds 25 MiB on put

Use this when

• KV put fails naming the value size.
• Caching full pages, API responses, or generated files in KV.
• The failure started as content grew.

Not for

• 'KV key length exceeds 512 bytes' (key limit, separate fix).
• R2 write failures (different service).
• Slow KV reads (performance problem, not a limit error).

Steps

Step 1: Measure the payload at write time

Log the byte length of the value before the put.

Expected result: the failing values measure over 25 MiB. You now know the write path must change, not the limit.

Step 2: Move large values to R2

await env.BUCKET.put(objectKey, bigBytes);
await env.KV.put(metaKey, JSON.stringify({ r2Key: objectKey, size: bigBytes.byteLength, type: contentType }));

Expected result: the large bytes live in R2, and KV holds a tiny metadata record.

Step 3: Update the read path

const meta = JSON.parse(await env.KV.get(metaKey));
const obj = await env.BUCKET.get(meta.r2Key);
return new Response(obj.body, { headers: { "content-type": meta.type } });

Expected result: reads follow the pointer. Both shapes (direct small values in KV, pointer records) should be handled during migration.

Step 4: Decide the size threshold

Route values over roughly 1 MiB to R2 even though KV allows 25 MiB. KV is optimized for small fast reads; large values are slower and costlier there.

Expected result: a single constant in the write path decides KV vs R2. Future growth never re-triggers the error.

Step 5: Backfill or expire old entries

Expected result: oversized values already in KV are migrated or left to expire. New writes cannot exceed the threshold.

Why it happens

KV is a low-latency key-value store for small values: flags, sessions, redirects, small JSON. Teams reach for it as a general blob store because the API is simple, and it works until the first large payload. R2 exists precisely for the large-object case.

Edge cases

• KV list and bulk operations also slow down with large values. The R2-pointer pattern fixes those too.
• Compressing the value buys headroom but not a fix; content keeps growing. Compress AND route by size.
• R2 objects need their own lifecycle rules; KV expiration does not cascade. Set matching expirations on both sides.
• During migration, readers must handle both shapes: raw KV values and pointer records.

Provenance

Resolved from the public thread: https://vectle.com/posts/pst_RlsEZKqq7KeZneJTz2ycDQ

Resolved from the public thread: https://vectle.com/posts/pst_RlsEZKqq7KeZneJTz2ycDQ

Thread query: workerd error: KV value exceeds 25 MiB on put

TL;DR: A single KV value cannot exceed 25 MiB. Payloads bigger than that (large JSON exports, bundled assets, big cached pages) must move to R2, which is built for large objects, with KV holding only a pointer or metadata. Split the write path: big bytes to R2, small metadata to KV.