API & SDK 2. Mai 2026 13 min Lesezeit

Claude API SDK Integration: Node.js, Python & TypeScript 2026

Das Anthropic SDK hat mehr zu bieten als einen einfachen messages.create Call. Streaming, Tool Use, Vision, Batch-API, Prompt Caching, Structured Outputs — dieser Guide zeigt alle SDK-Features mit echten Code-Beispielen.

SDK-Features im Überblick

⚡

Streaming

Token-für-Token Ausgabe, SSE-kompatibel

🔧

Tool Use

Function Calling, Agent Loops

👁️

Vision

Bilder, PDFs, Screenshots analysieren

📦

Batch API

50% günstiger, async bis 24h

💾

Prompt Caching

90% günstiger für wiederholte Prompts

📋

Structured Output

JSON Schema für zuverlässige Outputs

Setup: Node.js und Python

Node.jsInstallation und Basis-Setup

npm install @anthropic-ai/sdk

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

const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
  // Optional: eigener Base-URL für Proxies
  baseURL: process.env.ANTHROPIC_BASE_URL,
  // Timeout + Retry konfigurieren
  timeout: 60000,
  maxRetries: 3
});

# Python:
pip install anthropic

import anthropic

client = anthropic.Anthropic(
  api_key=os.environ["ANTHROPIC_API_KEY"]
)

Streaming: Live-Ausgabe

StreamingToken-für-Token mit dem SDK

# Node.js Streaming mit SDK-Helper
const stream = await client.messages.stream({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Erkläre Quantencomputing' }]
});

// Methode 1: Event-basiert
stream.on('text', (text) => process.stdout.write(text));
stream.on('finalMessage', (msg) => {
  console.log(`\nTokens verwendet: ${msg.usage.input_tokens + msg.usage.output_tokens}`);
});

// Methode 2: AsyncIterator (cleaner)
for await (const event of stream) {
  if (event.type === 'content_block_delta' &&
      event.delta.type === 'text_delta') {
    process.stdout.write(event.delta.text);
  }
}

# Python Streaming:
with client.messages.stream(
    model="claude-sonnet-4-6",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Erkläre Quantencomputing"}]
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

Prompt Caching: 90% Kosten sparen

CacheSystemat. Caching für wiederholte Prompts

# Prompt Caching für statische Kontexte (Docs, System-Prompts)
# Cache-Prefix: bis zu 4 cache_control-Breakpoints pro Request

const LONG_DOCUMENT = fs.readFileSync('knowledge-base.txt', 'utf-8');

const response = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  system: [
    {
      type: 'text',
      text: 'Du bist ein Experte für unsere Dokumentation.'
    },
    {
      type: 'text',
      text: LONG_DOCUMENT,  // 50.000 Token Dokument
      cache_control: { type: 'ephemeral' }  // ← Cache-Breakpoint
    }
  ],
  messages: [{ role: 'user', content: userQuestion }]
});

# Erster Call: input_tokens = 50.000 (normal berechnet)
# Folge-Calls: cache_read_input_tokens = 50.000 (90% günstiger!)
# Cache-TTL: 5 Minuten (wird bei Nutzung verlängert)

Wann Prompt Caching nutzen? Ideal für: große System-Prompts (>1000 Tokens), Dokumenten-QA, Chatbots mit langer History, Code-Review über große Codebases. Rechnung: 50k Tokens × 1000 Anfragen/Tag × 90% Rabatt = erhebliche Einsparung.

Batch API: 50% günstiger für Bulk-Tasks

# Batch API: bis zu 10.000 Requests gleichzeitig — 50% Rabatt
# Ideal für: Dokumente klassifizieren, Emails analysieren, Bulk-Content

const batch = await client.messages.batches.create({
  requests: documents.map((doc, i) => ({
    custom_id: `doc-${i}`,
    params: {
      model: 'claude-haiku-4-5',
      max_tokens: 256,
      messages: [{
        role: 'user',
        content: `Klassifiziere als JSON: ${doc.text.substring(0, 1000)}`
      }]
    }
  }))
});

// Batch läuft async — polling bis fertig (max 24h)
let batchResult;
do {
  batchResult = await client.messages.batches.retrieve(batch.id);
  await sleep(30000); // alle 30s prüfen
} while (batchResult.processing_status !== 'ended');

// Ergebnisse abrufen
for await (const result of await client.messages.batches.results(batch.id)) {
  if (result.result.type === 'succeeded') {
    console.log(result.custom_id, result.result.message.content[0].text);
  }
}

Vision: Bilder und PDFs verarbeiten

VisionScreenshots und Dokumente analysieren

# Screenshot analysieren:
const imageData = fs.readFileSync('screenshot.png');
const base64Image = imageData.toString('base64');

const response = await client.messages.create({
  model: 'claude-sonnet-4-6',
  max_tokens: 1024,
  messages: [{
    role: 'user',
    content: [
      {
        type: 'image',
        source: {
          type: 'base64',
          media_type: 'image/png',
          data: base64Image
        }
      },
      { type: 'text', text: 'Beschreibe alle UI-Bugs die du in diesem Screenshot siehst' }
    ]
  }]
});

# URL-basiert (öffentliche Bilder):
# source: { type: 'url', url: 'https://example.com/image.png' }

Rate Limits beachten: Haiku: 1000 RPM / Sonnet: 500 RPM / Opus: 100 RPM. Bei Batch-Verarbeitung: p-limit oder bottleneck-Library nutzen um unter den Limits zu bleiben. Claude Code generiert dir einen Rate-Limiter auf Knopfdruck.

SDK Deep-Dive im Kurs

Im Claude Code Mastery Kurs: vollständiger SDK-Workshop mit Node.js und Python. Streaming, Tool Use, Vision, Prompt Caching, Batch API — mit echten Projekten die alle Features kombinieren.

14 Tage kostenlos testen →