KI & Anthropic API

Anthropic Claude API mit TypeScript: KI-Anwendungen entwickeln 2026

6. Mai 2026 11 min Lesezeit Von Agentic Movers Team

Die Anthropic Claude API ist 2026 die leistungsstärkste Plattform für den Aufbau produktionsreifer KI-Anwendungen. In diesem Guide lernst du alles — vom SDK-Setup über Tool Use, Vision und Streaming bis hin zu Prompt Caching und der Batch API — mit vollständigen TypeScript-Beispielen, die du sofort verwenden kannst.

1. Anthropic SDK Setup & Messages API

SDK

Der einfachste Einstieg in die Claude API beginnt mit dem offiziellen Anthropic TypeScript SDK. Es abstrahiert HTTP-Details, übernimmt Retry-Logik und bietet vollständige TypeScript-Typen für alle API-Objekte. Claude Code — das offizielle Anthropic-CLI — setzt selbst auf dieses SDK, weshalb du mit exakt denselben Patterns arbeitest wie Anthropics eigene Tooling-Teams.

Installation

# NPM
npm install @anthropic-ai/sdk

# oder Yarn
yarn add @anthropic-ai/sdk

# TypeScript-Typen sind im Paket enthalten — kein @types nötig

Das SDK unterstützt Node.js ab Version 18 sowie moderne Deno- und Bun-Runtimes. Stelle sicher, dass du tsconfig.json mit "moduleResolution": "bundler" oder "node16" konfigurierst, damit die ESM-Exports korrekt aufgelöst werden.

API Key konfigurieren

// .env (niemals in Git committen!)
ANTHROPIC_API_KEY=sk-ant-api03-...

import Anthropic from '@anthropic-ai/sdk';

// SDK liest ANTHROPIC_API_KEY automatisch aus process.env
const client = new Anthropic();

// Oder explizit:
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

Sicherheit: Nutze dotenv in der Entwicklung und Umgebungsvariablen im Deployment (Railway, Fly.io, Vercel). Der API Key darf niemals im Frontend-Code landen — alle Claude-API-Calls gehören auf den Server.

Erste Nachricht: Messages API

Die Messages API ist das Herzstück von Claude. Sie nimmt eine Liste von Nachrichten entgegen und gibt eine strukturierte Antwort zurück — inklusive Nutzungsstatistiken, Stopground und dem gewählten Modell.

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function basicMessage() {
  const message = await client.messages.create({
    model: 'claude-opus-4-5',          // Aktuell stärkstes Modell
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: 'Erkläre den Unterschied zwischen Promises und async/await in TypeScript.',
      },
    ],
  });

  // content ist immer ein Array — je nach stop_reason können mehrere Blöcke enthalten sein
  const textBlock = message.content.find(b => b.type === 'text');
  console.log(textBlock?.text);

  // Nutzungsstatistiken für Kostenkontrolle
  console.log(`Tokens: ${message.usage.input_tokens} in / ${message.usage.output_tokens} out`);
}

basicMessage();

Modellauswahl 2026

Modell	Stärke	Ideal für	Kosten (Input/1M)
claude-opus-4-5	Höchste Intelligenz	Komplexe Reasoning-Tasks	$15
claude-sonnet-4-5	Ausgewogen	Produktions-Apps, Chatbots	$3
claude-haiku-3-5	Schnell & günstig	Klassifizierung, Extraktion	$0.25

System-Prompt & Multi-Turn

const conversation = await client.messages.create({
  model: 'claude-sonnet-4-5',
  max_tokens: 2048,
  system: 'Du bist ein erfahrener TypeScript-Entwickler. Antworte präzise und mit Codebeispielen.',
  messages: [
    { role: 'user', content: 'Was ist ein Generic in TypeScript?' },
    { role: 'assistant', content: 'Generics ermöglichen typsichere, wiederverwendbare Komponenten...' },
    { role: 'user', content: 'Zeig mir ein praktisches Beispiel mit einer Repository-Klasse.' },
  ],
});

Multi-Turn-Konversationen werden durch einfaches Anhängen von Nachrichten an das Array realisiert. Du kannst den gesamten Konversationsverlauf auf dem Client halten und bei jedem API-Call mitschicken — Claude selbst ist zustandslos.

2. Tool Use / Function Calling

Tool Use

Tool Use (auch bekannt als Function Calling) ist das mächtigste Feature der Claude API. Damit kann Claude strukturierte Aufrufe an externe Funktionen, APIs oder Datenbanken machen — und du weißt immer genau, welche Parameter es übergeben will. Das Ergebnis liefert du zurück, Claude integriert es in seine Antwort. So entstehen echte Agenten-Pipelines.

Tools-Array definieren

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: 'get_weather',
    description: 'Gibt die aktuelle Wetterinformation für einen Ort zurück.',
    input_schema: {
      type: 'object',
      properties: {
        location: {
          type: 'string',
          description: 'Stadt und Land, z.B. "Berlin, Deutschland"',
        },
        unit: {
          type: 'string',
          enum: ['celsius', 'fahrenheit'],
          description: 'Temperatureinheit',
        },
      },
      required: ['location'],
    },
  },
  {
    name: 'search_database',
    description: 'Durchsucht die Produktdatenbank nach einem Suchbegriff.',
    input_schema: {
      type: 'object',
      properties: {
        query: { type: 'string', description: 'Suchbegriff' },
        limit: { type: 'number', description: 'Maximale Anzahl Ergebnisse (default: 10)' },
        category: {
          type: 'string',
          enum: ['software', 'hardware', 'services'],
        },
      },
      required: ['query'],
    },
  },
];

Ersten Tool-Call ausführen

async function runToolUse() {
  const response = await client.messages.create({
    model: 'claude-sonnet-4-5',
    max_tokens: 1024,
    tools,
    messages: [
      { role: 'user', content: 'Wie ist das Wetter gerade in München?' },
    ],
  });

  // stop_reason === 'tool_use' wenn Claude ein Tool aufrufen möchte
  if (response.stop_reason === 'tool_use') {
    const toolUseBlock = response.content.find(b => b.type === 'tool_use');

    if (toolUseBlock && toolUseBlock.type === 'tool_use') {
      console.log(`Claude ruft Tool auf: ${toolUseBlock.name}`);
      console.log('Parameter:', toolUseBlock.input);

      // Tool ausführen (hier: simuliert)
      const weatherResult = await fetchWeather(
        (toolUseBlock.input as { location: string }).location
      );

      // Ergebnis zurück an Claude schicken
      const finalResponse = await client.messages.create({
        model: 'claude-sonnet-4-5',
        max_tokens: 1024,
        tools,
        messages: [
          { role: 'user', content: 'Wie ist das Wetter gerade in München?' },
          { role: 'assistant', content: response.content },
          {
            role: 'user',
            content: [
              {
                type: 'tool_result',
                tool_use_id: toolUseBlock.id,
                content: JSON.stringify(weatherResult),
              },
            ],
          },
        ],
      });

      const finalText = finalResponse.content.find(b => b.type === 'text');
      console.log('Antwort:', finalText?.text);
    }
  }
}

// Simulierte Wetter-API
async function fetchWeather(location: string) {
  // In der Produktion: echte API hier einfügen
  return { temperature: 18, unit: 'celsius', condition: 'Bewölkt', location };
}

Multi-Step Tool Calling (Agentic Loop)

Für komplexe Aufgaben ruft Claude mehrere Tools hintereinander auf. Der klassische Agentic Loop wiederholt die Tool-Ausführung, bis stop_reason === 'end_turn' erscheint:

async function agentLoop(userMessage: string) {
  const messages: Anthropic.MessageParam[] = [
    { role: 'user', content: userMessage },
  ];

  while (true) {
    const response = await client.messages.create({
      model: 'claude-opus-4-5',
      max_tokens: 4096,
      tools,
      messages,
    });

    // Assistenten-Turn hinzufügen
    messages.push({ role: 'assistant', content: response.content });

    if (response.stop_reason === 'end_turn') {
      // Fertig — finale Textantwort extrahieren
      return response.content.find(b => b.type === 'text')?.text;
    }

    if (response.stop_reason === 'tool_use') {
      const toolResults: Anthropic.ToolResultBlockParam[] = [];

      for (const block of response.content) {
        if (block.type === 'tool_use') {
          const result = await executeTool(block.name, block.input);
          toolResults.push({
            type: 'tool_result',
            tool_use_id: block.id,
            content: JSON.stringify(result),
          });
        }
      }

      messages.push({ role: 'user', content: toolResults });
    }
  }
}

async function executeTool(name: string, input: unknown) {
  switch (name) {
    case 'get_weather': return fetchWeather((input as any).location);
    case 'search_database': return searchDB((input as any).query);
    default: throw new Error(`Unbekanntes Tool: ${name}`);
  }
}

Tool Choice steuern: Mit tool_choice: { type: "auto" } entscheidet Claude selbst. { type: "any" } erzwingt einen Tool-Call. { type: "tool", name: "get_weather" } erzwingt ein bestimmtes Tool. Für End-Turn ohne Tools: { type: "none" }.

3. Vision & Multimodal

Vision

Claude versteht Bilder nativ. Du kannst Screenshots, Diagramme, Dokumente, Fotos und UI-Mockups direkt an die API schicken — entweder als URL oder als Base64-kodierte Daten. Die Vision-Funktion lässt sich nahtlos mit Tool Use kombinieren, sodass Claude ein Bild analysieren und gleichzeitig externe Funktionen aufrufen kann.

Bild via URL analysieren

const response = await client.messages.create({
  model: 'claude-opus-4-5',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'image',
          source: {
            type: 'url',
            url: 'https://example.com/screenshot.png',
          },
        },
        {
          type: 'text',
          text: 'Analysiere diesen Screenshot und beschreibe die Hauptelemente der UI.',
        },
      ],
    },
  ],
});

Bild als Base64 einbetten

import fs from 'fs';
import path from 'path';

async function analyzeLocalImage(imagePath: string) {
  const imageBuffer = fs.readFileSync(imagePath);
  const base64Image = imageBuffer.toString('base64');

  // MIME-Typ aus Extension bestimmen
  const ext = path.extname(imagePath).toLowerCase();
  const mediaTypeMap: Record<string, string> = {
    '.jpg': 'image/jpeg',
    '.jpeg': 'image/jpeg',
    '.png': 'image/png',
    '.gif': 'image/gif',
    '.webp': 'image/webp',
  };
  const mediaType = mediaTypeMap[ext] ?? 'image/jpeg';

  const response = await client.messages.create({
    model: 'claude-sonnet-4-5',
    max_tokens: 2048,
    messages: [
      {
        role: 'user',
        content: [
          {
            type: 'image',
            source: {
              type: 'base64',
              media_type: mediaType as 'image/jpeg' | 'image/png' | 'image/gif' | 'image/webp',
              data: base64Image,
            },
          },
          {
            type: 'text',
            text: 'Extrahiere alle sichtbaren Texte und Zahlen aus diesem Dokument im JSON-Format.',
          },
        ],
      },
    ],
  });

  return response.content.find(b => b.type === 'text')?.text;
}

Dokumentenanalyse: Mehrere Bilder kombinieren

async function analyzeMultiplePages(imageUrls: string[]) {
  const imageContent = imageUrls.map((url, idx) => ([
    {
      type: 'text' as const,
      text: `Seite ${idx + 1}:`,
    },
    {
      type: 'image' as const,
      source: { type: 'url' as const, url },
    },
  ])).flat();

  const response = await client.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 4096,
    messages: [
      {
        role: 'user',
        content: [
          ...imageContent,
          {
            type: 'text',
            text: 'Erstelle eine strukturierte Zusammenfassung aller Seiten. Identifiziere Kernaussagen, Zahlen und Handlungsempfehlungen.',
          },
        ],
      },
    ],
  });

  return response.content.find(b => b.type === 'text')?.text;
}

Vision + Tool Use kombiniert

// Claude analysiert Bild UND ruft Tools auf — echte multimodale Agenten
const response = await client.messages.create({
  model: 'claude-opus-4-5',
  max_tokens: 2048,
  tools: [
    {
      name: 'save_extracted_data',
      description: 'Speichert extrahierte Daten in der Datenbank.',
      input_schema: {
        type: 'object',
        properties: {
          invoice_number: { type: 'string' },
          amount: { type: 'number' },
          date: { type: 'string' },
          vendor: { type: 'string' },
        },
        required: ['invoice_number', 'amount'],
      },
    },
  ],
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'image',
          source: {
            type: 'url',
            url: 'https://example.com/invoice.pdf',
          },
        },
        {
          type: 'text',
          text: 'Extrahiere die Rechnungsdaten und speichere sie in der Datenbank.',
        },
      ],
    },
  ],
});

Bildgrößen-Limits: Maximale Bildgröße ist 5 MB (Base64). Claude skaliert Bilder intern auf max. 1568 px auf der längsten Seite. Für Dokument-OCR empfiehlt sich mindestens 300 DPI. Claude versteht PDFs nicht direkt — rendere Seiten zuerst als Bilder (z.B. mit pdf2pic).

4. Streaming Responses

Streaming

Streaming liefert Claude-Antworten Token für Token — ohne auf die vollständige Antwort zu warten. Das verbessert die wahrgenommene Performance drastisch, besonders bei langen Ausgaben. Das Anthropic SDK bietet zwei Streaming-APIs: die low-level stream()-Methode und die High-level-Wrapper mit Event-Callbacks.

Basis-Streaming mit for await...of

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function streamResponse() {
  const stream = client.messages.stream({
    model: 'claude-sonnet-4-5',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: 'Schreibe ein detailliertes TypeScript-Tutorial über Generics mit 5 praktischen Beispielen.',
      },
    ],
  });

  // Tokens direkt ausgeben wenn sie ankommen
  for await (const event of stream) {
    if (
      event.type === 'content_block_delta' &&
      event.delta.type === 'text_delta'
    ) {
      process.stdout.write(event.delta.text); // Kein Newline — fortlaufend ausgeben
    }
  }

  // Finale vollständige Message nach Abschluss
  const finalMessage = await stream.finalMessage();
  console.log(`\n\nTokens: ${finalMessage.usage.input_tokens} in / ${finalMessage.usage.output_tokens} out`);
}

Event-basiertes Streaming

async function streamWithEvents() {
  const stream = client.messages.stream({
    model: 'claude-sonnet-4-5',
    max_tokens: 2048,
    messages: [{ role: 'user', content: 'Erkläre async/await in 500 Wörtern.' }],
  });

  stream
    .on('text', (text) => {
      // Wird bei jedem neuen Text-Delta aufgerufen
      process.stdout.write(text);
    })
    .on('message', (message) => {
      // Vollständige Message nach Abschluss
      console.log(`\n[Fertig] stop_reason: ${message.stop_reason}`);
    })
    .on('error', (error) => {
      console.error('Stream-Fehler:', error);
    });

  await stream.finalMessage();
}

Streaming in Next.js / Express API Routes

// pages/api/chat.ts (Next.js)
import { NextRequest } from 'next/server';
import Anthropic from '@anthropic-ai/sdk';

export const runtime = 'edge';

export async function POST(req: NextRequest) {
  const { message } = await req.json();
  const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

  const encoder = new TextEncoder();
  const readable = new ReadableStream({
    async start(controller) {
      const stream = client.messages.stream({
        model: 'claude-sonnet-4-5',
        max_tokens: 1024,
        messages: [{ role: 'user', content: message }],
      });

      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(readable, {
    headers: {
      'Content-Type': 'text/plain; charset=utf-8',
      'Transfer-Encoding': 'chunked',
    },
  });
}

Streaming-Event-Typen

Event-Typ	Wann	Wichtige Felder
`message_start`	Beginn der Message	`message.usage.input_tokens`
`content_block_start`	Neuer Inhaltsblock	`index`, `content_block.type`
`content_block_delta`	Neues Text-Delta	`delta.text` oder `delta.partial_json`
`content_block_stop`	Block abgeschlossen	`index`
`message_delta`	Metadaten-Update	`delta.stop_reason`, `usage.output_tokens`
`message_stop`	Stream-Ende	—

Streaming + Tool Use: Bei Tool-Calls liefert das Delta partial_json statt Text. Du kannst die JSON-Fragmente sammeln und nach content_block_stop parsen — oder stream.finalMessage() abwarten, das dir das vollständige Tool-Call-Objekt gibt.

5. Prompt Caching

Cache

Prompt Caching ist eines der wirkungsvollsten Cost-Reduction-Features der Claude API. Häufig wiederholte Inhalte — System-Prompts, Dokumenten-Kontexte, Few-Shot-Beispiele — werden serverseitig gecacht. Cache-Hits kosten bis zu 90% weniger als normale Tokens. Die TTL beträgt 5 Minuten (Haiku) bzw. werden bei jedem Hit verlängert.

Cache Control: Ephemeral

const response = await client.messages.create({
  model: 'claude-sonnet-4-5',
  max_tokens: 1024,
  // System-Prompt cachen — wird bei jedem Request gelesen, aber nur einmal berechnet
  system: [
    {
      type: 'text',
      text: largeSystemPrompt, // Z.B. 50.000 Tokens Kontext
      cache_control: { type: 'ephemeral' }, // <-- Cache-Markierung
    },
  ],
  messages: [
    { role: 'user', content: 'Was sind die wichtigsten Punkte aus Kapitel 3?' },
  ],
});

Caching-Strategie für große Dokumente

const largeDocument = fs.readFileSync('./knowledge-base.txt', 'utf-8');
const fewShotExamples = fs.readFileSync('./examples.txt', 'utf-8');

async function queryWithCache(question: string) {
  const response = await client.messages.create({
    model: 'claude-opus-4-5',
    max_tokens: 2048,
    system: [
      {
        type: 'text',
        text: 'Du bist ein KI-Assistent für technische Dokumentation. Antworte präzise und verweise auf spezifische Abschnitte.',
      },
      {
        type: 'text',
        // Großes Dokument cachen — bis zu 90% Kostenersparnis ab dem 2. Request
        text: `\n\n<knowledge_base>\n${largeDocument}\n</knowledge_base>`,
        cache_control: { type: 'ephemeral' },
      },
    ],
    messages: [
      {
        role: 'user',
        content: [
          {
            type: 'text',
            // Few-Shot-Beispiele ebenfalls cachen
            text: `<examples>\n${fewShotExamples}\n</examples>\n\nFrage: `,
            cache_control: { type: 'ephemeral' },
          },
          {
            type: 'text',
            text: question, // Nur die Frage ist nicht gecacht
          },
        ],
      },
    ],
  });

  // Cache-Statistiken in den Usage-Feldern
  console.log('Cache-Statistiken:', {
    cache_creation: response.usage.cache_creation_input_tokens,
    cache_read: response.usage.cache_read_input_tokens,
    uncached: response.usage.input_tokens,
  });

  return response.content.find(b => b.type === 'text')?.text;
}

Kostenvergleich mit Prompt Caching

Beispiel: RAG-Chatbot mit 50.000 Token System-Prompt (claude-opus-4-5)

Szenario	Preis / Request	100 Requests / Tag
Ohne Caching	$0.75 (50K × $15/M)	$75.00
1. Request (Cache Write)	$0.94 (1.25× Preis)	$0.94
Folge-Requests (Cache Hit)	$0.075 (90% günstiger)	$7.43
Ersparnis ab Tag 1	—	$66.63 (89%)

Cache-Breakpoints: Maximale Effizienz

// Bis zu 4 Cache-Breakpoints pro Request erlaubt
// Setze sie an Stellen die sich zwischen Requests NICHT ändern
const response = await client.messages.create({
  model: 'claude-sonnet-4-5',
  max_tokens: 1024,
  system: [
    {
      type: 'text',
      text: roleDefinition,      // Ändert sich nie → Cache
      cache_control: { type: 'ephemeral' },
    },
  ],
  messages: [
    {
      role: 'user',
      content: [
        {
          type: 'text',
          text: staticDocumentContext, // Ändert sich täglich → Cache
          cache_control: { type: 'ephemeral' },
        },
        {
          type: 'text',
          text: userQuestion, // Jeder Request anders → kein Cache
        },
      ],
    },
  ],
});

// Wichtig: Caching erfordert min. 1024 Tokens im Cache-Segment (Haiku: 2048)

Wann Caching sich lohnt: Mindestens 1.024 gecachte Tokens (bei Haiku: 2.048) und Wiederverwendung innerhalb von 5 Minuten. Ideal für: RAG-Systeme, Chatbots mit großen System-Prompts, Code-Review-Tools mit Codebasis-Kontext, mehrsprachige Assistenten mit Glossar-Kontext.

6. Batch API & Production

Batch

Die Message Batches API ist für asynchrone Massenverarbeitung optimiert: bis zu 10.000 Requests in einem Batch, 50% Kostenersparnis gegenüber synchronen Calls, und 24-Stunden-SLA. Perfekt für Nacht-Jobs, Datenverarbeitung, Content-Generierung in Massen und jede Aufgabe, bei der Echtzeit-Antworten nicht nötig sind.

Batch erstellen

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic();

async function createBatchJob(texts: string[]) {
  // Requests vorbereiten (jeder mit eindeutiger custom_id)
  const requests = texts.map((text, idx) => ({
    custom_id: `request-${idx}-${Date.now()}`,
    params: {
      model: 'claude-haiku-3-5', // Günstiges Modell für Batch-Verarbeitung
      max_tokens: 512,
      messages: [
        {
          role: 'user' as const,
          content: `Klassifiziere diesen Text als positiv, neutral oder negativ. Antworte nur mit einem Wort.\n\nText: "${text}"`,
        },
      ],
    },
  }));

  // Batch starten
  const batch = await client.beta.messages.batches.create({ requests });

  console.log(`Batch erstellt: ${batch.id}`);
  console.log(`Status: ${batch.processing_status}`);
  console.log(`Requests: ${batch.request_counts.processing} verarbeitet`);

  return batch.id;
}

Batch-Status pollen & Ergebnisse abrufen

async function waitForBatch(batchId: string) {
  console.log(`Warte auf Batch ${batchId}...`);

  while (true) {
    const batch = await client.beta.messages.batches.retrieve(batchId);

    const { processing, succeeded, errored, canceled, expired } = batch.request_counts;
    console.log(`Status: ${batch.processing_status} | ${succeeded} OK | ${errored} Fehler | ${processing} ausstehend`);

    if (batch.processing_status === 'ended') {
      console.log('Batch abgeschlossen!');
      return batch;
    }

    // 30 Sekunden warten, dann nochmal pollen
    await new Promise(resolve => setTimeout(resolve, 30000));
  }
}

async function processBatchResults(batchId: string) {
  const results: Record<string, string> = {};

  // Ergebnisse als Stream lesen (JSONL-Format)
  for await (const result of await client.beta.messages.batches.results(batchId)) {
    if (result.result.type === 'succeeded') {
      const textBlock = result.result.message.content.find(b => b.type === 'text');
      results[result.custom_id] = textBlock?.text ?? '';
    } else if (result.result.type === 'errored') {
      console.error(`Fehler bei ${result.custom_id}:`, result.result.error);
      results[result.custom_id] = 'ERROR';
    }
  }

  return results;
}

Vollständiger Batch-Workflow

async function batchSentimentAnalysis(texts: string[]) {
  // 1. Batch erstellen
  const batchId = await createBatchJob(texts);

  // 2. Auf Abschluss warten
  await waitForBatch(batchId);

  // 3. Ergebnisse verarbeiten
  const results = await processBatchResults(batchId);

  // 4. Statistiken ausgeben
  const total = Object.keys(results).length;
  const positive = Object.values(results).filter(r => r.toLowerCase().includes('positiv')).length;
  const negative = Object.values(results).filter(r => r.toLowerCase().includes('negativ')).length;

  console.log(`Ergebnis: ${positive}/${total} positiv, ${negative}/${total} negativ`);

  return results;
}

Production Best Practices

Rate Limits: Claude API hat Limits per Minute (RPM) und per Tag (TPM). Implementiere exponentielles Backoff mit retry: { maxRetries: 3 } im Client-Konstruktor.
Error Handling: Fange Anthropic.APIError und behandle 529 (Overloaded) mit Retry, 401 (Auth) als Fatal, 400 (Invalid Request) als Bug.
Token-Tracking: Logge usage.input_tokens und usage.output_tokens pro Request für Kostentransparenz und Alerting.
Timeouts: Setze timeout: 60000 für normale Requests, 300000 für Batch-Polls. Streaming-Requests benötigen höhere Timeouts.
Idempotency: Nutze custom_id in Batches für Deduplizierung und sichere Retry-Logik.

// Production-ready Client-Konfiguration
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  maxRetries: 3,
  timeout: 60000, // 60 Sekunden
  defaultHeaders: {
    'X-App-Name': 'MyApp/1.0', // Für Debugging in Logs
  },
});

// Robustes Error Handling
async function safeMessage(prompt: string) {
  try {
    return await client.messages.create({
      model: 'claude-sonnet-4-5',
      max_tokens: 1024,
      messages: [{ role: 'user', content: prompt }],
    });
  } catch (error) {
    if (error instanceof Anthropic.APIError) {
      if (error.status === 529) {
        console.warn('API überlastet, warte 10 Sekunden...');
        await new Promise(r => setTimeout(r, 10000));
        return safeMessage(prompt); // Retry
      }
      if (error.status === 401) {
        throw new Error('Ungültiger API Key — prüfe ANTHROPIC_API_KEY in .env');
      }
    }
    throw error;
  }
}

Rate Limits im Überblick (2026)

Modell	RPM	ITPM	OTPM
claude-opus-4-5	4.000	400.000	16.000
claude-sonnet-4-5	4.000	400.000	16.000
claude-haiku-3-5	4.000	400.000	16.000

RPM = Requests/Minute | ITPM = Input-Tokens/Minute | OTPM = Output-Tokens/Minute. Limits steigen automatisch mit Nutzung.

Batch API Kostenersparnis: 50% auf alle Modelle. 10.000 claude-haiku-3-5 Requests mit je 500 Input-Tokens kosten synchron $1.25 — per Batch nur $0.625. Für grosse Datenverarbeitungs-Pipelines spart das hunderte Dollar pro Monat.

Fazit: Claude API in TypeScript meistern

Die Anthropic Claude API bietet 2026 ein vollständiges Toolkit für produktionsreife KI-Anwendungen. Die wichtigsten Takeaways:

Messages API — Der Einstieg: einfach, typsicher, vollständig mit dem offiziellen SDK.
Tool Use — Der Schlüssel zu echten Agenten: Claude koordiniert externe Funktionen autonom.
Vision — Multimodale Inputs eröffnen Dokumentenanalyse, UI-Testing und visuelle RAG-Systeme.
Streaming — Essenziell für UX: Nutzer sehen sofort Antworten statt auf vollständige Responses zu warten.
Prompt Caching — Bis zu 90% Kostenersparnis bei großen System-Prompts — immer aktivieren.
Batch API — 50% günstiger für alles was nicht real-time braucht: Analyse, Content, Klassifizierung.

Claude Code — Anthropics eigenes CLI, das auf demselben SDK aufbaut — nutzt alle diese Features intern. Im Claude Code Mastery Kurs lernst du, wie du diese Konzepte in vollständige Produkte umsetzt: von der ersten API-Integration bis zur produktionsreifen Multi-Agent-Pipeline mit Monitoring, Cost-Tracking und automatischer Fehlerbehandlung.

Claude-API-Modul im Kurs

Im Claude Code Mastery Kurs: vollständiges Anthropic-API-Modul mit Tool Use, Vision, Prompt Caching, Batch API und Production-Best-Practices.

14 Tage kostenlos testen →