Running the Anthropic SDK on Edge Runtimes

The official @anthropic-ai/sdk package is built on fetch, so it runs unmodified on edge runtimes like Vercel Edge Functions, Cloudflare Workers, and Deno Deploy, not just in Node.js. This page covers how to configure the client and stream responses correctly on each platform.

Summary

Edge runtimes are lightweight JavaScript environments that run close to the request, often without the full Node.js API surface. They don't have fs, net, or many other Node built-ins available.

@anthropic-ai/sdk avoids that problem because its request path is built on the standard fetch API, ReadableStream, and AbortController, all of which are available in every modern edge runtime.

The main differences between edge and Node.js deployments are how you read the API key (environment variable access differs per platform) and how you return a streamed response (edge handlers typically return a Response object directly instead of writing to a Node.js http.ServerResponse).

This page walks through a Vercel Edge Function (via a Next.js route handler), a Cloudflare Worker, and notes on Deno Deploy, each configuring the client and streaming a reply back to the caller.

Timeouts and cancellation work the same way on edge as they do in Node.js: pass an AbortSignal to the request, or rely on the SDK's own timeout setting, but remember the platform itself also imposes its own execution time limit on top of whatever you configure.

Recipe

Quick-reference recipe card, copy-paste ready.

// Works identically on Node.js, Vercel Edge, Cloudflare Workers, and Deno Deploy
import Anthropic from "@anthropic-ai/sdk";
 
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
const message = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Explain edge runtimes in one paragraph." }],
});
 
console.log(message.content);

When to reach for this:

• Serving low-latency Claude responses from a location close to the user (Vercel Edge, Cloudflare Workers both run at the network edge).
• Deploying to a platform that doesn't support the full Node.js runtime (Cloudflare Workers, Deno Deploy).
• Streaming a chat response directly back to the browser without buffering the full reply first.
• Keeping a serverless function's cold-start time low; edge runtimes generally start faster than Node.js functions.

Working Example

Vercel Edge Function (Next.js route handler)

// app/api/chat/route.ts
import Anthropic from "@anthropic-ai/sdk";
 
export const runtime = "edge";
 
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
export async function POST(req: Request) {
  const { prompt } = await req.json();
 
  const stream = await anthropic.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
    stream: true,
  });
 
  const encoder = new TextEncoder();
 
  const body = new ReadableStream({
    async start(controller) {
      for await (const event of stream) {
        if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
          controller.enqueue(encoder.encode(event.delta.text));
        }
      }
      controller.close();
    },
  });
 
  return new Response(body, {
    headers: { "Content-Type": "text/plain; charset=utf-8" },
  });
}

What this demonstrates:

• Setting export const runtime = "edge" opts the Next.js route handler into the Vercel Edge runtime.
• The API key is read from process.env.ANTHROPIC_API_KEY, which Vercel injects into edge functions the same way it does for Node.js functions, as long as the environment variable is set in the project's settings.
• The SDK's async iterator (for await (const event of stream)) is wrapped in a ReadableStream so the handler can return a streaming Response instead of waiting for the full message.
• Only text_delta content block deltas are forwarded to the client; other event types (message start, content block start/stop, message stop) are ignored for this simple text-streaming case.

Cloudflare Worker

// src/worker.ts
import Anthropic from "@anthropic-ai/sdk";
 
export interface Env {
  ANTHROPIC_API_KEY: string;
}
 
export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    if (request.method !== "POST") {
      return new Response("Use POST", { status: 405 });
    }
 
    const anthropic = new Anthropic({
      apiKey: env.ANTHROPIC_API_KEY,
    });
 
    const { prompt } = await request.json<{ prompt: string }>();
 
    const stream = await anthropic.messages.create({
      model: "claude-sonnet-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: prompt }],
      stream: true,
    });
 
    const encoder = new TextEncoder();
 
    const body = new ReadableStream({
      async start(controller) {
        for await (const event of stream) {
          if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
            controller.enqueue(encoder.encode(event.delta.text));
          }
        }
        controller.close();
      },
    });
 
    return new Response(body, {
      headers: { "Content-Type": "text/plain; charset=utf-8" },
    });
  },
};

What this demonstrates:

• Cloudflare Workers pass configuration and secrets through a typed env object argument to fetch, not through process.env. The ANTHROPIC_API_KEY is declared on an Env interface and read as env.ANTHROPIC_API_KEY.
• The secret itself is set outside the code, with wrangler secret put ANTHROPIC_API_KEY, so it never lives in the repository or the wrangler.toml file.
• The client is instantiated inside the fetch handler (not at module scope) so it always picks up the env bindings for the current request.
• The streaming pattern is identical to the Vercel Edge example because both platforms implement the same ReadableStream and Response web standards.

Canceling the Upstream Call on Client Disconnect

Both examples above can forward the incoming request's own AbortSignal to the SDK call, so a client disconnect cancels the upstream request to Claude instead of letting it run to completion:

const message = await anthropic.messages.create(
  {
    model: "claude-sonnet-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  },
  { signal: request.signal },
);

• Wiring AbortController to the incoming request's signal means canceling the client (closing the browser tab, navigating away) also cancels the upstream call to Claude, instead of letting it run to completion and burning tokens for a response nobody will read.
• request.signal is available on the Request object in both Vercel Edge Functions and Cloudflare Workers because both implement the standard Fetch API.

Deep Dive

How It Works

• @anthropic-ai/sdk sends requests with the global fetch function rather than a Node-specific HTTP client, so it has no dependency on Node built-ins like http, https, or net for its core request path.
• Streaming responses from the Messages API arrive as server-sent events, which the SDK parses and exposes as an async iterable of typed message events (for await (const event of stream)).
• Edge runtimes execute your handler in a lightweight, often V8-isolate-based sandbox, not a full Node.js process, which is why Node-only APIs (fs, child_process, native modules) aren't available and why a fetch-based SDK is the deciding factor for compatibility.
• Because the request/response cycle in an edge handler is built on the same Request/Response/ReadableStream primitives the SDK uses internally, you can pipe the SDK's stream straight into the function's return value without an adapter layer.

API Key Handling by Platform

Deno Deploy Notes

// main.ts (Deno Deploy)
import Anthropic from "npm:@anthropic-ai/sdk";
 
const anthropic = new Anthropic({
  apiKey: Deno.env.get("ANTHROPIC_API_KEY"),
});
 
Deno.serve(async (request: Request) => {
  const { prompt } = await request.json();
 
  const message = await anthropic.messages.create({
    model: "claude-sonnet-5",
    max_tokens: 1024,
    messages: [{ role: "user", content: prompt }],
  });
 
  return Response.json(message);
});

• Deno Deploy imports npm packages with the npm: specifier, so import Anthropic from "npm:@anthropic-ai/sdk" works without a package.json or a build step.
• Secrets are read with Deno.env.get(...), not process.env; Deno does expose a process shim for compatibility, but Deno.env is the native, recommended path.
• Deno.serve is the built-in HTTP entry point on Deno Deploy and, like the other two platforms, takes and returns standard Request/Response objects.

TypeScript Notes

// Narrow the streaming event union before reading delta.text
for await (const event of stream) {
  if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
    // event.delta.text is safely typed as string here
    process.stdout.write(event.delta.text);
  }
}

• The SDK ships its own TypeScript types, so message.content, streaming events, and error classes are all typed without extra @types packages.
• Streaming events are a discriminated union on event.type; narrowing with an if check (as above) is what lets TypeScript know event.delta.text exists, rather than reaching for a type assertion.
• Avoid as any casts on the client's apiKey option. If process.env.ANTHROPIC_API_KEY (or env.ANTHROPIC_API_KEY) is undefined at runtime because the variable wasn't set, let the SDK throw its normal authentication error rather than silencing the type checker.

Parameters & Return Values

Gotchas

• Reading process.env on Cloudflare Workers. Cloudflare Workers do not populate process.env with secrets by default; they pass configuration through the env argument on the fetch handler. Fix: read env.ANTHROPIC_API_KEY inside the handler, not process.env.ANTHROPIC_API_KEY at module scope.
• Instantiating the client at module scope on Cloudflare Workers. If you build the Anthropic client outside the fetch handler, env isn't available yet when the module loads. Fix: construct the client inside the handler function where env is passed in as an argument.
• Assuming edge runtimes have no timeout. Vercel Edge Functions, Cloudflare Workers, and Deno Deploy each enforce their own maximum execution or CPU time per request, on top of anything you configure on the SDK client. Fix: check the current limits for your plan on each platform and design long-running generations around streaming (return partial output as it arrives) rather than waiting for one large non-streamed response.
• Forgetting to set stream: true and then trying to iterate the result. Calling anthropic.messages.create() without stream: true returns a single resolved Message object, not an async iterable; attempting a for await loop over it fails. Fix: pass stream: true in the request parameters whenever you intend to consume the response as a stream.
• Not narrowing the streaming event union before reading delta.text. Streaming events include several types (message_start, content_block_start, content_block_delta, content_block_stop, message_stop, and more), and only content_block_delta events with delta.type === "text_delta" carry .text. Fix: check both event.type and event.delta.type before reading event.delta.text.
• Leaving the API key in client-side code. Because edge functions run server-side, it's tempting to think any code in the same repo is safe, but a key hardcoded into a route handler that also ships a client bundle (or copy-pasted into a Cloudflare Worker committed to source control) can leak. Fix: always load the key from an environment variable or secret store, never hardcode it, and add .env* files to .gitignore.
• Assuming AbortController needs a Node-specific import. AbortController and AbortSignal are global in Node.js 18+, all major browsers, and every edge runtime covered here, so no import or polyfill is needed. Fix: just use the global AbortController, or forward request.signal from an incoming Request when you want client disconnects to cancel the upstream Claude call.

Alternatives

FAQs

Related

• TypeScript/JavaScript SDK Basics - installing the SDK and sending your first typed Messages API call.
• Async Iterators for Streaming in the TypeScript SDK - a closer look at consuming streamed message deltas.
• Retry, Timeout, and AbortController Patterns in the TypeScript SDK - tuning backoff and cancellation in more depth.
• Building a Streaming Chat Endpoint with Next.js and the TypeScript SDK - a full chat endpoint built on the streaming pattern shown here.
• The Anthropic TypeScript SDK Mental Model - how the SDK's request/response and streaming model fits together.

Stack versions: Written against the Claude model lineup current as of ~June 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (the default), and Claude Haiku 4.5 - and the official @anthropic-ai/sdk TypeScript SDK (latest release). Model names, SDK versions, and pricing move quickly - verify current specifics at platform.claude.com/docs before relying on them.