Changelog

Streaming HTTP Responses for Webflow Cloud

Webflow Cloud now supports streaming HTTP responses for app routes!

Previously, responses were only delivered in a single payload. Now, your app can send an initial response and continue streaming chunks as work completes.

What’s new

• Streaming responses for app routes - Return output incrementally instead of waiting for the full result.
• Faster first-byte experiences - Start sending data early while backend work is still in progress.
• Progressive response patterns - Stream status updates, partial results, and final output in one request lifecycle.

Why this matters

• Better user experience for long-running work - Users get immediate feedback instead of waiting on a single final response.
• More resilient multi-step workflows - Keep clients informed as your app moves through sequential tasks.
• Lower perceived latency - Early partial output makes responses feel faster and more interactive.

Common use cases

• AI and LLM token streaming for chat, summaries, and code generation
• Multi-step workflows with progress updates such as “Step 1 of 5”
• Large exports and payload delivery, including incremental JSON or CSV output
• Search and aggregation requests that return partial matches as they are available
• Live log and status tailing during active operations

Minimal implementation example

1
export function handleRequest(request: Request): Response {
2
  const encoder = new TextEncoder();
3
4
  const stream = new ReadableStream({
5
    async start(controller) {
6
      // Send an immediate first chunk so the client receives output quickly.
7
      controller.enqueue(encoder.encode("event: progress\ndata: started\n\n"));
8
9
      const steps = [
10
        "validated input",
11
        "queried upstream services",
12
        "aggregated partial results",
13
      ];
14
15
      for (const step of steps) {
16
        await wait(400);
17
        controller.enqueue(
18
          encoder.encode(`event: progress\ndata: ${step}\n\n`)
19
        );
20
      }
21
22
      controller.enqueue(encoder.encode("event: done\ndata: complete\n\n"));
23
      controller.close();
24
    },
25
  });
26
27
  return new Response(stream, {
28
    headers: {
29
      "Content-Type": "text/event-stream; charset=utf-8",
30
      "Cache-Control": "no-cache",
31
      Connection: "keep-alive",
32
    },
33
  });
34
}
35
36
function wait(ms: number): Promise<void> {
37
  return new Promise((resolve) => setTimeout(resolve, ms));
38
}

Implementation guidance

• Send the first chunk as early as possible in the request lifecycle.
• Continue emitting periodic chunks while work is in progress.
• Use clear event payloads so clients can render progress and partial results predictably.
• Close the stream explicitly when processing is complete.
• Handle cancellation and upstream failures by emitting a terminal error event before closing.

For implementation details, see Node.js compatibility for Web API guidance such as Streams API and TextEncoder usage, and resource limits for request constraints such as timeout limits.