> This page is for Home.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://developers.webflow.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://developers.webflow.com/_mcp/server.

# Streaming HTTP Responses for Webflow Cloud

> Webflow Cloud apps can now stream HTTP responses incrementally for long-running and real-time workflows.

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

```ts
export function handleRequest(request: Request): Response {
  const encoder = new TextEncoder();

  const stream = new ReadableStream({
    async start(controller) {
      // Send an immediate first chunk so the client receives output quickly.
      controller.enqueue(encoder.encode("event: progress\ndata: started\n\n"));

      const steps = [
        "validated input",
        "queried upstream services",
        "aggregated partial results",
      ];

      for (const step of steps) {
        await wait(400);
        controller.enqueue(
          encoder.encode(`event: progress\ndata: ${step}\n\n`)
        );
      }

      controller.enqueue(encoder.encode("event: done\ndata: complete\n\n"));
      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      "Content-Type": "text/event-stream; charset=utf-8",
      "Cache-Control": "no-cache",
      Connection: "keep-alive",
    },
  });
}

function wait(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}
```

## 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](/webflow-cloud/environment/nodejs-compatibility) for Web API guidance such as Streams API and `TextEncoder` usage, and [resource limits](/webflow-cloud/limits) for request constraints such as timeout limits.