Streaming and asynchronous jobs

Streaming to the browser

A Route Handler can forward the streaming API directly as ReadableStream, without buffering the entire document in server memory:

app/api/convert/stream/route.ts

import { getServerClient } from "@markpdf/nextjs";

export const runtime = "nodejs";

export async function POST(req: Request) {
  const client = getServerClient({ apiKey: process.env.MARKPDF_API_KEY! });
  const { url } = await req.json();

  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    async start(controller) {
      try {
        for await (const chunk of client.convertStream({ url })) {
          controller.enqueue(encoder.encode(chunk));
        }
      } finally {
        controller.close();
      }
    },
  });

  return new Response(stream, { headers: { "content-type": "text/markdown; charset=utf-8" } });
}

On the client, consume the response with ReadableStream native or a streaming library of your choice:

async function streamConversion(url: string) {
  const res = await fetch("/api/convert/stream", {
    method: "POST",
    body: JSON.stringify({ url }),
    headers: { "content-type": "application/json" },
  });
  const reader = res.body!.getReader();
  const decoder = new TextDecoder();
  let full = "";
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    full += decoder.decode(value, { stream: true });
  }
  return full;
}

Server Actions do not support response streaming (they are serialized RPC calls, not raw Response calls). For actual streaming to the client, use a Route Handler.

Jobs due to saturation (202) in Server Actions

The convertFormData and convertUrlAction helpers inherit autoPoll from SDK of Node.js (enabled by default): if the server responds 202, the Server Action waits internally for the poll and returns the final Markdown once completed.

app/actions.ts

"use server";

import { convertFormData } from "@markpdf/nextjs";

export async function convertUpload(formData: FormData) {
  // If there were 202, this call takes longer — the Server Action blocks until "completed"
  return convertFormData(formData, {
    apiKey: process.env.MARKPDF_API_KEY!,
    mode: "fast",
  });
}

Server Actions have their own platform timeout (varies depending on your hosting provider). If you expect conversions that may take several minutes due to saturation, consider a Route Handler with manual polling from the client instead of blocking the Server Action.

Manual poll from the client

app/api/jobs/[id]/route.ts

import { getServerClient } from "@markpdf/nextjs";
import { NextResponse } from "next/server";

export async function GET(_req: Request, { params }: { params: { id: string } }) {
  const client = getServerClient({ apiKey: process.env.MARKPDF_API_KEY! });
  const status = await client.getJob(params.id);
  return NextResponse.json(status);
}

async function pollUntilDone(jobId: string): Promise<string> {
  while (true) {
    const res = await fetch(`/api/jobs/${jobId}`);
    const status = await res.json();
    if (status.status === "completed") return status.body;
    if (status.status === "failed") throw new Error(status.error);
    await new Promise((r) => setTimeout(r, 5000));
  }
}

Under normal load conditions you won’t see 202 — it only happens when all backends are saturated. The automatic poll of convertFormData/convertUrlAction already covers it for most cases.

Python

Node.js / TypeScript

C++

Next.js

Angular

React

React Native

Svelte

Bun

Flutter

Java

Kotlin

Streaming and asynchronous jobs

Streaming and asynchronous jobs

Streaming to the browser

Jobs due to saturation (202) in Server Actions

Manual poll from the client

​Streaming and asynchronous jobs

​Streaming to the browser

​Jobs due to saturation (202) in Server Actions

​Manual poll from the client

Streaming and asynchronous jobs

Streaming to the browser

Jobs due to saturation (202) in Server Actions

Manual poll from the client