TypeScript SDK

Diese Bibliothek bietet bequemen Zugriff auf die Claude API aus TypeScript oder JavaScript.

Installation

npm install @anthropic-ai/sdk

Anforderungen

TypeScript >= 5.0 wird unterstützt.

Die folgenden Laufzeitumgebungen werden unterstützt:

• Node.js 20 LTS oder neuere (nicht EOL) Versionen.
• Deno v1.28.0 oder höher.
• Bun 1.0 oder neuer.
• Cloudflare Workers.
• Vercel Edge Runtime.
• Jest 28 oder höher mit der "node"-Umgebung ("jsdom" wird derzeit nicht unterstützt).
• Nitro v2.6 oder höher.
• Webbrowser: standardmäßig deaktiviert, um zu vermeiden, dass deine geheimen API-Zugangsdaten offengelegt werden (siehe Best Practices für API-Keys). Aktiviere die Browser-Unterstützung, indem du dangerouslyAllowBrowser explizit auf true setzt.

Beachte, dass React Native derzeit nicht unterstützt wird.

Wenn du an anderen Laufzeitumgebungen interessiert bist, eröffne ein Issue im GitHub-Repository oder stimme für ein bestehendes ab.

Verwendung

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});

for (const block of message.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

Informationen zu Authentifizierungsoptionen, einschließlich Workload Identity Federation, findest du unter Authentifizierung. Wenn dein API-Key ein persönlicher Key oder Service-Account-Key ist, der nicht auf einen Workspace beschränkt ist, setze die Workspace-ID im Request-Header anthropic-workspace-id; Einen Workspace auswählen zeigt die Option pro Anfrage für dieses SDK.

Anfrage- und Antworttypen

Diese Bibliothek enthält TypeScript-Definitionen für alle Anfrageparameter und Antwortfelder. Du kannst sie wie folgt importieren und verwenden:

const client = new Anthropic({
  apiKey: process.env["ANTHROPIC_API_KEY"] // This is the default and can be omitted
});

const params: Anthropic.MessageCreateParams = {
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
};
const message: Anthropic.Message = await client.messages.create(params);

Die Dokumentation für jede Methode, jeden Anfrageparameter und jedes Antwortfeld ist in Docstrings verfügbar und wird in den meisten modernen Editoren beim Hovern angezeigt.

Token zählen

Du kannst die genaue Nutzung für eine bestimmte Anfrage über die Antworteigenschaft usage einsehen, zum Beispiel:

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message.usage);
// { input_tokens: 25, output_tokens: 13 }

Streaming-Antworten

Das SDK bietet Unterstützung für „streaming" (Streaming) von Antworten mithilfe von „Server-Sent Events" (vom Server gesendete Ereignisse), oder SSE.

const client = new Anthropic();

const stream = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5",
  stream: true
});
for await (const messageStreamEvent of stream) {
  console.log(messageStreamEvent.type);
}

Wenn du einen Stream abbrechen musst, kannst du mit break aus der Schleife aussteigen oder stream.controller.abort() aufrufen.

Streaming-Helfer

Diese Bibliothek bietet mehrere Annehmlichkeiten für das Streaming von Nachrichten, zum Beispiel:

const anthropic = new Anthropic();

const stream = anthropic.messages
  .stream({
    model: "claude-opus-5-5",
    max_tokens: 1024,
    messages: [
      {
        role: "user",
        content: "Say hello there!"
      }
    ]
  })
  .on("text", (text) => {
    console.log(text);
  });

const message = await stream.finalMessage();
console.log(message);

Streaming mit client.messages.stream(...) stellt dir verschiedene Helfer zur Verfügung, darunter Event-Handler und Akkumulation.

Alternativ kannst du client.messages.create({ ..., stream: true }) verwenden, das nur ein asynchrones Iterable der Events im Stream zurückgibt und daher weniger Speicher verbraucht (es baut kein finales Nachrichtenobjekt für dich auf).

Tool-Helfer

Dieses SDK bietet Helfer, die das Erstellen und Ausführen von Tools in der Messages API vereinfachen. Du kannst Zod-Schemas oder JSON-Schemas verwenden, um die Eingabe für ein Tool zu beschreiben. Anschließend kannst du diese Tools mit der Methode client.beta.messages.toolRunner() ausführen. Diese Methode übernimmt die Weitergabe der vom gewählten Modell generierten Eingaben an das richtige Tool und gibt das Ergebnis an das Modell zurück.

Weitere Details zur „tool use" (Tool-Nutzung) findest du unter Tool-Nutzung mit Claude. Um das Browser-Use-Tool oder das Computer-Use-Tool mit diesem SDK auszuführen, siehe Browser- und Computer-Use mit den SDK-Toolsets.

import { betaZodTool } from "@anthropic-ai/sdk/helpers/beta/zod";
import { z } from "zod";

const anthropic = new Anthropic();

const weatherTool = betaZodTool({
  name: "get_weather",
  inputSchema: z.object({
    location: z.string()
  }),
  description: "Get the current weather in a given location",
  run: (input) => {
    return `The weather in ${input.location} is foggy and 60°F`;
  }
});

const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1000,
  messages: [{ role: "user", content: "What is the weather in San Francisco?" }],
  tools: [weatherTool]
});

console.log(finalMessage.content);

Tool-Fehler

Um einen Fehler aus einem Tool an das Modell zurückzumelden, wirf einen ToolError aus der run-Funktion. Anders als ein einfacher Error akzeptiert ToolError Content-Blöcke, sodass du Bilder oder andere strukturierte Inhalte in die Fehlerantwort aufnehmen kannst:

import { ToolError } from "@anthropic-ai/sdk/lib/tools/BetaRunnableTool";

const screenshotTool = betaZodTool({
  name: "take_screenshot",
  inputSchema: z.object({ url: z.string() }),
  run: async (input) => {
    if (!isValidUrl(input.url)) {
      throw new ToolError(`Invalid URL: ${input.url}`);
    }
    const result = await takeScreenshot(input.url);
    if (result.error) {
      // Füge den Fehler-Screenshot hinzu, damit das Modell sieht, was schiefgelaufen ist
      throw new ToolError([
        { type: "text", text: `Failed to load page: ${result.error}` },
        {
          type: "image",
          source: { type: "base64", data: result.screenshot, media_type: "image/png" }
        }
      ]);
    }
    return {
      type: "image",
      source: { type: "base64", data: result.screenshot, media_type: "image/png" }
    };
  }
});

Wenn ein einfacher Error geworfen wird, wird die Nachricht in einen Text-Content-Block umgewandelt.

Tool-Nutzung

Dieses SDK bietet Unterstützung für Tool-Nutzung, auch bekannt als „function calling" (Funktionsaufrufe). Weitere Details findest du unter Tool-Nutzung mit Claude.

MCP-Helfer

Dieses SDK bietet Helfer für die Integration mit Servern des „Model Context Protocol", oder MCP. Diese Helfer konvertieren MCP-Typen in Claude-API-Typen und reduzieren so Boilerplate-Code bei der Arbeit mit MCP-Tools, -Prompts und -Ressourcen.

import {
  mcpTools,
  mcpMessages,
  mcpResourceToContent,
  mcpResourceToFile
} from "@anthropic-ai/sdk/helpers/beta/mcp";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const anthropic = new Anthropic();

// Mit einem MCP-Server verbinden
const transport = new StdioClientTransport({ command: "mcp-server", args: [] });
const mcpClient = new Client({ name: "my-client", version: "1.0.0" });
await mcpClient.connect(transport);

// MCP-Prompts verwenden
const { messages } = await mcpClient.getPrompt({ name: "my-prompt" });
const response = await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: mcpMessages(messages)
});
console.log(response.content);

// MCP-Tools mit toolRunner verwenden
const { tools } = await mcpClient.listTools();
const finalMessage = await anthropic.beta.messages.toolRunner({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Use the available tools" }],
  tools: mcpTools(tools, mcpClient)
});
console.log(finalMessage.content);

// MCP-Ressourcen als Inhalt verwenden
const resource = await mcpClient.readResource({ uri: "file:///path/to/doc.txt" });
await anthropic.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: [
        mcpResourceToContent(resource),
        { type: "text", text: "Summarize this document" }
      ]
    }
  ]
});

// MCP-Ressourcen als Dateien hochladen
const fileResource = await mcpClient.readResource({ uri: "file:///path/to/data.json" });
await anthropic.files.upload({ file: mcpResourceToFile(fileResource) });

MCP-Fehlerbehandlung

Die Konvertierungsfunktionen werfen UnsupportedMCPValueError, wenn ein MCP-Wert von der Claude API nicht unterstützt wird (zum Beispiel ein nicht unterstützter Content-Typ, ein nicht unterstützter MIME-Typ oder ein Ressourcenlink, der nicht HTTP/HTTPS ist).

Message Batches

Dieses SDK bietet Unterstützung für Batch-Verarbeitung im Namespace client.messages.batches.

Einen Batch erstellen

Message Batches nimmt ein Array von Anfragen entgegen, wobei jedes Objekt einen custom_id-Bezeichner und genau dieselben Anfrage-params wie die Standard-Messages-API hat:

const batch = await client.messages.batches.create({
  requests: [
    {
      custom_id: "my-first-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hello, world" }]
      }
    },
    {
      custom_id: "my-second-request",
      params: {
        model: "claude-opus-5-5",
        max_tokens: 1024,
        messages: [{ role: "user", content: "Hi again, friend" }]
      }
    }
  ]
});

Ergebnisse aus einem Batch abrufen

Sobald ein Message Batch verarbeitet wurde, erkennbar an .processing_status === 'ended', kannst du mit .batches.results() auf die Ergebnisse zugreifen

const results = await client.messages.batches.results(batch.id);
for await (const entry of results) {
  if (entry.result.type === "succeeded") {
    console.log(entry.result.message.content);
  }
}

Datei-Uploads

Anfrageparameter, die Datei-Uploads entsprechen, können in vielen verschiedenen Formen übergeben werden:

• File (oder ein Objekt mit derselben Struktur)
• eine fetch-Response (oder ein Objekt mit derselben Struktur)
• ein fs.ReadStream
• der Rückgabewert des toFile-Helfers

Setze den Content-Type explizit, da die Files API ihn nicht für dich ableitet:

import fs from "node:fs";
import Anthropic, { toFile } from "@anthropic-ai/sdk";

const client = new Anthropic();

// Wenn du Zugriff auf Node `fs` hast, verwende `fs.createReadStream()`:
await client.files.upload({
  file: await toFile(fs.createReadStream("/path/to/file"), undefined, {
    type: "application/json"
  })
});

// Oder wenn du die Web-`File`-API hast, kannst du eine `File`-Instanz übergeben:
await client.files.upload({
  file: new File(["my bytes"], "file.txt", { type: "text/plain" })
});
// Du kannst auch eine `fetch`-`Response` übergeben:
await client.files.upload({
  file: await fetch("https://somesite/file")
});

// Oder einen `Buffer` / `Uint8Array`
await client.files.upload({
  file: await toFile(Buffer.from("my bytes"), "file", { type: "text/plain" })
});
await client.files.upload({
  file: await toFile(new Uint8Array([0, 1, 2]), "file", { type: "text/plain" })
});

Fehlerbehandlung

Wenn die Bibliothek keine Verbindung zur API herstellen kann oder die API einen Statuscode zurückgibt, der keinen Erfolg anzeigt (also eine 4xx- oder 5xx-Antwort), wird eine Unterklasse von APIError geworfen:

const message = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .catch(async (err) => {
    if (err instanceof Anthropic.APIError) {
      console.log(err.status); // 400
      console.log(err.name); // BadRequestError
      console.log(err.headers); // {server: 'nginx', ...}
    } else {
      throw err;
    }
  });

Die Fehlercodes lauten wie folgt:

Request-IDs

Weitere Informationen zum Debuggen von Anfragen findest du unter Request-ID.

Alle Objektantworten im SDK stellen eine _request_id-Eigenschaft bereit, die aus dem request-id-Antwort-Header übernommen wird, sodass du fehlgeschlagene Anfragen schnell protokollieren und an Anthropic melden kannst.

const message = await client.messages.create({
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  model: "claude-opus-5-5"
});
console.log(message._request_id); // req_018EeWyXxfu5pfWkrYcMdjWG

Wiederholungsversuche

Bestimmte Fehler werden standardmäßig automatisch 2-mal wiederholt, mit einem kurzen exponentiellen Backoff. Verbindungsfehler (zum Beispiel aufgrund eines Netzwerkverbindungsproblems), 408 Request Timeout, 409 Conflict, 429 Rate Limit und >=500 Internal Errors werden standardmäßig alle wiederholt.

Du kannst die Option maxRetries verwenden, um dies zu konfigurieren oder zu deaktivieren:

// Konfiguriere den Standard für alle Anfragen:
const client = new Anthropic({
  maxRetries: 0 // default is 2
});

// Oder konfiguriere es pro Anfrage:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { maxRetries: 5 }
);

Timeouts

Standardmäßig laufen Anfragen nach 10 Minuten in ein Timeout. Wenn du jedoch einen großen max_tokens-Wert angegeben hast und kein Streaming verwendest, wird das Standard-Timeout dynamisch mit folgender Formel berechnet:

const minimum = 10 * 60;
const calculated = (60 * 60 * maxTokens) / 128_000;
return calculated < minimum ? minimum * 1000 : calculated * 1000;

was zu einem Timeout von bis zu 60 Minuten führt, skaliert anhand des max_tokens-Parameters, sofern es nicht auf Anfrage- oder Client-Ebene überschrieben wird.

Du kannst dies mit einer timeout-Option konfigurieren:

// Konfiguriere den Standardwert für alle Anfragen:
const client = new Anthropic({
  timeout: 20 * 1000 // 20 seconds (default is 10 minutes)
});

// Pro Anfrage überschreiben:
await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { timeout: 5 * 1000 }
);

Bei einem Timeout wird ein APIConnectionTimeoutError geworfen.

Beachte, dass Anfragen, die in ein Timeout laufen, standardmäßig zweimal wiederholt werden.

Lange Anfragen

Vermeide es, einen großen max_tokens-Wert zu setzen, ohne Streaming zu verwenden. Einige Netzwerke trennen inaktive Verbindungen nach einer bestimmten Zeit, was dazu führen kann, dass die Anfrage fehlschlägt oder in ein Timeout läuft, ohne eine Antwort von Anthropic zu erhalten.

Dieses SDK wirft außerdem einen Fehler, wenn erwartet wird, dass eine Nicht-Streaming-Anfrage länger als etwa 10 Minuten dauert. Die Übergabe von stream: true oder das Überschreiben der timeout-Option auf Client- oder Anfrageebene deaktiviert diesen Fehler.

Eine erwartete Anfragelatenz, die länger als das Timeout für eine Nicht-Streaming-Anfrage ist, führt dazu, dass der Client die Verbindung beendet und es erneut versucht, ohne eine Antwort zu erhalten.

Sofern von der fetch-Implementierung unterstützt, setzt das SDK eine TCP-Socket-Keep-Alive-Option, um die Auswirkungen von Timeouts inaktiver Verbindungen in einigen Netzwerken zu verringern. Dies kann durch die Konfiguration eines benutzerdefinierten Proxys überschrieben werden.

Automatische Paginierung

Listenmethoden in der Claude API sind paginiert. Du kannst die Syntax for await ... of verwenden, um über die Elemente aller Seiten zu iterieren:

async function fetchAllMessageBatches() {
  const allMessageBatches = [];
  // Ruft bei Bedarf automatisch weitere Seiten ab.
  for await (const messageBatch of client.messages.batches.list({ limit: 20 })) {
    allMessageBatches.push(messageBatch);
  }
  return allMessageBatches;
}

Alternativ kannst du jeweils eine einzelne Seite anfordern:

let page = await client.messages.batches.list({ limit: 20 });
for (const messageBatch of page.data) {
  console.log(messageBatch);
}

// Für manuelles Paginieren stehen Hilfsmethoden zur Verfügung:
while (page.hasNextPage()) {
  page = await page.getNextPage();
  // ...
}

Standard-Header

Das SDK sendet automatisch den anthropic-version-Header, gesetzt auf die API-Version für diese Hauptversion des SDK (siehe Semantische Versionierung).

Bei Bedarf kannst du ihn überschreiben, indem du Standard-Header pro Anfrage setzt.

Beachte, dass dies zu falschen Typen und anderem unerwartetem oder undefiniertem Verhalten im SDK führen kann.

const client = new Anthropic();

const message = await client.messages.create(
  {
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  },
  { headers: { "anthropic-version": "My-Custom-Value" } }
);

Erweiterte Verwendung

Zugriff auf rohe Response-Daten (zum Beispiel Header)

Auf die „rohe" Response, die von fetch() zurückgegeben wird, kann über die Methode .asResponse() des Typs APIPromise zugegriffen werden, den alle Methoden zurückgeben. Diese Methode kehrt zurück, sobald die Header einer erfolgreichen Antwort empfangen wurden, und verbraucht den Antwort-Body nicht, sodass du frei eigene Parsing- oder Streaming-Logik schreiben kannst.

Du kannst auch die Methode .withResponse() verwenden, um die rohe Response zusammen mit den geparsten Daten zu erhalten. Anders als .asResponse() verbraucht diese Methode den Body und kehrt zurück, sobald er geparst ist.

const client = new Anthropic();

const response = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .asResponse();
console.log(response.headers.get("X-My-Header"));
console.log(response.statusText); // access the underlying Response object

const { data: message, response: raw } = await client.messages
  .create({
    max_tokens: 1024,
    messages: [{ role: "user", content: "Hello, Claude" }],
    model: "claude-opus-5-5"
  })
  .withResponse();
console.log(raw.headers.get("X-My-Header"));
console.log(message.content);

Logging

Log-Level

Du kannst das Log-Level auf zwei Arten konfigurieren:

1. Über die Umgebungsvariable ANTHROPIC_LOG
2. Mit der Client-Option logLevel (überschreibt die Umgebungsvariable, falls gesetzt)

const client = new Anthropic({
  logLevel: "debug" // Show all log messages
});

Verfügbare Log-Level, von am ausführlichsten bis am wenigsten ausführlich:

• 'debug' - Zeigt Debug-Meldungen, Infos, Warnungen und Fehler
• 'info' - Zeigt Info-Meldungen, Warnungen und Fehler
• 'warn' - Zeigt Warnungen und Fehler (Standard)
• 'error' - Zeigt nur Fehler
• 'off' - Deaktiviert das gesamte Logging

Auf dem Level 'debug' werden alle HTTP-Anfragen und -Antworten protokolliert, einschließlich Header und Bodies. Einige authentifizierungsbezogene Header werden geschwärzt, aber sensible Daten in Anfrage- und Antwort-Bodies können weiterhin sichtbar sein.

Benutzerdefinierter Logger

Standardmäßig protokolliert diese Bibliothek nach globalThis.console. Du kannst auch einen benutzerdefinierten Logger bereitstellen. Die meisten Logging-Bibliotheken werden unterstützt, darunter pino, winston, bunyan, consola, signale und @std/log. Wenn dein Logger nicht funktioniert, eröffne ein Issue.

Wenn du einen benutzerdefinierten Logger bereitstellst, steuert die Option logLevel weiterhin, welche Meldungen ausgegeben werden; Meldungen unterhalb des konfigurierten Levels werden nicht an deinen Logger gesendet.

import pino from "pino";

const logger = pino();

const client = new Anthropic({
  logger: logger.child({ name: "Anthropic" }),
  logLevel: "debug" // Send all messages to pino, allowing it to filter
});

OpenTelemetry-Tracing

Wenn deine Anwendung einen OpenTelemetry Tracer Provider registriert, gibt das SDK für jede Anfrage, die es sendet, einen Span aus. Um die Spans an deine Observability-Plattform zu senden, siehe OpenTelemetry mit dem Claude SDK einrichten.

Benutzerdefinierte/undokumentierte Anfragen stellen

Diese Bibliothek ist für den bequemen Zugriff auf die dokumentierte API typisiert. Wenn du auf undokumentierte Endpunkte, Parameter oder Antworteigenschaften zugreifen musst, kann die Bibliothek trotzdem verwendet werden.

Undokumentierte Endpunkte

Um Anfragen an undokumentierte Endpunkte zu stellen, kannst du client.get, client.post und andere HTTP-Verben verwenden. Optionen des Clients, wie etwa Wiederholungsversuche, werden bei diesen Anfragen berücksichtigt.

await client.post("/some/path", {
  body: { some_prop: "foo" },
  query: { some_query_arg: "bar" }
});

Undokumentierte Anfrageparameter

Um Anfragen mit undokumentierten Parametern zu stellen, kannst du // @ts-expect-error beim undokumentierten Parameter verwenden. Diese Bibliothek validiert zur Laufzeit nicht, ob die Anfrage dem Typ entspricht, sodass alle zusätzlichen Werte, die du sendest, unverändert gesendet werden.

client.messages.create({
  // ...
  // @ts-expect-error baz is not yet public
  baz: "undocumented option"
});

Bei Anfragen mit dem Verb GET landen alle zusätzlichen Parameter in der Query; alle anderen Anfragen senden den zusätzlichen Parameter im Body.

Wenn du explizit ein zusätzliches Argument senden möchtest, kannst du dies mit den Anfrageoptionen query, body und headers tun.

Undokumentierte Antworteigenschaften

Um auf undokumentierte Antworteigenschaften zuzugreifen, kannst du mit // @ts-expect-error auf das Antwortobjekt zugreifen oder das Antwortobjekt in den erforderlichen Typ casten. Wie bei den Anfrageparametern validiert das SDK zusätzliche Eigenschaften in der Antwort der API nicht und entfernt sie auch nicht.

Den fetch-Client anpassen

Standardmäßig erwartet diese Bibliothek, dass eine globale fetch-Funktion definiert ist.

Wenn du eine andere fetch-Funktion verwenden möchtest, kannst du entweder das Global per Polyfill ersetzen:

import fetch from "my-fetch";

globalThis.fetch = fetch;

Oder sie an den Client übergeben:

import fetch from "my-fetch";

const client = new Anthropic({ fetch });

Fetch-Optionen

Wenn du benutzerdefinierte fetch-Optionen setzen möchtest, ohne die fetch-Funktion zu überschreiben, kannst du beim Erstellen des Clients oder beim Stellen einer Anfrage ein fetchOptions-Objekt angeben. (Anfragespezifische Optionen überschreiben Client-Optionen.)

const client = new Anthropic({
  fetchOptions: {
    // `RequestInit`-Optionen
  }
});

Proxys konfigurieren

Um das Proxy-Verhalten zu ändern, kannst du benutzerdefinierte fetchOptions angeben, die laufzeitspezifische Proxy-Optionen zu Anfragen hinzufügen:

import * as undici from "undici";

const proxyAgent = new undici.ProxyAgent("http://localhost:8888");
const client = new Anthropic({
  fetchOptions: {
    dispatcher: proxyAgent
  }
});

const client = new Anthropic({
  fetchOptions: {
    proxy: "http://localhost:8888"
  }
});

import Anthropic from "npm:@anthropic-ai/sdk";

const httpClient = Deno.createHttpClient({ proxy: { url: "http://localhost:8888" } });
const client = new Anthropic({
  fetchOptions: {
    client: httpClient
  }
});

Beta-Funktionen

Beta-Funktionen sind vor der allgemeinen Veröffentlichung verfügbar, um frühzeitig Feedback zu erhalten und neue Funktionalität zu testen. Die Verfügbarkeit aller Fähigkeiten und Tools von Claude kannst du in der Funktionsübersicht prüfen.

Auf die meisten Beta-API-Funktionen kannst du über die Eigenschaft beta des Clients zugreifen. Um eine bestimmte Beta-Funktion zu aktivieren, musst du beim Erstellen einer Nachricht den entsprechenden Beta-Header zum Feld betas hinzufügen.

Zum Beispiel, um Context Editing zu aktivieren:

const client = new Anthropic();
const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Hello, Claude" }],
  betas: ["context-management-2025-06-27"]
});

Laufzeitunterstützung

Plattformintegrationen

Das TypeScript SDK unterstützt die folgenden Plattformen:

• Agent Platform: npm install @anthropic-ai/vertex-sdk: Stellt den AnthropicVertex-Client bereit
• Bedrock: npm install @anthropic-ai/bedrock-sdk: Stellt den AnthropicBedrockMantle-Client bereit sowie AnthropicBedrock für den bedrock-runtime-Pfad
• Claude Platform on AWS: npm install @anthropic-ai/aws-sdk: Stellt den AnthropicAws-Client bereit. Übergib workspaceId an den Konstruktor oder setze die Umgebungsvariable ANTHROPIC_AWS_WORKSPACE_ID. In der Beta verfügbar.
• Foundry: npm install @anthropic-ai/foundry-sdk: Stellt den AnthropicFoundry-Client bereit

Verwende AnthropicBedrockMantle für neue Projekte; AnthropicBedrock bleibt für bestehende Anwendungen erhalten, die die Bedrock-InvokeModel-API verwenden.

Das TypeScript SDK unterstützt über den AnthropicGoogleCloud-Client auch Claude Models on Google Cloud (Anthropic managed). Dieser Client befindet sich in der Beta-Phase. Um ihn zu installieren, führe npm install @anthropic-ai/google-cloud-sdk aus. Übergib workspaceId an den Konstruktor oder setze die Umgebungsvariable ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID. Unter Auflösung von Projekt, Standort und Workspace erfährst du, wie der Client die Workspace-ID auflöst.

Semantische Versionierung

Jede Hauptversion dieses SDK sendet standardmäßig eine API-Version im anthropic-version-Header, und mit jeder neuen API-Version kommt eine neue Hauptversion. Die erste Hauptversion, die 2026-10-21 sendet, ist 1.0.0; siehe Migration zur API-Version 2026-10-21.

Dieses Paket folgt im Allgemeinen den SemVer-Konventionen, wobei bestimmte abwärtsinkompatible Änderungen als Minor-Versionen veröffentlicht werden können:

1. Änderungen, die nur statische Typen betreffen, ohne das Laufzeitverhalten zu beeinträchtigen.
2. Änderungen an Bibliotheksinterna, die technisch öffentlich sind, aber nicht für die externe Verwendung vorgesehen oder dokumentiert sind.
3. Änderungen, von denen nicht erwartet wird, dass sie sich in der Praxis auf die überwiegende Mehrheit der Benutzer auswirken.

Abwärtskompatibilität wird ernst genommen, damit du dich auf ein reibungsloses Upgrade-Erlebnis verlassen kannst.

Häufig gestellte Fragen

Im GitHub-Repository findest du FAQs, Issues und Community-Support.

Zusätzliche Ressourcen

• GitHub-Repository
• API-Referenz
• Streaming von Nachrichten
• Tool-Nutzung mit Claude