--- title: TypeScript SDK url: https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript description: Installiere und konfiguriere das Anthropic TypeScript SDK für Node.js-, Deno-, Bun- und Browser-Umgebungen --- Diese Bibliothek bietet bequemen Zugriff auf die Claude API aus TypeScript oder JavaScript. Eine Dokumentation der API-Funktionen mit Codebeispielen findest du in der [API-Referenz](https://platform.claude.com/docs/de/api/overview). Diese Seite behandelt TypeScript-spezifische SDK-Funktionen und die Konfiguration. ## Installation ```bash 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](https://endoflife.date/nodejs)) 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](https://support.claude.com/en/articles/9767949-api-key-best-practices-keeping-your-keys-safe-and-secure)). 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](https://github.com/anthropics/anthropic-sdk-typescript) oder stimme für ein bestehendes ab. ## Verwendung ```typescript 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](https://platform.claude.com/docs/de/manage-claude/authentication). Wenn dein API-Key ein [persönlicher Key oder Service-Account-Key](https://platform.claude.com/docs/de/manage-claude/authentication#key-types) ist, der nicht auf einen Workspace beschränkt ist, setze die Workspace-ID im Request-Header `anthropic-workspace-id`; [Einen Workspace auswählen](https://platform.claude.com/docs/de/manage-claude/authentication#select-a-workspace) 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: ```typescript 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: ```typescript 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. ```typescript 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: ```typescript 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview). Um das Browser-Use-Tool oder das Computer-Use-Tool mit diesem SDK auszuführen, siehe [Browser- und Computer-Use mit den SDK-Toolsets](https://platform.claude.com/docs/de/agents-and-tools/tool-use/browser-use-sdk). ```typescript 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: ```typescript 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](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview). ## MCP-Helfer Dieses SDK bietet Helfer für die Integration mit Servern des „[Model Context Protocol](https://modelcontextprotocol.io/)", 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. Die Claude API unterstützt außerdem einen [`mcp_servers`-Parameter](https://platform.claude.com/docs/de/agents-and-tools/mcp-connector), mit dem sich Claude direkt mit entfernten MCP-Servern verbinden kann. Verwende `mcp_servers`, wenn du entfernte Server hast, die über eine URL erreichbar sind, und nur Tool-Unterstützung benötigst. Verwende die MCP-Helfer, wenn du lokale MCP-Server, Prompts, Ressourcen oder mehr Kontrolle über die MCP-Verbindung benötigst. ```typescript 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](https://platform.claude.com/docs/de/build-with-claude/batch-processing) 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: ```typescript 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 ```typescript 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: ```typescript 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: ```typescript 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: | Statuscode | Fehlertyp | | ---------- | -------------------------- | | 400 | `BadRequestError` | | 401 | `AuthenticationError` | | 403 | `PermissionDeniedError` | | 404 | `NotFoundError` | | 409 | `ConflictError` | | 422 | `UnprocessableEntityError` | | 429 | `RateLimitError` | | >=500 | `InternalServerError` | | N/A | `APIConnectionError` | ## Request-IDs > Weitere Informationen zum Debuggen von Anfragen findest du unter [Request-ID](https://platform.claude.com/docs/de/api/errors#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. ```typescript 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: ```typescript // 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: ```typescript 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: ```typescript // 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#retries). ## Lange Anfragen Erwäge, für länger laufende Anfragen die Streaming-[Messages API](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#streaming-responses) zu verwenden. 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#timeouts), 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#timeouts) der `timeout`-Option auf Client- oder Anfrageebene deaktiviert diesen Fehler. Eine erwartete Anfragelatenz, die länger als das [Timeout](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#timeouts) 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](https://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html)-Option, um die Auswirkungen von Timeouts inaktiver Verbindungen in einigen Netzwerken zu verringern. Dies kann durch die Konfiguration eines benutzerdefinierten Proxys [überschrieben](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#configuring-proxies) 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: ```typescript 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: ```typescript 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](https://platform.claude.com/docs/de/cli-sdks-libraries/sdks/typescript#semantic-versioning)). 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. ```typescript 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. ```typescript 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 Alle Log-Meldungen sind ausschließlich für das Debugging gedacht. Format und Inhalt der Log-Meldungen können sich zwischen Releases ändern. #### 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) ```typescript 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](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale) und [@std/log](https://jsr.io/@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. ```typescript 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](https://platform.claude.com/docs/de/manage-claude/opentelemetry/sdk). ### 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. ```typescript 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. ```typescript 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: ```typescript import fetch from "my-fetch"; globalThis.fetch = fetch; ``` Oder sie an den Client übergeben: ```typescript 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.) ```typescript 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: ```typescript import * as undici from "undici"; const proxyAgent = new undici.ProxyAgent("http://localhost:8888"); const client = new Anthropic({ fetchOptions: { dispatcher: proxyAgent } }); ``` ```typescript const client = new Anthropic({ fetchOptions: { proxy: "http://localhost:8888" } }); ``` ```typescript 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](https://platform.claude.com/docs/de/build-with-claude/overview) 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](https://platform.claude.com/docs/de/api/beta-headers) zum Feld `betas` hinzufügen. Zum Beispiel, um [Context Editing](https://platform.claude.com/docs/de/build-with-claude/context-editing) zu aktivieren: ```typescript 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 Das Aktivieren der Option `dangerouslyAllowBrowser` kann gefährlich sein, da dadurch deine geheimen API-Zugangsdaten im clientseitigen Code offengelegt werden. Webbrowser sind von Natur aus weniger sicher als Serverumgebungen. Jeder Benutzer mit Zugriff auf den Browser kann diese Zugangsdaten potenziell einsehen, extrahieren und missbrauchen. Dies könnte zu unbefugtem Zugriff mit deinen Zugangsdaten führen und potenziell sensible Daten oder Funktionen gefährden. **Wann ist dies möglicherweise nicht gefährlich?** In bestimmten Szenarien birgt das Aktivieren der Browser-Unterstützung möglicherweise keine erheblichen Risiken: * **Interne Tools:** Wenn die Anwendung ausschließlich in einer kontrollierten internen Umgebung verwendet wird, in der die Benutzer vertrauenswürdig sind, kann das Risiko der Offenlegung von Zugangsdaten gemindert werden. * **Entwicklungs- oder Debugging-Zwecke:** Das vorübergehende Aktivieren dieser Funktion kann akzeptabel sein, sofern die Zugangsdaten kurzlebig sind, nicht auch in Produktionsumgebungen verwendet werden oder häufig rotiert werden. ## Plattformintegrationen Detaillierte Anleitungen zur Plattformeinrichtung mit Codebeispielen findest du unter: * [Amazon Bedrock](https://platform.claude.com/docs/de/build-with-claude/claude-in-amazon-bedrock) * [Amazon Bedrock (Opus 4.6 und früher)](https://platform.claude.com/docs/de/build-with-claude/claude-on-amazon-bedrock-legacy) * [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) * [Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/google-managed) * [Microsoft Foundry](https://platform.claude.com/docs/de/build-with-claude/claude-in-microsoft-foundry) Siehe auch [Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed). 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](https://platform.claude.com/docs/de/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution) 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](https://platform.claude.com/docs/de/api/migration-2026-10-21#upgrade). Dieses Paket folgt im Allgemeinen den [SemVer](https://semver.org/spec/v2.0.0.html)-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](https://github.com/anthropics/anthropic-sdk-typescript) findest du FAQs, Issues und Community-Support. ## Zusätzliche Ressourcen * [GitHub-Repository](https://github.com/anthropics/anthropic-sdk-typescript) * [API-Referenz](https://platform.claude.com/docs/de/api/overview) * [Streaming von Nachrichten](https://platform.claude.com/docs/de/build-with-claude/streaming) * [Tool-Nutzung mit Claude](https://platform.claude.com/docs/de/agents-and-tools/tool-use/overview)