Forem: Emre Demir

Claude Code: 'Ungültige custom3p Enterprise Config' Fehler beheben

Emre Demir — Mon, 11 May 2026 03:36:29 +0000

Wenn Sie Claude Code auf DeepSeek V4, OpenRouter, LiteLLM oder ein anderes Drittanbieter-LLM-Gateway routen, kann der Start mit Invalid custom3p enterprise config abbrechen. Der Fehler bedeutet: Claude Code konnte Ihre benutzerdefinierte Drittanbieter-Konfiguration nicht validieren, bevor die erste Modellanfrage gesendet wurde.

Teste Apidog noch heute

Dieser Leitfaden zeigt, was custom3p bedeutet, welche sechs Ursachen am häufigsten sind und wie Sie jede davon praktisch beheben. Die Beispiele decken OpenRouter, LiteLLM und lokale vLLM-Setups ab.

TL;DR

Invalid custom3p enterprise config bedeutet, dass Claude Code Ihre Drittanbieter-Konfiguration nicht akzeptiert.

custom3p ist die interne Bezeichnung für einen benutzerdefinierten Drittanbieter-Endpunkt, der über ANTHROPIC_BASE_URL gesetzt wird.

Prüfen Sie zuerst diese Punkte:

ANTHROPIC_BASE_URL darf meist kein nachgestelltes /v1 enthalten.
Verwenden Sie die richtige Auth-Variable:
- ANTHROPIC_AUTH_TOKEN für Bearer-Token
- ANTHROPIC_API_KEY für x-api-key
Validieren Sie ~/.claude/settings.json.
Stellen Sie sicher, dass das Claude-Code-Onboarding abgeschlossen ist.
Prüfen Sie, ob Ihr Gateway benötigte Header weiterleitet.
Prüfen Sie verwaltete Unternehmensrichtlinien.

In vielen Fällen reicht bereits das Entfernen von /v1 aus der Base-URL.

Was „custom3p“ bedeutet

Claude Code kann Anfragen über verschiedene Modi routen:

Modus	Auslöser
Anthropic API	Keine Überschreibung gesetzt
Amazon Bedrock	`CLAUDE_CODE_USE_BEDROCK=1`
Google Vertex AI	`CLAUDE_CODE_USE_VERTEX=1`
Microsoft Foundry	`CLAUDE_CODE_USE_FOUNDRY=1`
Benutzerdefinierter Drittanbieter	`ANTHROPIC_BASE_URL` zeigt auf einen anderen Host

Die letzte Variante ist custom3p: ein benutzerdefinierter Third-Party-Provider.

Beispiele:

OpenRouter
LiteLLM
lokaler vLLM-Server
internes Unternehmens-Gateway
eigener Proxy vor einem Modellanbieter

Wenn Claude Code eine solche Base-URL erkennt, validiert es die Enterprise-/Gateway-Konfiguration vor dem ersten Request. Schlägt diese Validierung fehl, erscheint:

Invalid custom3p enterprise config

Das ist ein Konfigurationsfehler, keine automatische Policy-Blockade.

Warum der Fehler häufiger auftritt

Im April 2026 blockierte Anthropic den Zugriff auf Claude Pro- und Max-Abonnements für agentische Drittanbieter-Tools, die die Claude-Code-Client-ID fälschten.

Das ist nicht dasselbe Problem.

Viele Entwickler nutzen seitdem die offiziell unterstützte Drittanbieter-Konfiguration von Claude Code, um den Agenten-Loop über günstigere oder eigene Backends zu betreiben. Ein Beispiel ist DeepSeek V4 Pro über OpenRouter. Projekte wie DeepClaude verpacken solche Setups in eine CLI.

Der Haken: Die offizielle Drittanbieter-Konfiguration muss exakt stimmen. Ein falscher Header, ein falscher JSON-Eintrag oder ein falsch formatierter Endpoint reicht aus, um Invalid custom3p enterprise config auszulösen.

Grundursache 1: `ANTHROPIC_BASE_URL` enthält ein nachgestelltes `/v1`

Claude Code hängt selbst /v1/messages an Ihre ANTHROPIC_BASE_URL an.

Wenn Sie bereits /v1 setzen, entsteht:

/v1/v1/messages

Das führt häufig zu 404 oder zur fehlgeschlagenen Preflight-Validierung.

Falsch

export ANTHROPIC_BASE_URL="https://api.openrouter.ai/api/v1"

export ANTHROPIC_BASE_URL="https://litellm.yourcompany.com/v1"

Richtig

export ANTHROPIC_BASE_URL="https://api.openrouter.ai/api"

export ANTHROPIC_BASE_URL="https://litellm.yourcompany.com"

Endpoint testen

Prüfen Sie, welche URL Claude Code effektiv aufrufen würde:

curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
  "${ANTHROPIC_BASE_URL}/v1/messages" \
  -d '{"model":"claude-sonnet-4-6","max_tokens":1,"messages":[{"role":"user","content":"hi"}]}'

Interpretation:

200: Endpoint existiert und Anfrage wurde akzeptiert
400: Endpoint existiert, Body ist aber unvollständig oder ungültig
404: sehr wahrscheinlich falsche Base-URL, oft wegen doppeltem /v1

Grundursache 2: Falsche Authentifizierungsvariable

Claude Code unterstützt zwei Auth-Varianten:

Variable	Gesendeter Header	Typischer Einsatz
`ANTHROPIC_API_KEY`	`x-api-key`	Anthropic-kompatible Gateways mit API-Key-Header
`ANTHROPIC_AUTH_TOKEN`	`Authorization: Bearer`	OAuth-/Bearer-Gateways, LiteLLM, viele OpenRouter-Setups

Wenn Ihr Gateway Bearer-Token erwartet, aber Claude Code x-api-key sendet, schlägt die Validierung fehl.

OpenRouter

OpenRouter erwartet typischerweise einen Bearer-Token:

export ANTHROPIC_AUTH_TOKEN="sk-or-your-openrouter-key"
export ANTHROPIC_BASE_URL="https://openrouter.ai/api"

Nicht verwenden:

export ANTHROPIC_API_KEY="sk-or-your-openrouter-key"

Das würde einen x-api-key-Header senden, den OpenRouter in diesem Setup nicht erwartet.

LiteLLM

export ANTHROPIC_AUTH_TOKEN="sk-litellm-your-virtual-key"
export ANTHROPIC_BASE_URL="https://your-litellm-server:4000"

Lokaler vLLM-Server oder DeepSeek-Gateway mit API-Key

export ANTHROPIC_API_KEY="your-key-here"
export ANTHROPIC_BASE_URL="https://your-vllm-server"

Prüfen Sie immer die Auth-Dokumentation Ihres Gateways: Entscheidend ist, welchen Header der Server erwartet.

Grundursache 3: Fehlerhafte `settings.json`

Wenn Sie Claude Code über ~/.claude/settings.json konfigurieren, muss die Datei gültiges JSON enthalten.

Häufige Fehler sind:

nachgestellte Kommas
typografische Anführungszeichen
Kommentare in JSON
fehlende Klammern
falsch verschachtelte env-Einträge

Falsch: nachgestelltes Komma

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-your-key",
  }
}

Falsch: intelligente Anführungszeichen

{
  "env": {
    “ANTHROPIC_BASE_URL”: “https://openrouter.ai/api”
  }
}

Richtig

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-your-openrouter-key"
  }
}

JSON validieren

Mit Python:

python3 -c "import json, os; json.load(open(os.path.expanduser('~/.claude/settings.json')))" && echo "Gültiges JSON"

Oder mit jq:

jq . ~/.claude/settings.json

Wenn die Datei nicht parsebar ist, kann Claude Code die Enterprise-Konfiguration nicht lesen und meldet sie als ungültig.

Grundursache 4: Onboarding bei Neuinstallation nicht abgeschlossen

Claude Code prüft in ~/.claude.json, ob das Onboarding abgeschlossen wurde.

Relevant ist:

"hasCompletedOnboarding": true

Fehlt dieser Wert, kann Claude Code in den Onboarding-Flow wechseln und Ihre settings.json ignorieren.

Status prüfen

cat ~/.claude.json | python3 -m json.tool 2>/dev/null | grep hasCompletedOnboarding

Wenn der Eintrag fehlt oder false ist, setzen Sie ihn manuell.

Minimal funktionierende `~/.claude.json`

{
  "hasCompletedOnboarding": true,
  "primaryApiKey": "sk-placeholder"
}

primaryApiKey ist hier nur ein Platzhalter. Ihre eigentliche Gateway-Konfiguration kommt aus settings.json oder den Umgebungsvariablen.

Danach Claude Code neu starten.

Grundursache 5: Gateway leitet erforderliche Header nicht weiter

Claude Code sendet für die Validierung zusätzliche Header. Einige Proxies oder Gateways entfernen diese Header.

Wichtige Header:

anthropic-beta
anthropic-version
X-Claude-Code-Session-Id

Wenn Ihr Gateway diese Header nicht weiterleitet, kann die Preflight-Validierung fehlschlagen.

Nginx-Beispiel

location /v1/ {
  proxy_pass http://backend;
  proxy_set_header anthropic-beta $http_anthropic_beta;
  proxy_set_header anthropic-version $http_anthropic_version;
  proxy_set_header X-Claude-Code-Session-Id $http_x_claude_code_session_id;
}

LiteLLM unterstützt diese Weiterleitung seit v1.82.9+ standardmäßig.

Workaround: experimentelle Betas deaktivieren

Wenn Sie das Gateway nicht anpassen können:

export CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1

Damit überspringt Claude Code Funktionen, die den Beta-Header benötigen. Der Kern-Agenten-Loop funktioniert weiter, aber einige experimentelle Funktionen stehen nicht zur Verfügung.

Grundursache 6: Konflikt mit verwalteten Unternehmensrichtlinien

Wenn Sie einen Team- oder Enterprise-Plan verwenden, können Administratoren verwaltete Einstellungen ausrollen.

Diese Einstellungen haben Vorrang vor:

~/.claude/settings.json
lokalen Umgebungsvariablen
manuell gesetzten Modelloptionen

Prüfen Sie, ob verwaltete Einstellungen aktiv sind:

ls ~/.claude/managed-settings.json 2>/dev/null && echo "Verwaltete Einstellungen gefunden"

Oder innerhalb von Claude Code:

/status

Wenn verwaltete Einstellungen aktiv sind, muss Ihr Administrator prüfen, ob:

Ihre Gateway-Domain erlaubt ist
Ihre Modell-IDs in availableModels enthalten sind
benutzerdefinierte Base-URLs blockiert werden

Für selbstverwaltete Unternehmensbereitstellungen liegen die Einstellungen beispielsweise unter macOS hier:

/Library/Application Support/ClaudeCode/managed-settings.json

Funktionierende Beispielkonfigurationen

Claude Code + OpenRouter + DeepSeek V4 Pro

OpenRouter bietet eine Anthropic-kompatible API. Verwenden Sie für OpenRouter eine Base-URL ohne /v1.

~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-your-openrouter-key",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "deepseek/deepseek-v4-pro",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "deepseek/deepseek-v4-pro",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek/deepseek-v4-pro"
  }
}

Die Modellüberschreibungen sind wichtig, weil Claude Code sonst weiterhin Standardmodellnamen wie claude-sonnet-4-6 sendet. Dann kann OpenRouter zwar erreichbar sein, aber ein anderes Modell routen als beabsichtigt.

Hinweis: OpenRouter implementiert die Anthropic-Streaming-Spezifikation für Tool-Aufrufe nicht in allen Randfällen vollständig. Der Haupt-Agenten-Loop funktioniert, komplexe Multi-Tool-Ketten können jedoch Einschränkungen haben. Prüfen Sie den aktuellen Status in der OpenRouter Claude Code Integration.

Claude Code + LiteLLM

LiteLLM ist für Claude-Code-Gateways besonders praktisch, weil es Header-Weiterleitung und Modellrouting zentral übernimmt.

config.yaml für LiteLLM:

model_list:
  - model_name: claude-sonnet-4-6
    litellm_params:
      model: deepseek/deepseek-v4
      api_key: "sk-your-deepseek-key"
  - model_name: claude-opus-4-7
    litellm_params:
      model: deepseek/deepseek-v4-pro
      api_key: "sk-your-deepseek-key"

Claude-Code-Konfiguration:

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:4000",
    "ANTHROPIC_AUTH_TOKEN": "sk-litellm-your-key"
  }
}

Vorteil: Claude Code kann weiterhin claude-sonnet-4-6 senden. LiteLLM mappt diesen Modellnamen intern auf DeepSeek oder ein anderes Backend.

Claude Code + lokales vLLM

Für lokale Modellinferenz mit vLLM starten Sie den Server:

python -m vllm.entrypoints.openai.api_server \
  --model deepseek-ai/DeepSeek-V3 \
  --dtype auto \
  --api-key local-key \
  --port 8000

Danach Claude Code konfigurieren:

export ANTHROPIC_BASE_URL="http://localhost:8000"
export ANTHROPIC_API_KEY="local-key"
export ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-ai/DeepSeek-V3"

Wichtig: Hier wird ANTHROPIC_API_KEY verwendet, weil der lokale Server in diesem Beispiel API-Key-Authentifizierung nutzt.

Debugging-Workflow

Wenn die Konfiguration weiterhin fehlschlägt, starten Sie Claude Code mit Debug-Logging:

claude --debug 2>&1 | head -100

Suchen Sie in der Ausgabe nach:

Sending request to: – zeigt die tatsächlich verwendete URL
Response status: – zeigt den HTTP-Status des Gateways
enterprise config error: – zeigt Hinweise zur internen Validierung

Gateway direkt testen

Senden Sie eine Anfrage mit den Headern, die Claude Code typischerweise verwendet:

curl -v -X POST "${ANTHROPIC_BASE_URL}/v1/messages" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${ANTHROPIC_AUTH_TOKEN}" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: max-tokens-3-5-sonnet-2024-07-15" \
  -d '{
    "model": "claude-sonnet-4-6",
    "max_tokens": 10,
    "messages": [{"role": "user", "content": "hi"}]
  }'

Interpretation:

200: Gateway akzeptiert Request
401: Authentifizierung falsch
403: Zugriff blockiert
404: Base-URL oder Pfad falsch
422: Body oder Modellformat nicht akzeptiert

Wenn Curl funktioniert, Claude Code aber nicht, prüfen Sie die Debug-Ausgabe. Claude Code sendet zusätzlich Preflight-/Validierungsanfragen, die Ihr einfacher Curl-Test möglicherweise nicht abbildet.

APIs mit Apidog testen

Beim Debuggen von LLM-Gateways hilft Apidog, die exakten Requests und Responses unabhängig von Claude Code zu prüfen.

Erstellen Sie eine Collection für den /v1/messages-Endpoint Ihres Gateways und legen Sie diese Werte als Collection-Variablen an:

base_url
authorization_token
anthropic_version
anthropic_beta
model

Beispiel-Header:

Authorization: Bearer {{authorization_token}}
anthropic-version: {{anthropic_version}}
anthropic-beta: {{anthropic_beta}}
Content-Type: application/json

Beispiel-Body:

{
  "model": "{{model}}",
  "max_tokens": 100,
  "messages": [
    {
      "role": "user",
      "content": "hi"
    }
  ]
}

So können Sie OpenRouter, LiteLLM, vLLM oder ein internes Gateway testen, ohne Claude Code jedes Mal neu zu starten.

Das ist besonders hilfreich bei Header-Problemen: Sie sehen direkt, ob Ihr Gateway anthropic-beta, anthropic-version und Auth-Header akzeptiert oder entfernt.

Weitere nützliche Claude-Code-Konfigurationen

Beta-Header-Abhängigkeit deaktivieren

Wenn Ihr Gateway keine benutzerdefinierten Header weiterleiten kann:

export CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1

Damit deaktivieren Sie den Beta-Feature-Handshake. Der Agenten-Loop bleibt nutzbar, aber Funktionen, die an den Beta-Header gebunden sind, können fehlen.

Gateway-Modellerkennung aktivieren

Ab Claude Code v2.1.129 kann Claude Code Modelle vom Gateway abrufen:

export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1

Claude Code fragt dann beim Start /v1/models ab.

Einschränkung: Automatisch hinzugefügt werden nur Modell-IDs, die mit claude oder anthropic beginnen. Für Modelle wie DeepSeek setzen Sie weiterhin explizit:

export ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek/deepseek-v4-pro"

Benutzerdefiniertes Modell in `/model` anzeigen

export ANTHROPIC_CUSTOM_MODEL_OPTION="deepseek/deepseek-v4-pro"
export ANTHROPIC_CUSTOM_MODEL_OPTION_NAME="DeepSeek V4 Pro"
export ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION="Günstigeres Gateway-Modell"

Damit erscheint das Modell in der /model-Auswahl und kann während der Arbeit schneller ausgewählt werden.

FAQ

Ist die Verwendung eines Drittanbieters mit Claude Code gegen die Nutzungsbedingungen von Anthropic?

Nein. Anthropic unterstützt das ANTHROPIC_BASE_URL-Muster für Bedrock, Vertex AI, Foundry und benutzerdefinierte Gateways.

Blockiert wurden Tools, die die Claude-Code-Client-ID fälschten, um Anthropic-Abonnements anders zu nutzen. Ein eigenes Gateway oder ein Anbieter wie OpenRouter mit eigenem API-Key ist ein anderes Setup.

Funktioniert der Claude-Code-Agenten-Loop mit DeepSeek V4 Pro?

Der Kern-Loop funktioniert: Dateibearbeitung, Shell-Kommandos und mehrstufige Aufgaben.

Einschränkungen gibt es bei Drittanbietern typischerweise bei:

MCP-Server-Tools
Bild-/Vision-Eingaben
komplexen Tool-Call-Streaming-Randfällen

Wenn Ihr Workflow diese Funktionen benötigt, bleiben Anthropic API, Bedrock oder Vertex oft die zuverlässigere Wahl.

Warum sagt der Fehler „enterprise config“, obwohl ich keinen Enterprise-Plan habe?

Claude Code verwendet „enterprise config“ intern für Drittanbieter- und Gateway-Konfigurationen. Das ist keine Aussage über Ihren Tarif.

Auch einzelne Entwickler können benutzerdefinierte Drittanbieter über ANTHROPIC_BASE_URL konfigurieren.

Kann ich während einer Claude-Code-Sitzung zwischen Anthropic und Drittanbieter wechseln?

Nicht innerhalb derselben Sitzung. Claude Code liest die Base-URL beim Start.

Zum Wechseln:

Claude Code beenden
Umgebungsvariablen oder settings.json ändern
Neue Sitzung starten

Tools wie DeepClaude kapseln diesen Wechsel über CLI-Flags.

Mein Gateway liegt hinter einer Unternehmens-Firewall. Kann Claude Code einen Proxy nutzen?

Ja:

export HTTPS_PROXY="http://your-proxy:8080"
export ANTHROPIC_BASE_URL="https://your-internal-gateway"

Bei TLS-Inspection durch Unternehmens-Proxies setzen Sie zusätzlich:

export NODE_EXTRA_CA_CERTS="/path/to/corporate-ca-bundle.pem"

Curl funktioniert, Claude Code aber nicht. Warum?

Claude Code führt zusätzliche Preflight-Validierungen aus. Ihr Curl-Test trifft möglicherweise nur den normalen /v1/messages-Endpoint.

Starten Sie Claude Code mit Debug-Logging:

claude --debug

Vergleichen Sie dann:

finale URL
Header
Auth-Format
JSON-Body
HTTP-Status
Preflight-Request

Häufige Unterschiede sind anthropic-beta, X-Claude-Code-Session-Id und das exakte Validierungsformat.

Fazit

Invalid custom3p enterprise config ist fast immer ein behebarer Konfigurationsfehler.

Gehen Sie in dieser Reihenfolge vor:

Entfernen Sie ein nachgestelltes /v1 aus ANTHROPIC_BASE_URL.
Prüfen Sie ANTHROPIC_AUTH_TOKEN vs. ANTHROPIC_API_KEY.
Validieren Sie ~/.claude/settings.json.
Setzen Sie hasCompletedOnboarding: true bei Neuinstallationen.
Prüfen Sie Header-Weiterleitung im Gateway.
Prüfen Sie verwaltete Unternehmensrichtlinien.

Sobald die Validierung erfolgreich ist, kann Claude Code seinen Agenten-Loop über OpenRouter, LiteLLM, vLLM oder ein internes Gateway ausführen. Die wichtigsten Einschränkungen bleiben MCP-Tools, Vision-Eingaben und einzelne Tool-Streaming-Randfälle bei Drittanbieter-Backends.

Kostenlose Unbegrenzte Gemini API erhalten

Emre Demir — Sat, 09 May 2026 07:04:16 +0000

Googles Gemini-Familie ist eine kostengünstige Modellreihe für Workloads mit hohem Volumen. Trotzdem können sich die Kosten bei öffentlichen Apps, Nebenprojekten oder Hackathon-Prototypen schnell summieren, sobald viele Benutzer denselben Endpunkt verwenden. Puter.js dreht dieses Modell um: Sie integrieren Gemini und Gemma direkt im Browser, ohne Google API-Schlüssel, ohne Google Cloud-Projekt und ohne eigenes Backend. Die Nutzung wird dem Endnutzer über dessen Puter-Konto zugeordnet; für Sie als Entwickler bleibt die Integration kostenlos.

Probieren Sie Apidog noch heute aus

Kurz gesagt

Puter.js bietet Zugriff auf Gemini- und Gemma-Modelle ohne Google API-Schlüssel, Google Cloud-Projekt oder Server.
Unterstützte Gemini-Modelle: 2.5 Pro, 2.5 Flash, 2.5 Flash Lite, 2.0 Flash, 2.0 Flash Lite, 3 Flash Preview sowie ältere Previews.
Unterstützte Gemma-Modelle: Gemma 2, 3, 4 in verschiedenen Größen, z. B. 4B, 12B, 27B, 31B und 26B-A4B.
Die Basisintegration besteht aus einem <script>-Tag und einem Funktionsaufruf.
Streaming, Bildeingaben und Temperatursteuerung funktionieren direkt im Browser.
Die Nutzung läuft über das Puter-Konto des Endnutzers.
Mit Apidog können Sie Puter-Prototypen mit der offiziellen Gemini API vergleichen und Migrationen planen.

Wie „kostenlos und unbegrenzt“ funktioniert

Bei der klassischen Gemini-Integration besitzen Sie den Google AI Studio- oder Google Cloud-Schlüssel und tragen alle Token-Kosten selbst. Puter.js verschiebt diese Verantwortung auf den Benutzer: Der Endnutzer meldet sich bei Puter an, und die Nutzung wird seinem Puter-Konto zugeordnet.

Für Entwickler bedeutet das:

Kein Google Cloud-Projekt: Sie müssen kein Projekt anlegen, keine Abrechnung konfigurieren und keine API-Schlüssel verwalten.
Kein eigener Gemini-Proxy: Der Aufruf läuft direkt aus der Browser-App über Puter.
Kein eigenes Token-Budget: Ihre Kosten skalieren nicht mit der Anzahl der Nutzer.

Der wichtigste Kompromiss: Puter ist browserzentriert. Ein Backend-Cronjob, ein Worker oder ein Discord-Bot kann Puter nicht einfach ohne aktive Benutzersitzung verwenden.

Schritt 1: Puter.js installieren

Für eine statische HTML-Seite reicht ein CDN-Script:

<script src="https://js.puter.com/v2/"></script>

Für eine gebündelte App können Sie das Paket installieren:

npm install @heyputer/puter.js

Und anschließend importieren:

import { puter } from '@heyputer/puter.js';

Schritt 2: Passendes Gemini- oder Gemma-Modell auswählen

Wählen Sie das Modell nach Latenz, Qualität und Prompt-Komplexität aus.

Modell-ID	Wann verwenden
`google/gemini-2.5-pro`	Komplexe Analysen, schwierige Schlussfolgerungen, Aufgaben mit langem Kontext
`google/gemini-2.5-flash`	Standardmodell für Chat, Q&A, Content-Generierung und allgemeine Prompts
`google/gemini-2.5-flash-lite`	Hohe Volumen, Klassifizierung, Tagging, einfache strukturierte Aufgaben
`google/gemini-2.0-flash`	Stabile Basislinie mit gut bekanntem Verhalten
`google/gemini-3-flash-preview`	Aktuelle Preview für schnelle Tests neuer Gemini-Funktionen
`google/gemma-3-27b-it`	Offenes Gemma-Modell, instruktionsoptimiert, geeignet für Open-Weight-Vergleiche
`google/gemma-4-31b-it`	Größeres offenes Gemma-Modell für höhere Qualität innerhalb der Gemma-Familie

Praktische Standardeinstellung:

const DEFAULT_MODEL = 'google/gemini-2.5-flash';

Nutzen Sie gemini-2.5-pro nur für Prompts, bei denen Flash sichtbar nicht ausreicht. Verwenden Sie Lite-Varianten für einfache Aufgaben mit hohem Durchsatz.

Schritt 3: Ersten Gemini-Aufruf im Browser ausführen

Minimalbeispiel:

<!DOCTYPE html>
<html lang="de">
<body>
  <script src="https://js.puter.com/v2/"></script>

  <script>
    puter.ai.chat(
      'Erklären Sie maschinelles Lernen in drei Sätzen.',
      { model: 'google/gemini-2.5-flash' }
    ).then(response => {
      puter.print(response);
    });
  </script>
</body>
</html>

Ablauf:

Datei als index.html speichern.
Im Browser öffnen.
Puter startet bei Bedarf den Login-Flow.
Die Gemini-Antwort wird direkt auf der Seite ausgegeben.

Sie benötigen keine .env-Datei, keinen API-Key und keinen Server-Endpunkt.

Schritt 4: Antwort in einer Chat-UI streamen

Für Chat-Oberflächen sollten Sie Antworten streamen, damit Nutzer nicht auf die komplette Ausgabe warten müssen.

const outputDiv = document.querySelector('#output');

const response = await puter.ai.chat(
  'Erklären Sie Photosynthese im Detail.',
  {
    model: 'google/gemini-2.5-flash',
    stream: true,
  }
);

for await (const part of response) {
  if (part?.text) {
    outputDiv.innerHTML += part.text;
  }
}

Ein einfaches HTML-Gerüst dazu:

<div id="output"></div>

Jeder part.text enthält ein Stück der Antwort. Hängen Sie diese Teile direkt an Ihre UI an.

Schritt 5: Bilder an Gemini übergeben

Gemini unterstützt multimodale Prompts. Übergeben Sie eine Bild-URL als zweites Argument:

puter.ai.chat(
  'Was sehen Sie auf diesem Bild? Beschreiben Sie Farben, Objekte und Stimmung.',
  'https://assets.puter.site/doge.jpeg',
  { model: 'google/gemini-2.5-flash' }
).then(response => {
  puter.print(response);
});

Typische Anwendungsfälle:

Alt-Text-Generierung
visuelle Q&A
Screenshot-Analyse
OCR-nahe Aufgaben
Barrierefreiheitstools
Produktbild-Tagging

Gemini ist besonders stark bei natürlichen Bildern und Diagrammen. Bei Screenshots mit sehr dichtem Text kann je nach Aufgabe ein anderes Modell besser geeignet sein.

Schritt 6: Temperatur konfigurieren

Die Temperatur steuert, wie deterministisch oder kreativ die Ausgabe wird.

const response = await puter.ai.chat(
  'Schreiben Sie eine kreative Kurzgeschichte über einen Roboterkoch.',
  {
    model: 'google/gemini-2.5-flash',
    temperature: 0.2,
  }
);

console.log(response);

Faustregeln:

0.0 bis 0.3: faktenorientierte, strukturierte oder reproduzierbare Ausgaben
0.4 bis 0.7: allgemeine Chat- und Content-Aufgaben
0.8 bis 1.0: kreatives Schreiben, Brainstorming, Varianten

Für viele Chat-Anwendungsfälle ist 0.7 ein brauchbarer Startwert.

Schritt 7: Mehrstufige Gespräche verwalten

Für Konversationen übergeben Sie ein Nachrichtenarray:

const messages = [
  { role: 'user', content: 'Ich entwickle eine Next.js-App mit Postgres.' },
  { role: 'assistant', content: 'Verstanden. Wobei benötigen Sie Hilfe?' },
  { role: 'user', content: 'Wie sollte ich Migrationen strukturieren?' },
];

const response = await puter.ai.chat(messages, {
  model: 'google/gemini-2.5-pro',
});

console.log(response);

In einer echten App speichern Sie den Verlauf clientseitig:

const messages = [];

async function sendMessage(userInput) {
  messages.push({ role: 'user', content: userInput });

  const response = await puter.ai.chat(messages, {
    model: 'google/gemini-2.5-flash',
  });

  messages.push({ role: 'assistant', content: response });

  return response;
}

So bleibt Gemini über mehrere Runden hinweg im Kontext.

Gemini mit anderen Modellen vergleichen

Puter stellt mehrere LLMs über eine einheitliche Schnittstelle bereit. Dadurch können Sie denselben Prompt gegen verschiedene Modelle testen.

const models = [
  'google/gemini-2.5-flash',
  'claude-sonnet-4-6',
  'gpt-5.5',
  'x-ai/grok-4.3',
];

const prompt = 'Refaktorieren Sie diese React-Komponente, um Hooks zu verwenden: ...';

for (const model of models) {
  const start = performance.now();

  const response = await puter.ai.chat(prompt, { model });

  const elapsed = performance.now() - start;

  console.log(`${model}: ${elapsed.toFixed(0)}ms`);
  console.log(response);
  console.log('---');
}

Bewerten Sie pro Modell mindestens:

Antwortqualität
Latenz
Konsistenz bei wiederholten Prompts
Eignung für Ihren konkreten Use Case
Benutzerakzeptanz des Puter-Flows

Was Sie bekommen und was nicht

Das bekommen Sie

Gemini 2.5/2.0/3-Flash-Modelle plus 2.5 Pro
Gemma-Familie 2/3/4 für Open-Weight-Workflows
mehrstufige Gespräche
Streaming-Antworten
Bildeingaben über Bild-URL
Optionen wie Temperatur, max_tokens und System-Prompts
browserbasierte Integration ohne eigenes Backend

Das bekommen Sie möglicherweise nicht

Je nach aktueller Puter-Version können Einschränkungen bestehen bei:

nativen Funktionsaufrufen auf Gemini
Code-Ausführungstools
Google Search Grounding
vollem 2M-Token-Kontextfenster
serverseitiger Nutzung ohne Browserkontext
direkter Sichtbarkeit der Google-Ratenlimits

Für agentenbasierte Workflows mit Tool-Aufrufen, Code-Ausführung oder Search Grounding ist die offizielle Google AI Studio API oft besser geeignet. Für Chat, Q&A, Content-Generierung und einfache Vision-Aufgaben reicht Puter in vielen Browser-Apps aus.

Wann Sie Puter statt der offiziellen Gemini API verwenden sollten

Verwenden Sie Puter, wenn:

Sie eine kostenlose öffentliche App ohne eigenes Abrechnungsrisiko veröffentlichen möchten.
Sie schnell prototypisieren und kein Google Cloud-Projekt einrichten wollen.
Sie Gemini in einer statischen Website, Browser-Erweiterung oder Hackathon-App brauchen.
Ihre Nutzer einen Puter-Login akzeptieren.
Ihre App primär im Browser läuft.

Verwenden Sie die offizielle Gemini API, wenn:

Sie serverseitige Aufrufe benötigen, z. B. Cronjobs, Batch-Prozesse oder Webhooks.
Sie Code-Ausführung, Search Grounding oder den vollen langen Kontext benötigen.
Sie Compliance-Anforderungen direkt mit Google abdecken müssen.
Sie Fine-Tuning oder eigene Datenpipelines benötigen.
Ihre Nutzer keinen zusätzlichen Puter-Anmeldeschritt akzeptieren.

Eine detaillierte Anleitung für Gemini 3 Flash finden Sie hier: So verwenden Sie die Gemini 3 Flash Preview API.

Integration mit Apidog testen

Puter-Aufrufe laufen im Browser. Deshalb testen Sie diese nicht wie einen klassischen Backend-Endpunkt. Ein praktikables Setup sieht so aus:

Erstellen Sie eine kleine statische Testseite mit Puter.js.
Lesen Sie Prompt und Modell aus Query-Parametern.
Testen Sie die offizielle Gemini API separat in Apidog.
Halten Sie Puter-Prototyp und Gemini-API-Variante als getrennte Umgebungen in derselben Sammlung.

Beispiel für eine lokale Puter-Testseite:

const params = new URLSearchParams(window.location.search);

const prompt = params.get('prompt') ?? 'Erklären Sie Gemini in einem Satz.';
const model = params.get('model') ?? 'google/gemini-2.5-flash';

const response = await puter.ai.chat(prompt, { model });

document.querySelector('#output').textContent = response;

Richten Sie in Apidog zwei Umgebungen ein:

puter-prototype: lokale URL Ihrer Puter-Testseite
gemini-prod: https://generativelanguage.googleapis.com/v1

So können Sie später sauber von einem Browser-Prototyp auf eine direkte Gemini-API-Integration migrieren. Weitere Testmuster finden Sie unter API-Test-Tool für QA-Ingenieure.

Weitere kostenlose LLM-Pfade über Puter

Das Nutzer-zahlt-Modell funktioniert nicht nur für Gemini. Über Puter können Sie auch andere Modellfamilien über denselben Aufrufstil testen:

Der Wechsel besteht meist nur aus einem anderen model-String:

const response = await puter.ai.chat(prompt, {
  model: 'google/gemini-2.5-flash',
});

Häufig gestellte Fragen

Ist das wirklich unbegrenzt?

Aus Entwicklersicht ja: Sie verwalten kein eigenes Token-Budget. Die tatsächliche Nutzung hängt vom Guthaben des jeweiligen Puter-Kontos ab. Neue Konten erhalten ein Startguthaben; Nutzer können bei Bedarf Guthaben aufladen.

Benötige ich ein Google-Konto oder ein Google Cloud-Projekt?

Nein. Puter übernimmt den Zugriff auf Gemini. Sie verwalten keinen Google API-Schlüssel.

Kann ich das in Produktion verwenden?

Ja, für browserbasierte Apps. Entscheidend ist, ob Ihre Nutzer den Puter-Anmeldeschritt akzeptieren.

Funktioniert Gemini über Puter identisch mit der offiziellen API?

Puter ruft Gemini im Namen des Benutzers auf. Das Modellverhalten sollte daher vergleichbar sein. Durch den zusätzlichen Hop kann die Latenz geringfügig höher sein.

Was ist mit Geminis 2M-Token-Kontextfenster?

Puter stellt nicht zwingend für jede Modellvariante das volle 2M-Token-Limit bereit. Für extrem lange Kontexte ist die offizielle Google AI Studio API der passendere Weg.

Kann ich Gemini über Puter in einem Discord-Bot oder Backend-Dienst verwenden?

Nicht ohne Weiteres. Puter ist browserbasiert und setzt eine Benutzersitzung voraus. Für Backend-Dienste sollten Sie die offizielle Gemini API direkt verwenden.

Welches Modell sollte ich standardmäßig verwenden?

Starten Sie mit:

'google/gemini-2.5-flash'

Wechseln Sie zu google/gemini-2.5-pro für komplexe Denkaufgaben und zu google/gemini-2.5-flash-lite für einfache Aufgaben mit hohem Volumen.

Wird Bildgenerierung unterstützt?

Puter bietet Bildgenerierung über OpenAI-Modelle wie gpt-image-2 und DALL-E-Varianten an, nicht über Imagen. Weitere Informationen finden Sie unter Holen Sie sich eine kostenlose unbegrenzte GPT-5.5 API.

Zusammenfassung

Puter.js ist ein schneller Weg, Gemini in browserbasierte Apps einzubauen, ohne Google Cloud-Projekt, API-Key oder eigenes Backend. Für die meisten Prototypen starten Sie mit google/gemini-2.5-flash, aktivieren bei Bedarf Streaming und verwalten den Chatverlauf im Browser.

Für serverseitige Workloads, Fine-Tuning, Tool-Aufrufe, Code-Ausführung oder sehr lange Kontexte bleibt die offizielle Google Gemini API die bessere Wahl.

Erstellen Sie Ihre API-Variante in Apidog, vergleichen Sie Puter mit der offiziellen Gemini API und wählen Sie den Integrationspfad, der zu Ihrer App passt.

Kostenlose GPT-5.5 API & Alle OpenAI Modelle Unbegrenzt

Emre Demir — Sat, 09 May 2026 02:42:00 +0000

OpenAIs GPT-5.5 wird mit einer kostenpflichtigen API ausgeliefert: 5 US-Dollar pro Million Input-Tokens, 30 US-Dollar pro Million Output-Tokens. Für Nebenprojekte, Hackathons oder kostenlose öffentliche Apps kann diese Rechnung schon vor dem ersten Release zum Problem werden. Ein praktikabler Workaround ist Puter.js: Es stellt den OpenAI-Katalog im Browser bereit, ohne dass Sie einen OpenAI-Schlüssel verwalten. Die Kosten werden dem Endnutzer über dessen Puter-Konto zugeordnet; für Entwickler bleibt die Nutzung kostenlos und unbegrenzt.

Probiere Apidog noch heute aus

TL;DR

Puter.js gibt Entwicklern kostenlosen, unbegrenzten Zugriff auf OpenAI-Modelle ohne API-Key, OpenAI-Konto oder Backend.
Unterstützte Textmodelle umfassen gpt-5.5, gpt-5.5-pro, gpt-5.4, gpt-5, gpt-5-mini, o1, o3, gpt-4.1, gpt-4o sowie Chat- und Codex-Varianten.
Bildmodelle: gpt-image-2, gpt-image-1.5, dall-e-3.
TTS-Modelle: gpt-4o-mini-tts, tts-1, tts-1-hd.
Ein <script>-Tag und ein Aufruf von puter.ai.chat() reichen für den ersten GPT-5.5-Call.
Streaming, Function Calling, Vision, Bildgenerierung und Text-zu-Sprache laufen direkt im Browser.
Der Endnutzer deckt die Nutzung über ein Puter-Konto; Sie zahlen nichts.
Nutzen Sie Apidog, um Prompts gegen Puter und die offizielle OpenAI API zu vergleichen, bevor Sie migrieren.

Wie „kostenlos unbegrenzt“ funktioniert

Puter.js dreht das übliche LLM-Abrechnungsmodell um:

Nicht Ihre App besitzt den OpenAI-Key.
Der Nutzer meldet sich bei Puter an.
Der Modellaufruf wird über das Puter-Konto des Nutzers abgewickelt.
Ihr Projekt benötigt keinen eigenen OpenAI-Vertrag und keine eigene Abrechnung.

Daraus ergeben sich drei praktische Vorteile:

Kein API-Key im Frontend oder Repo. Kein Leckagerisiko, keine Rotation, keine Secret-Verwaltung.
Keine zentrale Kostenstelle für Ihr Projekt. Jeder Nutzer läuft über sein eigenes Puter-Konto.
Geringe Einstiegshürde für Prototypen. Statische Website, Browser-Erweiterung oder Hackathon-Demo reichen aus.

Der wichtigste Kompromiss: Puter.js ist browserzentriert. Ein Backend-Node-Skript kann Puter nicht sauber ohne angemeldete Benutzersitzung nutzen. Für Cronjobs, Webhooks, Batch-Jobs oder serverseitige Agenten bleibt die offizielle OpenAI API der richtige Weg.

Schritt 1: Puter.js installieren

Für eine statische HTML-Seite reicht ein CDN-Script:

<script src="https://js.puter.com/v2/"></script>

Minimalbeispiel:

<!DOCTYPE html>
<html lang="de">
<body>
  <script src="https://js.puter.com/v2/"></script>
</body>
</html>

Für eine gebündelte App installieren Sie das Paket:

npm install @heyputer/puter.js

import { puter } from '@heyputer/puter.js';

Verwenden Sie:

CDN, wenn Sie schnell prototypen, eine statische Seite bauen oder in DevTools testen.
NPM, wenn Sie mit Bundler, TypeScript oder Komponentenframework arbeiten.

Schritt 2: Modell auswählen

Puter bietet die GPT-5.x-Reihe sowie ältere OpenAI-Modelle. Wählen Sie das Modell nach Aufgabe, nicht nach Hype.

Modell-ID	Geeignet für
`gpt-5.5-pro`	Komplexe Analyse, Code-Agenten, tiefe Schlussfolgerungen
`gpt-5.5`	Standardmodell für Chat, Assistenzfunktionen und allgemeine Aufgaben
`gpt-5.4-nano`	Schnelle, günstige Textaufgaben und hochvolumige Klassifizierung
`gpt-5.4-mini`	Chat-UIs mit guter Balance aus Qualität und Geschwindigkeit
`gpt-5.3-codex`	Codespezifische Aufgaben
`o3`	Komplexe Argumentationsketten
`o1-pro`	Mehrstufige Planung und agentenbasierte Workflows
`gpt-4.1`, `gpt-4o`, `gpt-4o-mini`	Stabile, gut verstandene Basis für bestehende Integrationen

Für Bildgenerierung:

gpt-image-2: aktuelle Bildausgabe, scharf und schnell.
gpt-image-1.5, gpt-image-1, dall-e-3, dall-e-2: ältere, stabile Optionen.

Für Text-zu-Sprache:

gpt-4o-mini-tts: neuere, natürlich klingende TTS-Ausgabe.
tts-1, tts-1-hd: klassische TTS-Modelle mit niedriger Latenz.

Schritt 3: Ersten GPT-5.5-Call ausführen

Der kleinste lauffähige Chat-Aufruf sieht so aus:

<!DOCTYPE html>
<html lang="de">
<body>
  <script src="https://js.puter.com/v2/"></script>

  <script>
    puter.ai.chat(
      "Explain WebSockets in three sentences",
      { model: "gpt-5.5" }
    ).then(response => {
      puter.print(response);
    });
  </script>
</body>
</html>

Ablauf:

Datei als index.html speichern.
Im Browser öffnen.
Puter übernimmt die Authentifizierung des Nutzers.
Die Antwort wird direkt auf der Seite ausgegeben.

Sie brauchen dafür:

keinen OpenAI-Key,
keine .env,
keinen Server,
keine Proxy-Route.

Schritt 4: Antwort streamen

Für Chat-UIs sollten Sie Streaming als Standard verwenden. So sieht der Nutzer sofort Fortschritt, statt auf die vollständige Antwort zu warten.

const response = await puter.ai.chat(
  "Explain the theory of relativity in detail",
  {
    model: "gpt-5.5",
    stream: true
  }
);

for await (const part of response) {
  puter.print(part?.text);
}

In einer echten UI hängen Sie die Chunks an ein DOM-Element an:

const output = document.querySelector("#answer");

const stream = await puter.ai.chat(
  "Fasse HTTP Caching für Backend-Entwickler zusammen.",
  {
    model: "gpt-5.5",
    stream: true
  }
);

for await (const part of stream) {
  output.textContent += part?.text ?? "";
}

HTML dazu:

<div id="answer"></div>

Schritt 5: Vision mit Bildeingabe verwenden

Für Bildanalyse übergeben Sie zusätzlich eine Bild-URL:

puter.ai.chat(
  "What do you see in this image? Describe colors, objects, and mood.",
  "https://assets.puter.site/doge.jpeg",
  { model: "gpt-5.5" }
).then(response => {
  puter.print(response);
});

Typische Anwendungsfälle:

Alt-Text für Bilder generieren
Screenshots analysieren
visuelle QA bauen
OCR-ähnliche Workflows prototypen
Barrierefreiheitstools testen

Das funktioniert mit GPT-5.x-Modellen und GPT-4o-Varianten.

Schritt 6: Bilder generieren

Mit puter.ai.txt2img() erzeugen Sie ein Bild aus einem Prompt. Die Funktion gibt ein bereits geladenes <img>-Element zurück.

puter.ai.txt2img(
  "A futuristic cityscape at night, cinematic, neon, rain",
  { model: "gpt-image-2" }
).then(imageElement => {
  document.body.appendChild(imageElement);
});

Für eine kleine UI:

<input id="prompt" placeholder="Bildbeschreibung eingeben" />
<button id="generate">Generieren</button>
<div id="result"></div>

<script src="https://js.puter.com/v2/"></script>
<script>
  document.querySelector("#generate").addEventListener("click", async () => {
    const prompt = document.querySelector("#prompt").value;
    const result = document.querySelector("#result");

    result.textContent = "Generiere Bild...";

    const image = await puter.ai.txt2img(prompt, {
      model: "gpt-image-2"
    });

    result.textContent = "";
    result.appendChild(image);
  });
</script>

Die Bildgenerierungskosten werden dem Puter-Konto des Nutzers zugeordnet. Für kostenlose öffentliche Generatoren ist das ein sauberes Modell, weil Ihre App keine zentrale OpenAI-Rechnung erzeugt.

Schritt 7: Text-zu-Sprache einbauen

Die OpenAI-TTS-Linie wird über txt2speech bereitgestellt. Die Funktion gibt ein <audio>-Element mit der generierten Stimme zurück.

puter.ai.txt2speech(
  "Welcome back. Your account balance is $1,247.50.",
  {
    provider: "openai",
    model: "gpt-4o-mini-tts"
  }
).then(audio => {
  audio.setAttribute("controls", "");
  document.body.appendChild(audio);
});

Praktische Einsätze:

Sprachansagen in Web-Apps
Voiceover für Tutorials
Podcast-Intros
Barrierefreiheits-Narrationen
Vorlesefunktion für lange Texte

Schritt 8: Function Calling nutzen

Puter verwendet die bekannte OpenAI-Struktur für Tools. Sie definieren Funktionen, das Modell gibt tool_calls zurück, und Ihre App führt die Funktion aus.

const tools = [{
  type: "function",
  function: {
    name: "get_weather",
    description: "Get the current weather for a city.",
    parameters: {
      type: "object",
      properties: {
        city: {
          type: "string"
        }
      },
      required: ["city"]
    }
  }
}];

const response = await puter.ai.chat(
  "What's the weather in Tokyo right now?",
  {
    model: "gpt-5.5",
    tools
  }
);

const toolCalls = response.message.tool_calls;

if (toolCalls?.length) {
  console.log(
    toolCalls[0].function.name,
    toolCalls[0].function.arguments
  );
}

Ein vollständiges Muster besteht aus drei Schritten:

Tool definieren.
Modell aufrufen.
Tool-Aufruf ausführen und Ergebnis zurückgeben.

Beispiel für die lokale Ausführung:

function get_weather({ city }) {
  return {
    city,
    temperature: "22°C",
    condition: "Cloudy"
  };
}

if (toolCalls?.length) {
  const call = toolCalls[0];

  if (call.function.name === "get_weather") {
    const args = JSON.parse(call.function.arguments);
    const result = get_weather(args);

    console.log("Tool result:", result);
  }
}

Die Struktur ähnelt der offiziellen OpenAI API. Dadurch lassen sich bestehende Tool-Definitionen leichter portieren. Für Tests tool-gesteuerter Abläufe in produktionsnahen Umgebungen siehe MCP-Servertests in Apidog.

Schritt 9: Temperatur und `max_tokens` setzen

Sie übergeben Standardparameter im Optionsobjekt:

const response = await puter.ai.chat(
  "Tell me about Mars",
  {
    model: "gpt-5.5",
    temperature: 0.2,
    max_tokens: 200
  }
);

Faustregeln:

temperature: 0.0 bis 0.3: faktische, stabile Antworten
temperature: 0.7 bis 1.0: kreativer Output
max_tokens: begrenzt die Antwortlänge und damit die Kosten auf Nutzerseite

Für öffentliche Apps ist max_tokens besonders wichtig. Es verhindert, dass ein einzelner Prompt sehr lange Antworten erzeugt.

Was Sie erhalten und was nicht

Puter bietet kostenlosen, unbegrenzten GPT-5.5-Zugriff aus Entwicklersicht. Trotzdem ersetzt es nicht jede Funktion der offiziellen OpenAI API.

Sie erhalten:

GPT-5.x-Katalog inklusive 5.5, 5.5 Pro, 5.4-Varianten und Codex-Varianten
ältere OpenAI-Modelle wie GPT-4.1, GPT-4o, o1 und o3
GPT-Image-2 und DALL-E für Bildgenerierung
OpenAI-TTS-Modelle inklusive gpt-4o-mini-tts
Streaming
Vision
Function Calling
Temperatursteuerung
max_tokens

Was Sie möglicherweise nicht erhalten:

Responses API
Prompt-Caching zur Kostenreduzierung
Files API für hochgeladene Dokumente
serverseitige Nutzung ohne Browserkontext
direkte Rate-Limit-Header von OpenAI
strukturierte Ausgaben mit JSON-Schema-Erzwingung

Kurz gesagt:

Puter eignet sich sehr gut für Browser-Apps, Prototypen, kostenlose Tools und statische Seiten.
Offizielle OpenAI API eignet sich besser für Backend-Workloads, Compliance-Anforderungen und produktionsreife Serverarchitekturen.

Wann Puter verwenden?

Verwenden Sie Puter, wenn:

Sie eine kostenlose öffentliche App ohne eigenes Kostenrisiko veröffentlichen möchten.
Sie prototypen und keine OpenAI-Abrechnung einrichten wollen.
Sie eine statische Website, Browser-Erweiterung oder Hackathon-Demo bauen.
Sie keinen Backend-Proxy betreiben möchten.
Ihre Nutzer einen Puter-Login akzeptieren.

Wann die offizielle OpenAI API verwenden?

Verwenden Sie die offizielle OpenAI API, wenn:

Sie serverseitige Aufrufe brauchen.
Sie Cronjobs, Webhooks oder Batch-Verarbeitung ausführen.
Sie Prompt-Caching für stabile System-Prompts nutzen möchten.
Sie Responses API, Files oder strukturierte Ausgaben benötigen.
Sie Compliance- oder Vertragsanforderungen erfüllen müssen.
Ihre Nutzer keinen zusätzlichen Puter-Login akzeptieren.

Viele Projekte starten mit Puter und migrieren später zur offiziellen API, sobald Backend-Anforderungen, Compliance oder spezielle API-Funktionen wichtig werden. Die Migration ist einfacher, weil die Nachrichtenstruktur ähnlich bleibt.

Für ein kostenpflichtiges Produktions-Setup siehe Wie man die GPT-5.5 API verwendet.

Integration in Apidog testen

Puter-Aufrufe laufen im Browser. Deshalb können Sie sie nicht wie reine Backend-Requests direkt über einen klassischen API-Test-Runner ausführen. Ein praktikables Setup sieht so aus:

Erstellen Sie eine kleine statische Seite mit Puter.js.
Lesen Sie den Prompt aus einem Query-Parameter.
Testen Sie dieselbe Prompt-Struktur separat gegen die offizielle OpenAI API.
Halten Sie beide Varianten in Apidog als getrennte Umgebungen.

Beispiel für eine Puter-Testseite:

<!DOCTYPE html>
<html lang="de">
<body>
  <pre id="output"></pre>

  <script src="https://js.puter.com/v2/"></script>
  <script>
    const params = new URLSearchParams(location.search);
    const prompt = params.get("prompt") ?? "Sag Hallo";

    const output = document.querySelector("#output");

    puter.ai.chat(prompt, {
      model: "gpt-5.5"
    }).then(response => {
      output.textContent = response;
    });
  </script>
</body>
</html>

Aufruf lokal:

http://localhost:3000/?prompt=Erkläre%20WebSockets%20in%20drei%20Sätzen

In Apidog können Sie parallel Umgebungen anlegen:

puter-prototype: lokale URL Ihrer Puter-Testseite
openai-prod: https://api.openai.com/v1

Laden Sie Apidog herunter und pflegen Sie Puter-Prototyp und OpenAI-Produktions-Setup in derselben Sammlung. So können Sie Prompts, Request-Strukturen und erwartete Antworten systematisch vergleichen. Für breitere API-Testmuster siehe API-Testtool für QA-Ingenieure.

FAQ

Ist dies wirklich unbegrenzt, oder gibt es eine versteckte Obergrenze?

Aus Entwicklersicht ist es unbegrenzt. Der Endnutzer nutzt sein Puter-Konto. Neue Konten erhalten Startguthaben, und Nutzer können bei Bedarf mehr aufladen. Es gibt keine zentrale Obergrenze pro Entwicklerprojekt.

Brauche ich ein OpenAI-Konto?

Nein. Puter wickelt die OpenAI-Beziehung ab. Sie verwalten keinen OpenAI-Schlüssel.

Kann ich das in Produktion verwenden?

Ja, für browserbasierte Apps. Entscheidend ist, ob Ihre Nutzer bereit sind, sich bei Puter anzumelden.

Verhält sich GPT-5.5 über Puter identisch zur offiziellen API?

Die Modellausgabe basiert auf der offiziellen OpenAI API im Namen des Nutzers. Durch den zusätzlichen Hop kann die Latenz geringfügig höher sein.

Wie sieht es mit Prompt-Caching aus?

Puter bietet derzeit keine Preissteuerung für OpenAI-Prompt-Caching. Wenn Sie stabile große System-Prompts haben und Cache-Rabatte benötigen, verwenden Sie die offizielle API.

Kann ich Puter in einem Backend-Dienst verwenden?

Nicht sauber. Puter ist browserzentriert und setzt eine Benutzersitzung voraus. Backend-Dienste sollten die offizielle OpenAI API verwenden. Für kostenlose serverseitige Optionen siehe Wie man die GPT-5.5 API kostenlos verwendet.

Welches Modell sollte ich standardmäßig verwenden?

Verwenden Sie gpt-5.5 für allgemeine Aufgaben, gpt-5.4-nano für hochvolumige Klassifizierung, gpt-5.5-pro für komplexe Denkaufgaben und o3 für lange Schlussfolgerungsketten.

Werden meine Nutzer viel bezahlen müssen?

Chat-ähnliche Nutzung kostet typischerweise nur geringe Beträge pro Sitzung. Bildgenerierung ist teurer. Begrenzen Sie max_tokens und vermeiden Sie unnötige Generierungsaufrufe.

Kann ich Bilder mit Puter kostenlos generieren?

Ja, über txt2img mit gpt-image-2 oder DALL-E. Die Kosten werden dem Puter-Guthaben des Nutzers zugeordnet. Eine Anleitung zur offiziellen kostenpflichtigen API finden Sie unter Wie man die GPT-Image-2 API verwendet.

Zusammenfassung

Puter.js ist ein praktischer Weg, GPT-5.5 und andere OpenAI-Modelle in browserbasierte Apps einzubauen, ohne einen eigenen OpenAI-Key oder ein eigenes Abrechnungsmodell zu verwalten.

Der Implementierungsweg ist kurz:

Puter-Script einbinden.
Modell auswählen.
puter.ai.chat() oder eine der Spezialfunktionen aufrufen.
Optional Streaming, Vision, Function Calling, Bildgenerierung oder TTS ergänzen.
Bei Bedarf später zur offiziellen OpenAI API migrieren.

Für serverseitige Workloads, Prompt-Caching, Responses API, Files oder strukturierte Ausgaben bleibt die offizielle OpenAI API die bessere Wahl. Für Prototypen, Hackathons, kostenlose öffentliche Apps und statische Websites ist Puter eine sehr schnelle Lösung.

Erstellen Sie die Anfrage einmal in Apidog, vergleichen Sie Puter mit der offiziellen API und wählen Sie den Pfad, der zu Ihrer Architektur passt.

Kostenlose Unbegrenzte Claude Opus 4.7 API

Emre Demir — Sat, 09 May 2026 02:34:48 +0000

Die Claude-Familie von Anthropic ist eine leistungsfähige Closed-Source-Modellreihe für Programmierung, autonome Aufgaben und Long-Context-Reasoning. Der API-Preis kann jedoch schnell zum Limit für Seitenprojekte werden: Sonnet kostet 3 $ / 15 $ pro Million Tokens, Opus ist teurer. Puter.js dreht das Abrechnungsmodell um: Sie integrieren Claude im Browser ohne Anthropic-API-Key, während die Nutzung über das Puter-Konto des Endbenutzers läuft. Für Sie als Entwickler entstehen dadurch keine direkten Anthropic-Kosten.

Teste Apidog noch heute

Dieser Leitfaden zeigt die praktische Integration: Skript einbinden, Modell auswählen, Chat-Aufrufe ausführen, Streaming aktivieren, Konversationen verwalten und die Grenzen des Ansatzes kennen.

TL;DR

Puter.js ermöglicht browserbasierten Zugriff auf Claude ohne eigenen Anthropic-API-Key.
Die Nutzung wird dem Puter-Konto des Endbenutzers zugeordnet, nicht Ihrem Entwicklerkonto.
Unterstützte Modelle laut ursprünglichem Katalog: Opus 4.7, Opus 4.6, Opus 4.6 Fast, Opus 4.5, Opus 4.1, Opus 4, Sonnet 4.6, Sonnet 4.5, Sonnet 4, Haiku 4.5.
Die Basisintegration besteht aus einem <script>-Tag und einem Aufruf von puter.ai.chat().
Streaming, System-Prompts und mehrstufige Unterhaltungen funktionieren über eine Anthropic-ähnliche Nachrichtenstruktur.
Mit Apidog können Sie dieselben Prompts gegen Puter-Prototypen und eine spätere offizielle Anthropic-API-Integration vergleichen.

Wie das Abrechnungsmodell funktioniert

Puter.js ist eine browserbasierte Cloud- und KI-Bibliothek. Der zentrale Unterschied zur direkten Anthropic-Integration:

Sie speichern keinen Anthropic-API-Key.
Ihr Backend muss keine Claude-Aufrufe signieren.
Der Benutzer meldet sich bei Puter an.
Die Nutzung läuft über das Guthaben des jeweiligen Puter-Kontos.

Für Entwickler bedeutet das:

Kein API-Key im Frontend oder Repository

Kein Schlüssel, kein Leak-Risiko, keine Rotation.
Keine zentrale Entwicklerabrechnung

Jeder Benutzer bringt seine eigene Nutzung mit.
Schneller Prototyping-Pfad

Besonders geeignet für statische Websites, Hackathon-Projekte, Browser-Apps und Demos.

Der wichtigste Kompromiss: Puter.js ist browserzentriert. Für Cron-Jobs, Discord-Bots, serverseitige Batch-Verarbeitung oder API-Endpunkte ist die offizielle Anthropic API weiterhin die passendere Option.

Schritt 1: Puter.js einbinden

Für eine statische Seite reicht ein Script-Tag:

<script src="https://js.puter.com/v2/"></script>

Minimalbeispiel:

<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8" />
  <title>Claude mit Puter.js</title>
</head>
<body>
  <div id="output"></div>

  <script src="https://js.puter.com/v2/"></script>
  <script>
    async function main() {
      const response = await puter.ai.chat(
        "Erkläre Quantencomputing in einfachen Worten.",
        { model: "claude-sonnet-4-6" }
      );

      document.getElementById("output").textContent =
        response.message.content[0].text;
    }

    main();
  </script>
</body>
</html>

Wenn Sie eine gebündelte App mit Vite, Webpack oder ähnlichen Tools bauen, können Sie stattdessen das Paket verwenden:

npm install @heyputer/puter.js

import { puter } from "@heyputer/puter.js";

Für den schnellsten Einstieg ist das CDN-Tag meist ausreichend. Für TypeScript-Projekte oder größere Frontends ist der NPM-Import praktischer.

Schritt 2: Claude-Modell auswählen

Puter stellt Claude-Modelle über Modell-IDs bereit. Die Auswahl hängt vom Anwendungsfall ab:

Modell-ID	Wann verwenden?
`claude-opus-4-7`	Für besonders anspruchsvolle Reasoning-, Coding- und Agentenaufgaben
`claude-opus-4-6`	Starke Code-Erstellung und komplexe Aufgaben
`claude-opus-4.6-fast`	Opus-Variante mit Fokus auf geringere Latenz
`claude-opus-4-5`	Stabile Option für komplexere Produktionsszenarien
`claude-opus-4-1`	Älteres, gut einschätzbares Opus-Modell
`claude-opus-4`	Basislinie der Opus-4-Reihe
`claude-sonnet-4-6`	Guter Standard für tägliche Entwicklungs- und Chat-Aufgaben
`claude-sonnet-4-5`	Frühere Sonnet-Version für allgemeine Aufgaben
`claude-sonnet-4`	Basislinie der Sonnet-4-Reihe
`claude-haiku-4-5`	Schnelle Antworten, Klassifizierung, einfache Transformationen

Praktische Startpunkte:

Verwenden Sie claude-sonnet-4-6 als Standardmodell.
Verwenden Sie claude-haiku-4-5, wenn Latenz wichtiger ist als maximale Tiefe.
Verwenden Sie claude-opus-4-7, wenn der Prompt komplexe Planung, tiefe Codeanalyse oder mehrstufiges Reasoning benötigt.

Schritt 3: Einen einfachen Chat-Aufruf bauen

Der kleinste funktionierende Aufruf sieht so aus:

<!DOCTYPE html>
<html>
<body>
  <script src="https://js.puter.com/v2/"></script>
  <script>
    puter.ai.chat(
      "Erklären Sie Quantencomputing in einfachen Worten",
      { model: "claude-sonnet-4-6" }
    ).then(response => {
      puter.print(response.message.content[0].text);
    });
  </script>
</body>
</html>

Die Antwortstruktur ähnelt der Anthropic Messages API:

response.message.content[0].text

Für reine Textantworten reicht meist der erste Content-Block. Wenn Sie mit mehrteiligen Antworten arbeiten, sollten Sie alle Blöcke iterieren:

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

Schritt 4: Fehlerbehandlung ergänzen

Für Prototypen reicht der Minimalcode. Für eine echte UI sollten Sie Ladezustand und Fehler anzeigen:

<button id="run">Prompt senden</button>
<pre id="output"></pre>

<script src="https://js.puter.com/v2/"></script>
<script>
  const output = document.getElementById("output");
  const button = document.getElementById("run");

  button.addEventListener("click", async () => {
    output.textContent = "Lade...";

    try {
      const response = await puter.ai.chat(
        "Gib mir drei Ideen für eine REST-API-Teststrategie.",
        { model: "claude-sonnet-4-6" }
      );

      output.textContent = response.message.content[0].text;
    } catch (error) {
      console.error(error);
      output.textContent = "Fehler beim Claude-Aufruf. Details siehe Konsole.";
    }
  });
</script>

Das ist besonders wichtig, weil der Benutzer sich gegebenenfalls zuerst bei Puter anmelden muss.

Schritt 5: Streaming aktivieren

Für längere Antworten ist Streaming deutlich angenehmer. Aktivieren Sie es mit stream: true:

const response = await puter.ai.chat(
  "Schreiben Sie einen detaillierten Aufsatz über die Auswirkungen künstlicher Intelligenz auf die Gesellschaft.",
  {
    model: "claude-sonnet-4-6",
    stream: true
  }
);

for await (const part of response) {
  puter.print(part?.text);
}

Für eine eigene Chat-Oberfläche hängen Sie jeden Chunk an ein DOM-Element an:

const output = document.getElementById("output");

const stream = await puter.ai.chat(
  "Erstelle eine Schritt-für-Schritt-Anleitung für API-Mocking.",
  {
    model: "claude-sonnet-4-6",
    stream: true
  }
);

output.textContent = "";

for await (const part of stream) {
  if (part?.text) {
    output.textContent += part.text;
  }
}

Schritt 6: Mehrstufige Unterhaltungen verwalten

Für Chatverläufe übergeben Sie ein Array von Nachrichten:

const messages = [
  {
    role: "user",
    content: "Ich entwickle eine Next.js-App mit Postgres."
  },
  {
    role: "assistant",
    content: "Verstanden. Wobei benötigen Sie Hilfe?"
  },
  {
    role: "user",
    content: "Wie soll ich den Migrationsordner strukturieren?"
  }
];

const response = await puter.ai.chat(messages, {
  model: "claude-opus-4-7"
});

console.log(response.message.content[0].text);

In einer echten App speichern Sie den Verlauf clientseitig:

const messages = [];

async function sendMessage(userText) {
  messages.push({
    role: "user",
    content: userText
  });

  const response = await puter.ai.chat(messages, {
    model: "claude-sonnet-4-6"
  });

  const assistantText = response.message.content[0].text;

  messages.push({
    role: "assistant",
    content: assistantText
  });

  return assistantText;
}

Wichtig: Je länger der Verlauf wird, desto mehr Kontext wird mitgeschickt. Für lange Chats sollten Sie ältere Nachrichten zusammenfassen oder gezielt kürzen.

Schritt 7: System-Prompts verwenden

System-Prompts definieren Rolle, Stil, Einschränkungen und Ausgabeformat:

const messages = [
  {
    role: "system",
    content:
      "Sie sind ein erfahrener Backend-Ingenieur. Antworten Sie in nummerierten Punkten und mit maximal fünf Punkten."
  },
  {
    role: "user",
    content: "Wie verhindere ich SQL-Injection in einer Node-App?"
  }
];

const response = await puter.ai.chat(messages, {
  model: "claude-sonnet-4-6"
});

console.log(response.message.content[0].text);

Gute System-Prompts sind konkret:

const systemPrompt = `
Sie sind ein API-Reviewer.
Prüfen Sie die folgende OpenAPI-Spezifikation.
Antworten Sie mit:
1. Kritischen Fehlern
2. Sicherheitsrisiken
3. Verbesserungen für Developer Experience
4. Konkreten Änderungsvorschlägen
`;

Modelle mit demselben Prompt vergleichen

Um ein passendes Modell zu wählen, testen Sie denselben Prompt gegen mehrere Modelle:

const models = [
  "claude-haiku-4-5",
  "claude-sonnet-4-6",
  "claude-opus-4-7"
];

const prompt =
  "Refaktorisieren Sie diese React-Komponente, um Hooks zu verwenden: ...";

for (const model of models) {
  const start = performance.now();

  const response = await puter.ai.chat(prompt, { model });

  const elapsed = performance.now() - start;

  console.log(`${model}: ${elapsed.toFixed(0)}ms`);
  console.log(response.message.content[0].text);
  console.log("---");
}

Bewerten Sie nicht nur die Antwortqualität, sondern auch:

Latenz
Antwortlänge
Konsistenz bei wiederholten Runs
Qualität bei Randfällen
Eignung für Ihren konkreten UI-Flow

Für viele Anwendungen ist claude-sonnet-4-6 ein sinnvoller Default. claude-haiku-4-5 eignet sich für schnelle Klassifizierung oder einfache Texttransformationen. claude-opus-4-7 sollten Sie für Aufgaben reservieren, bei denen bessere Reasoning-Qualität den Mehraufwand rechtfertigt.

Wenn Sie Puter mit einer späteren offiziellen Anthropic-Integration vergleichen möchten, können Sie in Apidog separate Umgebungen für Prototyp und Produktion pflegen.

Was Sie bekommen — und was nicht

Puter.js ist praktisch, aber nicht identisch mit einer direkten Backend-Integration über die offizielle Anthropic API.

Sie bekommen:

Zugriff auf Claude-Modelle über eine einfache Browser-API
Mehrstufige Unterhaltungen
System-Prompts
Streaming-Antworten
Keine Verwaltung eigener Anthropic-Keys
Kein zentrales Abrechnungsrisiko für Ihr Projekt

Sie bekommen möglicherweise nicht oder nur eingeschränkt:

Native Tool-Nutzung / Function Calling, abhängig vom aktuellen Puter-Funktionsumfang
Vision-Eingaben wie Bildanhänge
Direkte Kontrolle über Anthropic-spezifisches Prompt-Caching
Serverseitige Nutzung ohne Browserkontext
Direkte Einsicht in Anthropic-Rate-Limit-Header

Für Workflows mit komplexer Tool-Nutzung, MCP-Servern oder Backend-Automatisierung bietet die offizielle Anthropic API mehr Kontrolle. Für MCP-bezogene Tests siehe auch MCP-Server-Testing in Apidog.

Wann Sie Puter verwenden sollten

Verwenden Sie Puter.js, wenn:

Sie eine browserbasierte Demo oder öffentliche App bauen.
Sie keine eigene Anthropic-Abrechnung verwalten möchten.
Sie schnell prototypen wollen.
Ihre App ohne Backend auskommen soll.
Ihre Benutzer einen Puter-Login akzeptieren.

Verwenden Sie die offizielle Anthropic API, wenn:

Sie serverseitige Jobs, Cron-Prozesse oder Backend-Endpunkte haben.
Sie Tool-Nutzung, Vision oder Files-Workflows benötigen.
Sie Prompt-Caching gezielt zur Kostenoptimierung einsetzen wollen.
Sie Compliance-Anforderungen vertraglich abdecken müssen.
Ihre Benutzer keinen zusätzlichen Login-Schritt akzeptieren.

Ein praktikabler Weg ist: mit Puter prototypen, Produktlogik validieren und bei Bedarf später auf die offizielle API migrieren. Da die Nachrichtenstruktur ähnlich ist, bleibt die Migration überschaubar.

Für das GPT-Äquivalent siehe Wie man die GPT-5.5 API verwendet.

Die Integration mit Apidog testen

Puter-Aufrufe laufen im Browser. Ein klassischer Backend-Test-Runner kann sie daher nicht direkt wie eine normale REST-API testen. Ein praktikabler Testaufbau:

Erstellen Sie eine kleine statische Testseite mit Puter.js.
Übergeben Sie den Prompt per Query-Parameter oder Formularfeld.
Loggen Sie Modell, Prompt, Antwort und Laufzeit im Browser.
Pflegen Sie in Apidog parallel die spätere Anthropic-API-Struktur.
Vergleichen Sie beide Pfade über separate Umgebungen.

Laden Sie Apidog herunter und legen Sie zwei Umgebungen an:

puter-prototype

Beispiel: http://localhost:5173
anthropic-prod

Beispiel: https://api.anthropic.com/v1

So können Sie Prompts, erwartete Antworten und spätere API-Verträge an einem Ort dokumentieren.

Beispiel: Prompt über URL testen

Eine einfache Testseite kann den Prompt aus der URL lesen:

<!DOCTYPE html>
<html lang="de">
<head>
  <meta charset="UTF-8" />
  <title>Puter Claude Test</title>
</head>
<body>
  <pre id="output">Lade...</pre>

  <script src="https://js.puter.com/v2/"></script>
  <script>
    async function main() {
      const params = new URLSearchParams(window.location.search);
      const prompt = params.get("prompt") || "Sag Hallo in einem Satz.";
      const model = params.get("model") || "claude-sonnet-4-6";

      const output = document.getElementById("output");

      try {
        const start = performance.now();

        const response = await puter.ai.chat(prompt, { model });

        const elapsed = performance.now() - start;

        output.textContent = JSON.stringify(
          {
            model,
            elapsedMs: Math.round(elapsed),
            prompt,
            response: response.message.content[0].text
          },
          null,
          2
        );
      } catch (error) {
        output.textContent = String(error);
      }
    }

    main();
  </script>
</body>
</html>

Aufruf im Browser:

http://localhost:5173/?model=claude-sonnet-4-6&prompt=Erkläre%20API-Mocking

Damit erhalten Sie einen reproduzierbaren Prototyp, den Sie später mit einer serverseitigen Anthropic-Route vergleichen können.

FAQ

Ist das wirklich unbegrenzt?

Aus Entwicklersicht gibt es keine zentrale Anthropic-Abrechnung über Ihr Konto. Die tatsächliche Nutzung hängt vom Puter-Konto und Guthaben des jeweiligen Endbenutzers ab.

Muss ich mich bei Anthropic anmelden?

Nein. Bei diesem Ansatz verwalten Sie keinen Anthropic-API-Key.

Kann ich das in Produktion verwenden?

Ja, für browserbasierte Apps, wenn der Puter-Login für Ihre Benutzer akzeptabel ist. Für serverseitige Produktionslogik sollten Sie die offizielle Anthropic API prüfen.

Verhält sich Claude über Puter identisch zur offiziellen API?

Die Modellantworten sollten grundsätzlich aus demselben Claude-Modell stammen. Die verfügbare API-Oberfläche, Latenz und Zusatzfunktionen können sich jedoch von der direkten Anthropic API unterscheiden.

Was ist mit Prompt-Caching?

Wenn Sie Anthropic-spezifisches Prompt-Caching gezielt steuern möchten, ist die offizielle API der bessere Weg.

Kann ich Puter in einem Discord-Bot oder Backend-Dienst verwenden?

Nicht sauber, da Puter.js browserzentriert ist und eine Benutzersitzung voraussetzt. Für Bots und Backends verwenden Sie besser die offizielle Anthropic API.

Welches Modell sollte ich standardmäßig verwenden?

claude-sonnet-4-6 ist ein guter Startpunkt. Wechseln Sie zu claude-opus-4-7 für tiefere Analyse und zu claude-haiku-4-5 für schnelle, einfache Aufgaben.

Zusammenfassung

Puter.js ist ein schneller Weg, Claude in browserbasierte Apps einzubauen, ohne einen eigenen Anthropic-API-Key zu verwalten. Die Integration ist minimal: Skript einfügen, Modell wählen, puter.ai.chat() aufrufen.

Für Prototypen, statische Websites, Hackathon-Projekte und kostenlose öffentliche Tools ist dieser Ansatz besonders praktisch. Für serverseitige Workloads, Tool-Nutzung, Prompt-Caching oder Compliance-Anforderungen bleibt die offizielle Anthropic API die robustere Option.

Erstellen Sie Ihre Testfälle in Apidog, vergleichen Sie Puter-Prototypen mit einer offiziellen API-Integration und migrieren Sie erst dann, wenn Ihr Anwendungsfall es wirklich erfordert.

Grok 4.3 Kostenlos Nutzen: 4 Funktionierende Wege 2026

Emre Demir — Sat, 09 May 2026 02:28:59 +0000

Grok 4.3 ist ab Mai 2026 xAIs Vorzeigemodell: 1M-Token-Kontextfenster, native Videoeingabe und ein Preis von 1,25 $ / 2,50 $ pro Million Tokens. Wenn Sie Prototypen bauen, lernen oder ein Nebenprojekt entwickeln, können Sie Grok 4.3 über drei realistische Wege kostenlos nutzen: xAI Console-Werbeguthaben, Puter.js mit Benutzer-zahlt-Modell und die kostenlosen Chat-Oberflächen auf grok.com und X.

Testen Sie Apidog noch heute

Dieser Leitfaden zeigt die praktische Umsetzung für jeden Weg: Einrichtung, Beispielaufrufe, Grenzen und Entscheidungskriterien. Den vollständigen Leitfaden für die kostenpflichtige API finden Sie unter So verwenden Sie die Grok 4.3 API. Für das Sprach-Äquivalent siehe So verwenden Sie Grok Voice kostenlos.

TL;DR

Drei kostenlose Wege zu Grok 4.3: xAI Console mit Werbeguthaben, Puter.js mit Benutzer-zahlt-Modell und die Chat-UIs auf grok.com und X.
Für Entwickler am praktischsten: Puter.js. Sie stellen ohne eigenen Billing-Key bereit; der Endbenutzer trägt seine Nutzung.
Für API-Prototyping: xAI Console. Das Startguthaben reicht typischerweise, um eine Integration Ende-zu-Ende zu testen.
Für Nicht-Entwickler: grok.com oder X-App. Kein Code, aber tägliche Limits.
Modell-IDs: Puter: x-ai/grok-4.3; direkt bei xAI: grok-4.3.
Nutzen Sie Apidog, um Anfragen an mehrere Anbieter zu testen und Latenz, Antwortqualität und Token-Verbrauch zu vergleichen.

Weg 1: xAI Console-Werbeguthaben

Nutzen Sie diesen Weg, wenn Sie die echte Produktions-API testen möchten.

Schritt 1: Konto erstellen

Gehen Sie zu console.x.ai und erstellen Sie ein Konto. Die Anmeldung läuft über Ihr X-Konto.

Schritt 2: Guthaben prüfen

xAI bietet zeitweise Werbeguthaben für neue Konten an. Betrag und Laufzeit können sich ändern. Prüfen Sie nach der Registrierung den Bereich Abrechnung.

Wichtig:

Das Guthaben erneuert sich normalerweise nicht automatisch.
Es eignet sich für Prototyping, nicht für dauerhafte Produktion.
Sobald das Guthaben aufgebraucht ist, müssen Sie zahlen oder zu einem anderen Weg wechseln.

Schritt 3: API-Key setzen

Erstellen Sie in der Console einen API-Key und exportieren Sie ihn lokal:

export XAI_API_KEY="xai-..."

Schritt 4: Grok 4.3 aufrufen

Der Endpoint ist OpenAI-kompatibel:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "user",
        "content": "Explain prompt caching in three sentences."
      }
    ],
    "reasoning_effort": "low"
  }'

Für Prototyping sollten Sie mit reasoning_effort: "low" starten. medium und high verbrauchen Ihr Guthaben schneller.

Vor- und Nachteile

Vorteile	Nachteile
Echte Produktions-API	Guthaben ist begrenzt
Gleiche Oberfläche wie bei bezahlter Nutzung	Werbebedingungen können sich ändern
Unterstützt Grok 4.3-Funktionen wie 1M Kontext, Video und Function Calling	Für Lasttests ungeeignet
Keine Code-Migration beim Wechsel zu Paid	Rate Limits bleiben bestehen

Empfehlung: Starten Sie mit der Console, wenn Sie wissen möchten, wie sich die direkte xAI API in Ihrer App verhält. Das vollständige Request-Schema finden Sie unter So verwenden Sie die Grok 4.3 API.

Weg 2: Puter.js — Benutzer zahlt, Entwickler kostenlos

Puter.js ist der sauberste Weg für öffentliche Web-Apps, wenn Sie keine eigene AI-Abrechnung betreiben möchten.

Wie das Modell funktioniert

Puter.js stellt einen JavaScript-Client bereit, der LLMs wie Grok, GPT, Claude, Gemini und DeepSeek aufrufen kann.

Der wichtige Unterschied:

Der Endbenutzer bezahlt die Nutzung über sein Puter-Konto, nicht Sie als Entwickler.

Das bedeutet:

Sie benötigen keinen API-Key im Frontend.
Sie müssen keine eigene Billing-Logik bauen.
Ihre öffentliche App kann AI-Funktionen anbieten, ohne dass Sie die Modellkosten tragen.

Schritt 1: Puter.js einbinden

Fügen Sie das Skript in Ihre HTML-Seite ein:

<script src="https://js.puter.com/v2/"></script>

Mehr Setup ist nicht nötig.

Schritt 2: Grok 4.3 aufrufen

Verwenden Sie puter.ai.chat() mit der Modell-ID x-ai/grok-4.3:

<script src="https://js.puter.com/v2/"></script>

<script>
  puter.ai.chat(
    "Summarize the trade-offs between SQLite and Postgres in three bullets.",
    { model: "x-ai/grok-4.3" }
  ).then((response) => {
    document.body.innerText = response.message.content;
  });
</script>

Beim ersten Aufruf fordert Puter den Benutzer auf, sich anzumelden oder ein Konto zu erstellen. Danach werden die Aufrufe gegen dessen Puter-Guthaben abgerechnet.

Schritt 3: Streaming verwenden

Für längere Antworten sollten Sie Streaming aktivieren:

const stream = await puter.ai.chat(
  "Walk me through migrating a React app to Next.js.",
  {
    model: "x-ai/grok-4.3",
    stream: true,
    reasoning_effort: "medium",
  }
);

for await (const chunk of stream) {
  process.stdout.write(chunk?.text || "");
}

Wann Puter.js passt

Puter.js eignet sich besonders für:

öffentliche Web-Tools
Demos
Lernprojekte
clientseitige Apps
Nebenprojekte ohne eigene AI-Kostenstelle

Nicht ideal ist Puter.js für:

reine Backend-Jobs
interne Automatisierung
Bots, bei denen kein Endbenutzer im Browser sitzt
Workloads, bei denen Sie die vollständige Server-Kontrolle brauchen

Vor- und Nachteile

Vorteile	Nachteile
Entwickler zahlt dauerhaft 0 $	Benutzer muss sich bei Puter anmelden
Kein API-Key im Repo	Weniger geeignet für reine Backend-Systeme
Einfache Browser-Integration	Benötigt Browser-Kontext
Unterstützt mehrere LLM-Anbieter	Potenziell höhere Latenz als direkte xAI API

Empfehlung: Verwenden Sie Puter.js, wenn Ihre Benutzer diejenigen sind, die die Abfragen ausführen. Für serverseitige Automatisierung ist die xAI Console der bessere kostenlose Einstieg.

Ähnliche Muster finden Sie in Wie man die DeepSeek V4 API kostenlos nutzt und Wie man die GPT-5.5 API kostenlos nutzt.

Weg 3: grok.com und X-App

Wenn Sie keinen API-Zugriff brauchen, sondern nur mit Grok chatten möchten, nutzen Sie die kostenlosen Chat-Oberflächen.

grok.com: Web-Chat mit X-Login.
X-App: Grok ist in den mobilen und Web-Apps von X verfügbar.

Diese Option eignet sich für:

einmalige Fragen
manuelle Prompt-Tests
schnelle Modell-Evaluierung
Recherche ohne Code

Sie können diese Oberfläche nicht skripten. Wenn Sie automatisierte Requests, Logs, Tests oder Integration in eine App brauchen, verwenden Sie xAI Console oder Puter.js.

Die kostenlose Stufe auf grok.com verwendet standardmäßig eine kleinere Grok-Variante. Premium-Abonnements auf X schalten Grok 4.3 in der Chat-Oberfläche mit höheren Kontingenten frei.

Weg 4: OpenRouter — günstig, aber nicht kostenlos für Grok 4.3

OpenRouter aggregiert mehrere Modellanbieter hinter einem API-Key und einer Billing-Oberfläche.

Für Grok 4.3 ist OpenRouter nicht kostenlos. Der Preis entspricht direkt bei xAI: 1,25 $ / 2,50 $ pro 1 Mio. Tokens.

Trotzdem kann OpenRouter nützlich sein, weil es kostenlose Varianten anderer Grok-Modelle gibt, zum Beispiel:

x-ai/grok-4-fast:free

Wenn Sie nicht zwingend Grok 4.3 benötigen, können Sie damit kostenlos eine Grok-ähnliche Ausgabe testen.

Beispiel:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "x-ai/grok-4-fast:free",
    "messages": [
      {
        "role": "user",
        "content": "Hello!"
      }
    ]
  }'

Verwenden Sie OpenRouter, wenn Sie mehrere Modelle über eine einheitliche API vergleichen möchten. Verwenden Sie einen der ersten drei Wege, wenn Sie speziell Grok 4.3 kostenlos nutzen möchten.

Vergleich der Wege

Weg	Kosten für Entwickler	Kosten für Endbenutzer	Am besten geeignet für
xAI Console-Guthaben	0 $ innerhalb des Guthabens	n. a.	API-Prototyping, Lernen der Produktions-API
Puter.js	0 $	wenige Cent pro Sitzung	öffentliche Web-Apps, Demos, kostenlose Tools
grok.com / X	0 $	0 $ mit Kontingent	manuelle Nutzung, Prompt-Tests
OpenRouter Free-Modell	0 $	n. a.	Grok-ähnliche Ausgabe, aber nicht Grok 4.3

Anbieterübergreifend mit Apidog testen

Wenn Sie mehrere Anbieter vergleichen, sollten Sie dieselbe Anfrage gegen mehrere Base-URLs ausführen. So sehen Sie Unterschiede bei Antwortqualität, Token-Verbrauch und Latenz.

Setup in Apidog

Erstellen Sie eine neue Umgebung in Apidog.
Legen Sie Variablen an:
- XAI_API_KEY
- OPENROUTER_API_KEY
- BASE_URL
Erstellen Sie eine Request-Collection für Chat Completions.
Verwenden Sie für xAI:
- Base URL: https://api.x.ai/v1
- Model: grok-4.3
Verwenden Sie für OpenRouter:
- Base URL: https://openrouter.ai/api/v1
- Model: x-ai/grok-4-fast:free oder ein anderes verfügbares Modell
Führen Sie denselben Prompt gegen beide Umgebungen aus.
Vergleichen Sie Antwort, Latenz und Token-Verbrauch.

Puter.js läuft browserseitig und fällt aus diesem API-Test-Loop heraus.

Laden Sie Apidog herunter und erstellen Sie eine Collection mit dem OpenAI Chat Completions Schema. Weitere Informationen zum anbieterübergreifenden Testen finden Sie unter API-Testtool für QA-Ingenieure.

Was Sie bei kostenlosen Wegen beachten müssen

Kostenlose Optionen sind gut für Prototypen, aber sie haben Grenzen.

1. Strengere Rate Limits

Konsolen-Guthaben hebt Rate Limits nicht auf. Wenn Sie viele Requests parallel senden, können 429-Fehler auftreten, bevor das Guthaben verbraucht ist.

Planen Sie deshalb:

Request-Throttling
Retry mit Backoff
kleinere Testdatensätze
Logging für Fehlerraten

2. Prompt-Caching bringt erst später viel

Prompt-Caching ist bei großen, wiederverwendeten System-Prompts nützlich. Für einen kleinen 50-Request-Prototypen werden Sie die Einsparung kaum merken.

Relevant wird es, wenn:

Ihr System-Prompt sehr groß ist
Sie denselben Kontext häufig wiederverwenden
Sie wiederkehrende Workloads haben

3. Support ist eingeschränkt

Kostenlose Konten erhalten in der Regel keinen produktionskritischen Support. Wenn Sie SLAs, Audit-Trails oder Compliance-Anforderungen brauchen, sollten Sie bezahlte Nutzung einplanen.

Wann Sie auf kostenpflichtige Nutzung wechseln sollten

Wechseln Sie auf Paid, wenn eines dieser Signale zutrifft:

Regelmäßiger Durchsatz: Sie stoßen mehrmals pro Woche an Rate Limits.
Stabile große Prompts: Ihr System-Prompt ist groß und wird häufig wiederverwendet.
Produktionsbetrieb: Benutzer verlassen sich auf Ihre Anwendung.
Compliance: Sie brauchen Audit-Trails, BAAs, SOC-2-Anforderungen oder regionale Datenresidenz.
Backend-Automatisierung: Sie können das Benutzer-zahlt-Modell von Puter.js nicht nutzen.

Die Migration ist meist klein: Base URL, API-Key und gegebenenfalls Modell-ID ändern. Das Chat-Completions-Request-Format bleibt weitgehend gleich.

FAQ

Ist Grok 4.3 wirklich kostenlos?

Es hängt vom Weg ab:

xAI Console: kostenlos innerhalb des Werbeguthabens.
Puter.js: kostenlos für den Entwickler; der Benutzer trägt die Nutzung.
grok.com / X: kostenlos mit täglichem Nachrichtenlimit.

Kann ich Grok 4.3 aus einem Backend nutzen, ohne zu bezahlen?

Ja, solange Ihr xAI Console-Guthaben reicht. Danach müssen Sie zahlen oder eine browserseitige Option wie Puter.js verwenden, bei der der Endbenutzer die Nutzung trägt.

Funktioniert Puter.js in Node.js?

Puter.js ist primär für den Browser gedacht. Das Benutzer-zahlt-Modell basiert auf der Browser-Sitzung des Endbenutzers. Für Backend-Code ist die xAI Console der passendere kostenlose Einstieg.

Welche Modell-ID nutze ich bei Puter.js?

x-ai/grok-4.3

Welche Modell-ID nutze ich direkt bei xAI?

grok-4.3

Deckt xAI Console-Guthaben Function Calling und Videoeingabe ab?

Ja. Das Guthaben gilt für die Grok 4.3-Nutzung. Achten Sie aber auf den Token-Verbrauch: Video und große Kontexte können Guthaben schnell verbrauchen.

Wie unterscheidet sich das von Grok Voice?

Grok Voice ist separat zu betrachten. Grok 4.3 Text ist über Guthaben oder alternative Wege nutzbar. Siehe So verwenden Sie Grok Voice kostenlos.

Gibt es ein kostenloses Grok 4.3 Mini?

Noch nicht. xAI hat keine separate Mini-SKU für die 4.3-Linie veröffentlicht. Eine kostenlose Alternative ist grok-4-fast:free auf OpenRouter, aber das ist nicht Grok 4.3.

Zusammenfassung

Für Grok 4.3 gibt es drei sinnvolle kostenlose Einstiege:

xAI Console: beste Wahl für API-Prototyping mit echter Produktionsoberfläche.
Puter.js: beste Wahl für öffentliche Web-Apps ohne eigene AI-Kosten.
grok.com / X: beste Wahl für manuelle Nutzung ohne Code.

OpenRouter ist zusätzlich nützlich, wenn Sie kostenlose Grok-ähnliche Modelle testen möchten, aber Grok 4.3 selbst ist dort nicht kostenlos.

Wenn Ihr Projekt produktiv wird, ist bezahlte Nutzung oft der einfachste Weg: API-Key setzen, Base URL stabil halten und Requests weiter über das OpenAI-kompatible Schema ausführen. Für die vollständige Anleitung zur kostenpflichtigen API siehe So verwenden Sie die Grok 4.3 API. Für den direkten Vergleich mit OpenAI siehe Grok Voice vs. GPT-Realtime.

Erstellen Sie die Anfrage einmal in Apidog, wechseln Sie die Base URL je nach Anbieter und testen Sie mit identischen Prompts, welcher Weg zu Ihrer Nutzungskurve passt.

Grok 4.3 API Nutzung: Eine Anleitung

Emre Demir — Fri, 08 May 2026 07:46:24 +0000

xAI hat Grok 4.3 schrittweise ausgerollt: Beta am 17. April 2026, API-Zugang am 30. April und allgemeine Verfügbarkeit am 6. Mai. Für Entwickler sind vor allem vier Punkte relevant: ein 1.000.000-Token-Kontextfenster, native Videoeingabe, durchgängiges Reasoning und eine Preissenkung von ungefähr 40 % gegenüber Grok 4.20. Da acht ältere Grok-Modelle am 15. Mai eingestellt werden, sollten bestehende Integrationen mit grok-3- oder grok-4-Modellen jetzt migriert und getestet werden.

Probieren Sie Apidog noch heute aus

Dieser Leitfaden zeigt die praktische Integration von Grok 4.3: Endpunkt, Authentifizierung, OpenAI-kompatible base_url, reasoning_effort, Videoeingabe, Funktionsaufrufe und ein reproduzierbares Test-Setup in Apidog.

Für die Sprachseite derselben Veröffentlichung siehe Wie man Grok Voice kostenlos nutzt. Für den direkten Vergleich mit OpenAIs führendem Sprachmodell siehe Grok Voice vs. GPT-Realtime.

TL;DR

Grok 4.3 ist seit dem 6. Mai 2026 allgemein verfügbar. Acht ältere Modelle werden am 15. Mai 2026 eingestellt.
Preise: $1.25 pro 1M Eingabe-Tokens, $2.50 pro 1M Ausgabe-Tokens, zwischengespeicherte Eingabe $0.20 pro 1M.
Kontextfenster: 1M Tokens.
Neue Fähigkeit: native Videoeingabe.
Reasoning ist durchgängig aktiv und kann über reasoning_effort gesteuert werden: low, medium, high.
API-Endpunkt: https://api.x.ai/v1/chat/completions.
OpenAI-kompatibel: OpenAI SDK verwenden, base_url austauschen.
Durchsatz: ungefähr 159 Tokens/Sekunde auf Standard-Tiers.
Testen Sie Varianten mit Apidog, um Latenz, Antwortqualität und usage.reasoning_tokens zu vergleichen.

Was sich in Grok 4.3 geändert hat

Die wichtigsten Änderungen für Implementierungen:

Niedrigere Kosten

Die Eingabekosten sinken um 37,5 % gegenüber Grok 4.20, die Ausgabekosten um 58,3 %. Zwischengespeicherte Eingaben kosten jetzt 0,20 $ pro 1M Tokens. Das ist besonders relevant für stabile System-Prompts, große Kontextblöcke und wiederkehrende Agenten-Workflows.
1M-Token-Kontext

Das Kontextfenster steigt von 256k auf 1M Tokens. Damit können Sie große Diffs, lange Dokumente, komplette Berichte oder längere Konversationshistorien in einer Anfrage verarbeiten.
Native Videoeingabe

Grok 4.3 kann Video-URLs direkt als Inhaltsblock verarbeiten. Sie müssen nicht zuerst manuell Frames extrahieren.
Durchgängiges Reasoning

Jede Anfrage nutzt mindestens low Reasoning. Über reasoning_effort steuern Sie, wie viel Reasoning-Zeit und Tokens das Modell investieren soll.
Bessere agentische Workflows

xAI nennt einen Gewinn von +300 Elo-Punkten auf GDPval-AA gegenüber Grok 4.20. In der Praxis ist das vor allem bei Tool-Auswahl, mehrstufigen Abläufen und Fehlererholung relevant.

Der Intelligenzindex von 53 (Artificial Analysis) platziert Grok 4.3 über dem Durchschnitt von 35 für seine Preisklasse und auf Platz 10 von 146 erfassten Modellen.

Voraussetzungen

Bereiten Sie vor der ersten Anfrage diese Komponenten vor:

Ein xAI Console-Konto unter console.x.ai.
Einen API-Schlüssel, idealerweise projektbezogen für Produktionsumgebungen.
Das OpenAI SDK oder das xAI SDK.
Einen API-Client wie Apidog, damit Sie Requests versionieren, wiederholen und Varianten vergleichen können.

Exportieren Sie den Schlüssel lokal:

export XAI_API_KEY="xai-..."

Endpunkt und Authentifizierung

Grok 4.3 wird über die OpenAI-kompatible Chat-Completions-Schnittstelle bereitgestellt.

POST https://api.x.ai/v1/chat/completions

Die Header entsprechen dem üblichen Bearer-Token-Muster:

Authorization: Bearer $XAI_API_KEY
Content-Type: application/json

Wenn Sie bereits das OpenAI SDK verwenden, müssen Sie in vielen Fällen nur base_url und model ändern.

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["XAI_API_KEY"],
    base_url="https://api.x.ai/v1",
)

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Summarize the trade-offs of GraphQL vs REST in three bullets."
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)

Anfrageparameter

Die wichtigsten Parameter für Grok 4.3:

Parameter	Typ	Werte	Hinweise
`model`	string	`grok-4.3`	Erforderlich.
`messages`	array	OpenAI-Nachrichtenstruktur	Erforderlich. Unterstützt `system`, `user`, `assistant`.
`reasoning_effort`	string	`low`, `medium`, `high`	Optional. Standard: `medium`.
`max_tokens`	int	1–32768	Begrenzt die Ausgabe.
`temperature`	float	0.0–2.0	Standard: 1.0.
`top_p`	float	0.0–1.0	Nucleus Sampling.
`stream`	bool	`true`, `false`	Server-Sent Events bei `true`.
`tools`	array	OpenAI-Tool-Struktur	Für Funktionsaufrufe.
`tool_choice`	string / object	`auto`, `none`, spezifisches Tool	Standard-OpenAI-Semantik.
`response_format`	object	`{ "type": "json_object" }`	Strukturierte Ausgabe.
`seed`	int	beliebig	Für Reproduzierbarkeit bei `temperature: 0`.

Minimaler curl-Request:

curl https://api.x.ai/v1/chat/completions \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.3",
    "messages": [
      {
        "role": "system",
        "content": "You are a senior backend engineer."
      },
      {
        "role": "user",
        "content": "Review this query plan and flag the bottleneck."
      }
    ],
    "reasoning_effort": "high"
  }'

Die Antwort folgt der OpenAI-Struktur:

{
  "choices": [
    {
      "message": {
        "role": "assistant",
        "content": "..."
      }
    }
  ],
  "usage": {
    "prompt_tokens": 123,
    "completion_tokens": 456,
    "reasoning_tokens": 78,
    "total_tokens": 657
  }
}

Reasoning-Aufwand richtig wählen

reasoning_effort ist einer der wichtigsten Tuning-Parameter.

`low`

Geeignet für:

Klassifizierung
einfache Zusammenfassungen
FAQ-Antworten
Routing
einfache Extraktion

Beispiel:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Classify this ticket as billing, technical, or account."
        }
    ],
    reasoning_effort="low",
)

`medium`

Geeignet für:

Kundenservice
einfache Tool-Nutzung
Datenanalyse
Standard-Agenten
strukturierte Antworten

medium ist der Standard und für den meisten Produktionsverkehr der erste sinnvolle Wert.

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Analyze this API error log and suggest likely causes."
        }
    ],
    reasoning_effort="medium",
)

`high`

Geeignet für:

mehrstufige Agenten
komplexe Code-Reviews
mathematische Aufgaben
Planungsaufgaben
Workflows mit mehreren Tool-Aufrufen

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Review this migration plan and identify hidden failure modes."
        }
    ],
    reasoning_effort="high",
)

Wichtig: Reasoning ist in Grok 4.3 nicht vollständig deaktivierbar. Auch low führt einen grundlegenden Reasoning-Schritt aus.

Funktionsaufrufe verwenden

Grok 4.3 unterstützt die OpenAI-kompatible Tool-Struktur. Der Ablauf:

Tool-Schema deklarieren.
Anfrage mit tools senden.
tool_calls aus der Antwort lesen.
Tool serverseitig ausführen.
Ergebnis als tool-Nachricht zurückgeben.

Beispiel:

tools = [
    {
        "type": "function",
        "function": {
            "name": "lookup_user",
            "description": "Look up a user by ID.",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "string"
                    }
                },
                "required": ["user_id"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": "Find user u_42 and tell me their last login."
        }
    ],
    tools=tools,
    reasoning_effort="medium",
)

tool_calls = response.choices[0].message.tool_calls

for call in tool_calls:
    print(call.function.name)
    print(call.function.arguments)

Danach führen Sie das Tool in Ihrer Anwendung aus und senden das Ergebnis zurück:

messages = [
    {
        "role": "user",
        "content": "Find user u_42 and tell me their last login."
    },
    response.choices[0].message,
    {
        "role": "tool",
        "tool_call_id": tool_calls[0].id,
        "content": '{"user_id":"u_42","last_login":"2026-05-01T13:45:00Z"}'
    }
]

final_response = client.chat.completions.create(
    model="grok-4.3",
    messages=messages,
    tools=tools,
    reasoning_effort="medium",
)

print(final_response.choices[0].message.content)

Wenn Sie Tool-Abläufe isoliert testen möchten, beschreibt MCP-Servertests in Apidog eine passende Wiedergabe- und Testeinrichtung.

Videoeingabe

Grok 4.3 ist das erste Grok-Modell mit nativer Videoeingabe. Sie übergeben eine Video-URL als Inhaltsblock:

response = client.chat.completions.create(
    model="grok-4.3",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Describe what happens in this clip and flag any anomalies."
                },
                {
                    "type": "video_url",
                    "video_url": {
                        "url": "https://example.com/clip.mp4"
                    }
                },
            ],
        }
    ],
    reasoning_effort="medium",
)

print(response.choices[0].message.content)

Praktische Hinweise:

Video-Tokens zählen zu den Eingabe-Tokens.
Lange Clips verbrauchen den Kontext schnell.
Wenn Kosten relevant sind, kürzen oder komprimieren Sie Videos vor dem Senden.
Da das Modell nativ über Frames reasonen kann, müssen Sie keine eigenen Keyframes extrahieren.

1M-Token-Kontext praktisch nutzen

Das 1M-Kontextfenster ist besonders nützlich, wenn Sie bisher Chunking, Retrieval oder manuelles Zusammenführen einsetzen mussten.

Typische Muster:

Code-Review über große Diffs

System:
You are a senior backend reviewer. Focus on correctness, security, and migration risks.

User:
Here is the full diff:
<diff>

Here are the affected files:
<files>

Here is the CI output:
<logs>

Return:
1. Critical issues
2. Risky assumptions
3. Suggested fixes

Dokumenten-QA

Sie können lange Verträge, technische Spezifikationen oder Berichte direkt in den Prompt aufnehmen und gezielte Fragen stellen:

Based only on the document below, list all clauses that affect data retention.

<full document>

Agenten-Kontext

Für länger laufende Agenten können Sie mehr Verlauf im Kontext halten, statt aggressive Zusammenfassungen zu erzwingen.

Zwischengespeicherte Eingaben reduzieren die Kosten bei stabilen Prompts deutlich. Ein stabiler System-Prompt mit 400.000 Tokens kostet bei zwischengespeicherter Eingabe 0,08 $ pro Aufruf statt 0,50 $ bei regulärer Eingabe.

Migration von älteren Grok-Modellen

Acht ältere Grok-Modelle werden am 15. Mai 2026, 12:00 Uhr PT eingestellt. Wenn Ihre Anwendung noch grok-3- oder ältere grok-4-Varianten nutzt, planen Sie mindestens diese Schritte:

Modellnamen auf grok-4.3 ändern.
base_url auf https://api.x.ai/v1 setzen, falls noch nicht geschehen.
Testfälle mit echten Produktionsprompts ausführen.
Latenz und usage.reasoning_tokens vergleichen.
Regex- oder Parser-Nachbearbeitung erneut validieren.

Beispiel für eine minimale Migration:

 response = client.chat.completions.create(
-    model="grok-4.20",
+    model="grok-4.3",
     messages=messages,
+    reasoning_effort="medium",
 )

Achten Sie besonders auf zwei Punkte:

Reasoning-Latenz: Grok 4.3 führt immer Reasoning aus. Wenn Ihr vorheriger Pfad auf sehr niedrige Latenz optimiert war, testen Sie reasoning_effort="low".
Ausgabeformat: Grok 4.3 erzeugt tendenziell strukturiertere Antworten. Wenn Ihre Nachbearbeitung stark auf Regex basiert, testen Sie alle erwarteten Antwortvarianten.

Für Preisvergleiche mit OpenAI-Modellen siehe GPT-5.5-Preise. Für eine ähnliche API-Integration siehe Wie man die GPT-5.5 API verwendet.

Testen in Apidog

Ein pragmatisches Test-Setup in Apidog:

Erstellen Sie eine Umgebung mit:
- XAI_API_KEY
- BASE_URL = https://api.x.ai/v1
Legen Sie einen Request an:

POST {{BASE_URL}}/chat/completions
Authorization: Bearer {{XAI_API_KEY}}
Content-Type: application/json

Verwenden Sie diesen Body:

{
  "model": "grok-4.3",
  "messages": [
    {
      "role": "system",
      "content": "You are a senior backend engineer."
    },
    {
      "role": "user",
      "content": "Review this API design and identify production risks."
    }
  ],
  "reasoning_effort": "{{REASONING_EFFORT}}"
}

Erstellen Sie drei Varianten:
- REASONING_EFFORT = low
- REASONING_EFFORT = medium
- REASONING_EFFORT = high
Vergleichen Sie:
- Antwortqualität
- Latenz
- usage.prompt_tokens
- usage.completion_tokens
- usage.reasoning_tokens
- usage.total_tokens
Optional: Erstellen Sie eine vierte Variante mit OpenAI-Base-URL, um bei identischem Prompt ein Vergleichsmodell zu testen.

Laden Sie Apidog herunter, um diese Varianten als wiederholbare API-Tests zu speichern. Für eine breitere Teststrategie siehe API-Testtool für QA-Ingenieure.

Ratenbegrenzungen und Backoff

Die konkreten Tier-Limits ändern sich und sollten in der xAI-Konsole geprüft werden. xAI nennt ungefähr 159 Tokens/Sekunde als Ausgabegeschwindigkeit pro Stream. Das ist nicht dasselbe wie ein globaler Aggregatdurchsatz.

Wenn Sie ein Rate Limit erreichen, gibt die API einen 429-Fehler mit retry-after zurück. Implementieren Sie exponentiellen Backoff:

import time
from openai import RateLimitError

def call_with_backoff(fn, max_retries=5):
    delay = 1

    for attempt in range(max_retries):
        try:
            return fn()
        except RateLimitError:
            if attempt == max_retries - 1:
                raise

            time.sleep(delay)
            delay *= 2

Verwendung:

response = call_with_backoff(
    lambda: client.chat.completions.create(
        model="grok-4.3",
        messages=[
            {
                "role": "user",
                "content": "Summarize this incident report."
            }
        ],
        reasoning_effort="medium",
    )
)

FAQ

Ist Grok 4.3 Ende-zu-Ende OpenAI-kompatibel?

Für Chat Completions: ja. Sie können das OpenAI SDK verwenden, base_url ändern und model="grok-4.3" setzen. Funktionsaufrufe, strukturierte Ausgabe und Streaming folgen der OpenAI-kompatiblen Form.

Unterstützt Grok 4.3 die Responses API?

Die xAI-Schnittstelle ist aktuell Chat Completions. Die Responses API ist nur für OpenAI verfügbar.

Was ist das tatsächliche Kontextlimit?

1.000.000 Tokens. Lange Eingaben verursachen auch bei 1,25 $ pro 1M Tokens reale Kosten. Verwenden Sie Caching, wenn große Promptteile stabil bleiben.

Wie beeinflusst Reasoning die Latenz?

Die Latenz bis zum ersten Token kann höher sein als bei Modellen ohne Reasoning. Danach streamt Grok 4.3 mit ungefähr 159 Tokens/Sekunde. Für Genauigkeits- und Agenten-Workloads ist der Trade-off häufig sinnvoll.

Kann ich Grok 4.3 mit Grok Voice verwenden?

Ja. Der Sprachagent grok-voice-think-fast-1.0 ruft Grok 4.3 im Hintergrund auf, wenn Reasoning benötigt wird. Sie können Grok 4.3 auch direkt aus einer eigenen Sprachschleife mit TTS- und STT-Komponenten aufrufen.

Was passiert mit alten Grok-3- oder Grok-4-Aufrufen nach dem 15. Mai?

Sie schlagen mit einem 410-Fehler fehl, weil das Modell eingestellt wurde. Migrieren Sie vorher auf grok-4.3.

Unterstützt Grok 4.3 Bildeingabe?

Ja. Zusätzlich zur neuen Videoeingabe können Sie Bild-URLs als Inhaltsblock übergeben, analog zur OpenAI-kompatiblen Form.

Zusammenfassung

Grok 4.3 ist für Entwickler vor allem wegen OpenAI-kompatibler Integration, 1M-Kontext, durchgängigem Reasoning, nativer Videoeingabe und niedrigeren Kosten interessant. Für bestehende Grok-Integrationen ist die Migration meist klein: model ändern, optional reasoning_effort setzen und reale Prompts erneut testen.

Der schnellste Validierungspfad: Legen Sie in Apidog drei Varianten mit low, medium und high an, messen Sie Latenz und usage.reasoning_tokens, und migrieren Sie vor dem 15. Mai.

Grok Voice Kostenlos Nutzen: Konsolen Einrichtung, Stimmklonung & Echtzeit Sprachagenten

Emre Demir — Fri, 08 May 2026 07:34:10 +0000

xAI hat Grok Voice mit Grok 4.3 ausgeliefert. Für Entwickler ist der wichtigste Punkt: Der Zugriff ist in der xAI Console kostenlos verfügbar. Es gibt keine Kosten pro Minute und keine separaten Token-Kosten für das Sprachagentenmodell, Text-to-Speech, Speech-to-Text oder Custom-Voices-Klonen. Abgerechnet wird nur die zugrunde liegende Grok-4.3-Token-Nutzung, wenn der Agent Reasoning ausführt; dafür gibt es in der Console eine eigene kostenlose Freigrenze zum Testen.

Testen Sie Apidog noch heute

Dieser Leitfaden zeigt praktisch, wie Sie Grok Voice einrichten, eine eigene Stimme klonen, eine WebSocket-Sitzung starten und den Ablauf mit Apidog testen, bevor Sie ihn in ein Produkt integrieren.

Wenn Sie zusätzlich den umfassenderen Grok 4.3 API-Leitfaden oder einen direkten Vergleich mit OpenAIs Stack in Grok Voice vs. GPT-Realtime benötigen, decken diese begleitenden Beiträge den Rest der Oberfläche ab.

Kurz gesagt

Grok Voice ist für Benutzer der xAI Console (console.x.ai) kostenlos nutzbar.
Keine Gebühr pro Minute oder pro Token für TTS, STT, Sprachagenten oder benutzerdefinierte Stimmen.
Flaggschiff-Modell: grok-voice-think-fast-1.0.
Zeit bis zum ersten Audio: unter 1 Sekunde; xAI gibt an, dass es ungefähr 5x schneller als der nächste Wettbewerber ist.
Über 80 voreingestellte Stimmen in 28 Sprachen.
5 integrierte Sprachagenten-Personas: Eve, Ara, Rex, Sal und Leo.
Benutzerdefiniertes Stimmenklonen aus etwa 1 Minute Sprache; produktionsreife Stimme in unter 2 Minuten.
WebSocket-Endpunkt:

wss://api.x.ai/v1/realtime?model=grok-voice-think-fast-1.0

REST-Endpunkte für TTS, STT und Custom Voices teilen sich eine API-Oberfläche.
Verwenden Sie Apidog, um WebSocket-Sitzungen zu skripten und ohne erneute Audioaufnahme zu reproduzieren.

Was Grok Voice kostenlos bietet

Der kostenlose Zugriff läuft über die xAI Console. Melden Sie sich unter console.x.ai an, generieren Sie einen API-Schlüssel und verwenden Sie damit vier Oberflächen:

Verfügbare Oberflächen

Sprachagent: Echtzeit-Sprache-zu-Sprache mit Tool-Nutzung, serverseitiger Spracherkennungsaktivität und integriertem Turn-Taking.
Text-to-Speech: Über 80 voreingestellte Stimmen in 28 Sprachen, Ausgabe als MP3 oder μ-law für Telefonie.
Speech-to-Text: Streaming- und Batch-Transkription in 25 Eingabesprachen, inklusive Wortzeitstempeln und Sprechererkennung.
Benutzerdefinierte Stimmen: Klonen einer Stimme aus einer kurzen Stichprobe. Die resultierende voice_id funktioniert für TTS und den Sprachagenten.

Der einzige relevante Verbrauchszähler ist die Grok-4.3-Token-Nutzung, wenn der Agent Reasoning ausführt. Die Console stellt dafür kostenlose Credits bereit, sodass Sie End-to-End-Flows validieren können, bevor Abrechnung relevant wird.

Schritt 1: API-Schlüssel in der Console erstellen

Öffnen Sie console.x.ai.
Melden Sie sich mit Ihrem X-Konto an.
Wechseln Sie zur Seite API-Schlüssel.
Erstellen Sie einen neuen Schlüssel.
Aktivieren Sie die Bereiche voice und chat.
Speichern Sie den Schlüssel lokal als Umgebungsvariable:

export XAI_API_KEY="xai-..."

Für serverseitige Tests reicht dieser Schlüssel aus.

Für Browser-Anwendungen sollten Sie den Hauptschlüssel nicht an den Client ausliefern. Erstellen Sie stattdessen ein ephemeres Token über die Console-Einstellungen oder über den Endpunkt:

/v1/realtime/sessions

Ephemere Token haben denselben Umfang, laufen aber nach wenigen Minuten ab. Damit kann ein Browser direkt mit dem WebSocket-Endpunkt verbunden werden, ohne den übergeordneten API-Schlüssel offenzulegen.

Schritt 2: Stimme auswählen

Sie haben zwei Optionen: voreingestellte Stimmen oder benutzerdefinierte Stimmklone.

Option A: Voreingestellte Stimmen verwenden

Der Sprachagent enthält fünf benannte Personas:

Stimme	Beschreibung	Geeignete Verwendung
`eve`	weiblich, energisch	positive Support-Flows
`ara`	weiblich, warm	allgemeine Unterstützung
`rex`	männlich, selbstbewusst	Verkaufsgespräche
`sal`	neutral, sanft	Erzählungen und längere Lesungen
`leo`	männlich, autoritär	Compliance und formale Abläufe

Für die breitere TTS-API gibt es zusätzlich über 80 Stimmen in 28 Sprachen. Diese werden über den voice-Parameter am TTS-Endpunkt ausgewählt.

Option B: Eigene Stimme klonen

Für einen benutzerdefinierten Stimmklon laden Sie eine WAV-Datei mit etwa einer Minute sauberer Sprache eines einzelnen Sprechers hoch:

curl https://api.x.ai/v1/custom-voices \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -F "name=narrator-jane" \
  -F "language=en" \
  -F "audio=@sample.wav"

Die Antwort enthält eine voice_id, die Sie anschließend sowohl für TTS als auch für den Sprachagenten verwenden können.

Praktische Hinweise für bessere Ergebnisse:

Verwenden Sie einen ruhigen Raum.
Nehmen Sie eine einzelne Stimme auf.
Vermeiden Sie Hintergrundmusik.
Verwenden Sie einen konsistenten Abstand zum Mikrofon.
Nutzen Sie einen einzelnen Take statt zusammengeschnittener Clips.

Die maximale Länge des Referenzclips beträgt 120 Sekunden. Sauberes Audio ist wichtiger als maximale Länge.

Schritt 3: WebSocket-Sitzung starten

Der Sprachagent läuft über eine einzelne WebSocket-Verbindung:

WebSocket öffnen.
Sitzung konfigurieren.
Audio als Frames senden.
Audio-Deltas als Antwort empfangen.
Verbindung für weitere Gesprächsrunden offen halten.

Minimaler Node.js-Client:

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.x.ai/v1/realtime?model=grok-voice-think-fast-1.0",
  {
    headers: {
      Authorization: `Bearer ${process.env.XAI_API_KEY}`,
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "ara",
      instructions: "You are a friendly support agent. Keep replies under two sentences.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: {
        type: "server_vad",
      },
    },
  }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());

  if (event.type === "response.audio.delta") {
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }

  if (event.type === "response.audio.done") {
    console.error("Audio response finished");
  }
});

Benutzeraudio senden Sie als Base64-kodierte PCM16-Frames über input_audio_buffer.append-Ereignisse.

Der Server sendet während der Antwort:

response.audio.delta

Wenn die Runde beendet ist, folgt:

response.audio.done

Für Browser- und Desktop-Anwendungen ist PCM16 bei 24 kHz ein sicherer Standard. Für Telefonie verwenden Sie μ-law.

Schritt 4: Tool-Nutzung aktivieren

Der Sprachagent unterstützt Funktionsaufrufe. Dadurch kann das Modell während eines Gesprächs Ihre APIs verwenden.

Beispiel: Ein Tool zum Abrufen eines Bestellstatus deklarieren.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "function",
        name: "lookup_order",
        description: "Look up the status of a customer order by order number.",
        parameters: {
          type: "object",
          properties: {
            order_id: {
              type: "string",
            },
          },
          required: ["order_id"],
        },
      },
    ],
  },
}));

Wenn das Modell das Tool aufrufen möchte, erhalten Sie ein Ereignis wie:

response.function_call_arguments.done

Implementieren Sie dann auf Ihrer Seite den eigentlichen API-Aufruf und senden Sie das Ergebnis als conversation.item.create mit dem Typ function_call_output zurück.

Der Ablauf sieht so aus:

Modell erkennt, dass externe Daten benötigt werden.
Modell gibt Funktionsargumente aus.
Ihre Anwendung führt die Funktion aus.
Ihre Anwendung sendet das Ergebnis zurück.
Das Modell setzt die Antwort fort und spricht das Ergebnis aus.

Zusätzlich ist ein integriertes web_search-Tool verfügbar. Das ist hilfreich, wenn Antworten mit aktuellen Daten angereichert werden sollen, ohne direkt eine eigene Retrieval-Schicht zu bauen.

Schritt 5: Text-to-Speech ohne Sprachagent verwenden

Wenn Sie nur Audio aus Text generieren möchten, benötigen Sie keine WebSocket-Sitzung. Verwenden Sie stattdessen den REST-Endpunkt für TTS.

Beispiel:

curl https://api.x.ai/v1/tts \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-tts-1",
    "voice": "ara",
    "input": "Welcome back to your account. Your last login was Tuesday at 3pm.",
    "format": "mp3"
  }' \
  --output greeting.mp3

Verfügbare Ausgabeformate:

mp3: High-Fidelity-Ausgabe
mulaw: 8 kHz, geeignet für Telefonie

Der Endpunkt ist synchron. Sie senden Text und erhalten Audiodaten zurück. Eine Streaming-Sitzung ist dafür nicht erforderlich.

Schritt 6: WebSocket-Flow in Apidog testen

WebSocket-APIs sind im Terminal schwer zu debuggen, weil die Konversation zustandsbehaftet ist. Ein reproduzierbarer Test-Flow hilft besonders bei Voice-Agents, da kleine Änderungen an Stimme, Prompt oder Turn-Taking das Verhalten beeinflussen können.

Ein praktisches Setup:

Erstellen Sie in Apidog eine neue WebSocket-Anfrage.
Speichern Sie die WebSocket-URL:

wss://api.x.ai/v1/realtime?model=grok-voice-think-fast-1.0

Legen Sie XAI_API_KEY als Umgebungsvariable an.
Fügen Sie den Authorization-Header hinzu:

Authorization: Bearer {{XAI_API_KEY}}

Erstellen Sie ein Nachrichtenskript mit:
- session.update
- input_audio_buffer.append
- response.create
Verwenden Sie einen Fixture-Audioframe, damit Tests reproduzierbar bleiben.
Erfassen Sie alle Serverereignisse als Baum.
Vergleichen Sie mehrere Durchläufe, wenn Sie Stimme oder Instruktionen ändern.

Das ist besonders nützlich, um Unterschiede im Turn-Taking-Verhalten, in der Latenz oder in der Audioausgabe sichtbar zu machen.

Laden Sie Apidog herunter, erstellen Sie eine neue WebSocket-Anfrage und speichern Sie Ihren XAI_API_KEY in den Umgebungsvariablen. Dieselbe Sammlung kann auch REST-Endpunkte für TTS und STT enthalten, sodass WebSocket- und REST-Tests in einem Projekt bleiben.

Weitere Testmuster für zustandsbehaftete APIs finden Sie im Beitrag API-Test-Tool für QA-Ingenieure.

Limits des kostenlosen Tarifs

Die Console bietet Zugriff ohne Gebühren pro Minute oder separate Token-Gebühren für die Sprachfunktionen selbst. Trotzdem gibt es Grenzen, die Sie beim Prototyping berücksichtigen sollten.

Ratenbegrenzungen

Die Console erzwingt Anfragen-pro-Minute-Grenzen pro Endpunkt, um Missbrauch zu verhindern. Diese reichen für Tests, Demos und Prototypen aus, sind aber keine Produktionsfreigabe.

Wenn Sie Rate-Limit-Fehler erhalten:

Anfragen bündeln
weniger parallele Sessions starten
Audio-Frames effizienter senden
auf einen kostenpflichtigen Tarif wechseln

Das API-Verhalten bleibt gleich; nur die Obergrenzen ändern sich.

Kontingent für benutzerdefinierte Stimmen

Ein einzelnes Konto kann nur eine begrenzte Anzahl benutzerdefinierter Stimmklone gleichzeitig speichern. Wenn ein Slot benötigt wird, löschen Sie eine nicht mehr benötigte Stimme und erstellen Sie den Klon erneut.

Reasoning-Tokens

Wenn der Sprachagent im Hintergrund Grok 4.3 für Reasoning nutzt, wird diese Token-Nutzung Ihrem Konsolenguthaben angerechnet. Das kostenlose Guthaben reicht für Prototyping; für Produktion ist ein kostenpflichtiger Plan erforderlich.

Stimmen vor dem Live-Gang vergleichen

Testen Sie jede Stimme mit denselben Beispielsätzen, bevor Sie sie produktiv verwenden. Stimmen unterscheiden sich in Ton, Intonation und Eignung für bestimmte Use Cases.

Eine kurze Testliste reicht oft aus:

Eine zweiseitige Begrüßung.
Eine Bestätigungsphrase wie: „Verstanden, das ist alles erledigt.“
Ein langer Satz mit Zahl, Datum und Komma.

Ein modellunabhängiger Test:

Schreiben Sie einen kurzen Prompt.
Lassen Sie ihn mit derselben Stimme in drei Gesprächssituationen erzeugen:
- ruhig
- normal
- dringend
Hören Sie auf Intonation, Tempo und Natürlichkeit.
Wiederholen Sie den Test mit zwei bis drei anderen Stimmen.

Groks voreingestellte Stimmen bewältigen solche Varianten besser als viele TTS-Engines, die wir getestet haben. Trotzdem sollte diese Prüfung vor dem Live-Gang Teil Ihres Voice-QA-Prozesses sein.

FAQ

Ist die API tatsächlich kostenlos, oder gibt es eine versteckte Obergrenze?

Die Sprachfunktionen TTS, STT, Sprachagent und Custom Voices sind in der Console ohne Gebühren pro Minute oder separate Token-Gebühren nutzbar. Das zugrunde liegende Reasoning-Modell wird über das Konsolenguthaben abgerechnet. Die kostenlose Freigrenze reicht für Prototyping.

Benötige ich ein X-Konto?

Ja. Für die Anmeldung an der xAI Console wird ein X-Konto verwendet.

Kann ich Grok Voice im Browser verwenden?

Ja. Verwenden Sie dafür ein ephemeres Token.

Der empfohlene Ablauf:

Ihr Server erstellt ein kurzlebiges Token über /v1/realtime/sessions.
Der Browser erhält nur dieses ephemere Token.
Der Browser öffnet direkt die WebSocket-Verbindung.
Der Haupt-API-Schlüssel bleibt auf Ihrem Server.

Welche Audioqualität kann ich erwarten?

Die TTS-Ausgabe ist hochauflösendes MP3 oder 8 kHz μ-law. Der Sprachagent verwendet intern PCM16 bei 24 kHz. Die Qualität ist vergleichbar mit großen kommerziellen TTS-Engines; die Latenz ist das wichtigste Unterscheidungsmerkmal.

Funktioniert Grok Voice mit Telefonie?

Ja. Die μ-law-Ausgabe ist das Standardformat für SIP- und PSTN-Brücken. Sie benötigen weiterhin einen SIP-Anbieter, da xAI derzeit kein eigenes SIP-Gateway bereitstellt.

Wie gut ist die Qualität beim Stimmenklonen?

Die Qualität hängt stärker von der Referenzaufnahme als von der Länge ab. Eine saubere 60-Sekunden-Aufnahme in einem ruhigen Raum ist in der Praxis besser als eine verrauschte 120-Sekunden-Aufnahme. Die resultierende voice_id kann sowohl mit dem TTS-Endpunkt als auch mit dem Sprachagenten genutzt werden.

Kann ich Grok Voice für KI-Charaktere in einem Spiel verwenden?

Ja. Der TTS-Endpunkt ist schnell genug für Laufzeitgenerierung, und Custom Voices ermöglichen eigene Stimmen pro Charakter. Achten Sie bei langen Zeilen auf die Latenz; chunked TTS ist dafür das passende Muster.

Zusammenfassung

Grok Voice ist 2026 ein direkter Weg zu einem kostenlosen Echtzeit-Sprachagenten. Die Console erhebt keine Gebühr pro Minute für Sprachfunktionen, die Latenz ist niedrig, und Custom Voices reduzieren den Aufwand für individuelle Sprachoberflächen.

Der schnellste Validierungsweg:

API-Schlüssel in der xAI Console erstellen.
Eine voreingestellte Stimme auswählen.
WebSocket-Sitzung starten.
Einen reproduzierbaren Test in Apidog skripten.
Drei Stimmen mit denselben Prompts vergleichen.
Erst danach Browser-, App- oder Telefonie-Integration bauen.

Wenn Sie Grok Voice mit der Grok-4.3-Reasoning-Engine kombinieren möchten, lesen Sie den Grok 4.3 API-Leitfaden. Für einen direkten Vergleich mit OpenAIs Stack siehe Grok Voice vs. GPT-Realtime.

GPT-Realtime-2: Was ist das & GPT-Realtime-2 API nutzen

Emre Demir — Fri, 08 May 2026 07:30:37 +0000

OpenAI hat am 6. November 2026 eine neue Generation von Sprachmodellen veröffentlicht. Die wichtigste Neuerung ist gpt-realtime-2: ein Sprach-zu-Sprach-Modell mit GPT-5-Klasse-Reasoning, 128.000 Token Kontextfenster und konfigurierbarem Reasoning-Aufwand. Wenn Sie bereits gpt-realtime integriert haben, ist die Migration im Kern ein Modellstring-Wechsel plus einige neue Sitzungs- und Tool-Felder.

Teste Apidog noch heute

Dieser Leitfaden zeigt, was GPT-Realtime-2 ist, was sich gegenüber dem Vorgängermodell geändert hat, wie die Preise aussehen und wie Sie das Modell per WebSocket oder SIP anbinden. Zusätzlich richten wir ein testbares Setup in Apidog ein, damit Sie Realtime-Sitzungen reproduzierbar wiedergeben können, ohne Audio jedes Mal neu aufzunehmen.

Für den Kontext zu OpenAIs breiterer Modelllinie 2026 siehe Was ist GPT-5.5. Für das multimodale Geschwistermodell siehe Wie man die GPT-Image-2 API verwendet.

TL;DR

gpt-realtime-2 ist OpenAIs Flaggschiffmodell für Sprach-zu-Sprach-Anwendungen mit GPT-5-Klasse-Reasoning, 128k Kontext und 32k maximalen Ausgabetoken.
Audiopreise: 32 $ pro 1 Mio. Eingabetoken und 64 $ pro 1 Mio. Ausgabetoken. Zwischengespeicherte Eingaben kosten 0,40 $ pro 1 Mio. Token.
Neue Stimmen: Cedar und Marin, exklusiv für die Realtime API. Acht bestehende Stimmen wurden überarbeitet.
Reasoning-Stufen: minimal, low, medium, high, xhigh. Standard ist low.
WebSocket-Endpunkt: wss://api.openai.com/v1/realtime?model=gpt-realtime-2.
SIP wird für eingehende Telefonanrufe unterstützt.
Begleitmodelle: GPT-Realtime-Translate für Live-Übersetzung und GPT-Realtime-Whisper für Streaming-STT.
Nutzen Sie Apidog, um WebSocket-Sitzungen zu skripten, Frames zu erfassen und Läufe zu vergleichen.

Was ist GPT-Realtime-2?

GPT-Realtime-2 ist ein End-to-End-Sprach-zu-Sprach-Modell. Sie streamen Audio hinein, erhalten Audio zurück, und das Modell übernimmt Transkription, Reasoning, Tool-Auswahl und Sprachgenerierung in einem Durchlauf.

Das ersetzt die klassische Pipeline:

Speech-to-Text → LLM → Text-to-Speech

durch eine direkte Realtime-Sitzung:

Audio/Text/Bild → GPT-Realtime-2 → Audio/Text

Das Modell akzeptiert Text, Audio und Bilder als Eingabe und gibt Text sowie Audio aus. Neu ist die Bildeingabe: Sie können während einer Live-Konversation etwa einen Screenshot oder ein Foto übergeben und den Agenten laut dazu befragen.

Typische Anwendungsfälle:

Voice-Support-Agenten mit Tool-Zugriff
Sprach-Copiloten, die Screenshots oder Fotos analysieren
Telefonagenten über SIP
Live-Übersetzungs- und Assistenzsysteme
Barrierefreiheits- und Screen-Reader-ähnliche Anwendungen

Spezifikationen

Attribut	Wert
Modell-ID	`gpt-realtime-2`
Kontextfenster	128.000 Token
Max. Ausgabe	32.000 Token
Eingabe-Modalitäten	Text, Audio, Bild
Ausgabe-Modalitäten	Text, Audio
Wissensgrenze	30.09.2024
Reasoning-Stufen	`minimal`, `low`, `medium`, `high`, `xhigh`
Funktionsaufruf	Ja
Remote MCP-Server	Ja
Bildeingabe	Ja
SIP-Telefonanruf	Ja

Was sich gegenüber `gpt-realtime` geändert hat

Gegenüber gpt-realtime-1.5 verbessert gpt-realtime-2 laut den veröffentlichten Benchmarks vor allem Audio-Intelligenz und Anweisungsbefolgung:

Big Bench Audio: 81,4 % → 96,6 %
Audio MultiChallenge: 34,7 % → 48,5 %

Diese Werte wurden mit high und xhigh Reasoning erzielt. Für Produktionsanwendungen ist low der Standard, weil es geringere Latenz bietet.

Wichtige Verhaltensänderungen:

Preambeln: Das Modell kann kurze Übergangssätze wie „Ich prüfe das kurz“ ausgeben, während es Reasoning oder Tool-Aufrufe vorbereitet.
Parallele Tool-Aufrufe: Mehrere Tools können gleichzeitig gestartet werden, während das Modell den Fortschritt per Audio erklärt.
Bessere Wiederherstellung: Mehrdeutige oder teilweise fehlgeschlagene Abläufe werden stabiler fortgesetzt.
Domänen-Tonsteuerung: Fachterminologie und gewünschter Sprachstil bleiben über längere Sitzungen konsistenter.

Das Kontextfenster wächst von 32k auf 128k Token. Das ist relevant für lange Support-, Banking-, Lern- oder Beratungs-Sitzungen, in denen das Modell über viele Minuten Kontext behalten muss.

Preise

GPT-Realtime-2 wird pro Token abgerechnet. Text, Audio und Bild haben separate Tarife.

Token-Typ	Eingabe	Zwischengespeicherte Eingabe	Ausgabe
Text	4,00 $ / 1 Mio.	0,40 $ / 1 Mio.	24,00 $ / 1 Mio.
Audio	32,00 $ / 1 Mio.	0,40 $ / 1 Mio.	64,00 $ / 1 Mio.
Bild	5,00 $ / 1 Mio.	0,50 $ / 1 Mio.	n. z.

Zwischengespeicherte Eingaben sind besonders wichtig, wenn Ihr Agent mit einem stabilen Systemprompt, festen Richtlinien oder wiederverwendbaren Dokumenten arbeitet. Halten Sie diesen Kontext cache-freundlich, um wiederholte Eingaben günstiger zu machen.

Zum Vergleich mit der restlichen OpenAI-Modelllinie siehe GPT-5.5-Preise.

Die Begleitmodelle werden pro Minute abgerechnet:

GPT-Realtime-Translate: 0,034 $ pro Minute. Unterstützt 70 Eingabesprachen und 13 Ausgabesprachen.
GPT-Realtime-Whisper: 0,017 $ pro Minute. Streaming-Sprach-zu-Text für Live-Untertitel und kontinuierliche Transkription.

Faustregel:

Verwenden Sie GPT-Realtime-2, wenn Reasoning und Sprachausgabe zusammen benötigt werden.
Verwenden Sie GPT-Realtime-Translate für Live-Übersetzung.
Verwenden Sie GPT-Realtime-Whisper, wenn Sie nur ein Transkript benötigen.

Endpunkte und Authentifizierung

GPT-Realtime-2 ist über mehrere Endpunkte erreichbar:

POST https://api.openai.com/v1/chat/completions
POST https://api.openai.com/v1/responses
WSS  wss://api.openai.com/v1/realtime?model=gpt-realtime-2
WSS  wss://api.openai.com/v1/realtime?call_id={call_id}
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions

Für Sprachagenten ist der WebSocket-Endpunkt relevant:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

Authentifizierung:

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1

Setzen Sie Ihren API-Key als Umgebungsvariable:

export OPENAI_API_KEY="sk-proj-..."

Verbindung über WebSocket

Ein minimaler Node.js-Client:

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime?model=gpt-realtime-2",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Beta": "realtime=v1",
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "cedar",
      instructions: "You are a friendly support agent for a fintech app.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: { type: "server_vad" },
      reasoning: { effort: "low" },
    },
  }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());

  if (event.type === "response.audio.delta") {
    // base64 PCM16 Audio-Chunk.
    // In der Praxis an Lautsprecher, Browser oder Telefon-Bridge weiterleiten.
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }
});

Die Realtime API ist ereignisgesteuert:

Client öffnet WebSocket.
Client sendet session.update.
Client streamt Audio mit input_audio_buffer.append.
Server erkennt Gesprächsgrenzen per VAD.
Server sendet Audio mit response.audio.delta.
Client spielt Audio ab oder leitet es weiter.

PCM16 bei 24 kHz ist ein sicherer Standard. Für Telefonie sind auch G.711 mu-law und A-law relevant.

Wenn Sie die Realtime-Oberfläche mit der Responses API vergleichen möchten, siehe Wie man die GPT-5.5 API verwendet.

Stimmen

Mit dieser Version gibt es zwei neue Stimmen:

Cedar: Warme, mitteltiefe männliche Stimme. Geeignet für allgemeine Agenten.
Marin: Helle, klare weibliche Stimme. Geeignet für Übersetzungen und Ansagen.

Beide sind exklusiv für die Realtime API.

Bestehende Stimmen bleiben verfügbar:

alloy
ash
ballad
coral
echo
sage
shimmer
verse

Sie können die Stimme während einer laufenden Sitzung wechseln:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    voice: "marin",
  },
}));

Bildeingabe

Sie können einem Benutzerbeitrag ein Bild hinzufügen. Das Modell kann das Bild in der laufenden Sprachsitzung berücksichtigen.

Beispiel:

ws.send(JSON.stringify({
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_image",
        image_url: "https://example.com/screenshot.png",
      },
      {
        type: "input_text",
        text: "What does this error mean?",
      },
    ],
  },
}));

ws.send(JSON.stringify({ type: "response.create" }));

Praktische Muster:

Sprachgesteuerte QA: Tester zeigt eine fehlerhafte UI per Kamera; der Agent beschreibt den Fehler und formuliert einen Bugreport.
Vor-Ort-Support: Techniker teilt ein Foto einer Verkabelung; der Agent führt durch die Diagnose.
Barrierefreiheit: Der Agent beschreibt den aktuellen Bildschirm während eines Support-Anrufs.

Mehr zum Bild-Stack: Wie man die GPT-Image-2 API verwendet.

Funktionsaufruf und MCP

GPT-Realtime-2 unterstützt klassische Funktionstools und Remote-MCP-Server in derselben Sitzung.

Standard-Funktionsaufrufe

Der Ablauf ähnelt Chat Completions:

Tools in der Sitzung deklarieren.
Modell sendet Funktionsargumente als Events.
Anwendung führt die Funktion aus.
Anwendung sendet das Ergebnis als function_call_output zurück.

Konzeptionell:

session.update → tools deklarieren
response.function_call_arguments.delta → Argumente empfangen
Tool ausführen
conversation.item.create → function_call_output senden

Neu ist, dass das Modell mehrere Tool-Aufrufe parallel auslösen kann. Das ist nützlich für Sprachagenten, die beispielsweise gleichzeitig Kontostand, letzte Transaktionen und Supportstatus abrufen.

Remote MCP-Server

Bei Remote MCP konfigurieren Sie einen MCP-Server direkt in der Sitzung. Die Realtime API kann dann erlaubte Tools über diesen Server verwenden.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [
      {
        type: "mcp",
        server_url: "https://mcp.example.com/sse",
        allowed_tools: [
          "lookup_account",
          "list_transactions",
        ],
      },
    ],
  },
}));

Das reduziert die eigene Event-Loop-Logik, wenn Ihr Agent viele Tools anbinden muss.

Wenn Sie MCP-Server vor der Integration testen möchten, siehe MCP-Server-Test in Apidog.

SIP-Telefonanrufe

GPT-Realtime-2 kann über SIP in Telefonie-Workflows eingebunden werden.

Grundidee:

SIP-Trunk an OpenAIs SIP-Gateway weiterleiten.
Eingehender Anruf erzeugt eine Realtime-Sitzung.
Anwendung verbindet sich per WebSocket mit:

wss://api.openai.com/v1/realtime?call_id={call_id}

Das Modell akzeptiert G.711 mu-law und A-law direkt. Dadurch müssen Telefonie-Bridges nicht zwingend transkodieren.

Das ist besonders relevant für Callcenter-Agenten, die während eines Gesprächs Tools ausführen, Daten nachschlagen oder MCP-Server verwenden.

Reasoning-Stufen

Die Reasoning-Stufe steuert den Kompromiss zwischen Latenz und Antwortqualität.

Stufe	Anwendungsfall	Ungefähre Latenzkosten
`minimal`	Einfache Ja/Nein-Antworten	Keine
`low`	Standard; Support und Chat	Gering
`medium`	Disambiguierung, komplexerer Tool-Dispatch	Moderat
`high`	Mehrstufiges Reasoning, Code-Review per Sprache	Hoch
`xhigh`	Benchmarks, schwierige analytische Fragen	Höchste

Standard ist:

reasoning: { effort: "low" }

Starten Sie in Produktion mit low. Erhöhen Sie die Stufe nur, wenn Sie konkret messen, dass die Antwortqualität nicht ausreicht.

Testen der Realtime API in Apidog

WebSocket-APIs sind im Terminal schwer zu debuggen, weil Sitzungen zustandsbehaftet sind. Mit Apidog können Sie Realtime-Flows reproduzierbar testen.

Praktisches Setup:

Neue WebSocket-Anfrage erstellen.
URL setzen:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2

Header hinzufügen:

Authorization: Bearer {{OPENAI_API_KEY}}
OpenAI-Beta: realtime=v1

session.update als erste Nachricht speichern:

{
  "type": "session.update",
  "session": {
    "voice": "cedar",
    "instructions": "You are a concise technical support agent.",
    "input_audio_format": "pcm16",
    "output_audio_format": "pcm16",
    "turn_detection": {
      "type": "server_vad"
    },
    "reasoning": {
      "effort": "low"
    }
  }
}

Danach Testnachrichten wie conversation.item.create, input_audio_buffer.append und response.create ausführen.
Serverevents erfassen und zwischen Läufen vergleichen.

Laden Sie Apidog herunter, erstellen Sie eine WebSocket-Anfrage und speichern Sie API-Key, Voice und Modell als Umgebungsvariablen. So können Sie dieselbe Sitzung mit unterschiedlichen Reasoning-Stufen oder Stimmen wiederholen.

Zum Vergleich mit einem anderen schnellen multimodalen Modell siehe Wie man die Gemini 3 Flash Preview API verwendet.

FAQ

Welche Modell-ID soll ich verwenden?

Verwenden Sie:

gpt-realtime-2

Das frühere Modell ist weiterhin als gpt-realtime verfügbar, falls Sie ein Rollback benötigen. Für die Lite-Version ist auch gpt-realtime-2-mini live.

Kann ich Audio-Eingabe streamen, während Audio-Ausgabe abgespielt wird?

Ja. Die Realtime API nutzt standardmäßig serverseitige Voice Activity Detection. Das Modell kann aufhören zu sprechen, wenn der Benutzer beginnt. Sie können VAD deaktivieren und Gesprächsgrenzen clientseitig steuern.

Umfasst der 128k-Kontext Audio-Token?

Ja. Audio wird tokenisiert. Eine Sekunde Audio entspricht je nach Format etwa 50 Token. Lange Supportanrufe verbrauchen Kontext schneller als reine Textchats.

Wird Fine-Tuning unterstützt?

Noch nicht. Laut Modellkarte unterstützt GPT-Realtime-2 derzeit kein Fine-Tuning, keine vorhergesagten Ausgaben und kein Textstreaming bei Chat Completions. Der Realtime-Endpunkt streamt Audio nativ.

Wie unterscheidet sich GPT-Realtime-2 von GPT-5.5 mit TTS?

GPT-Realtime-2 verarbeitet Sprache End-to-End. Es kann Tonfall, Zögern und Betonung direkt berücksichtigen. Ein Textmodell mit separater TTS-Schicht verliert diese Signale.

Für reines Text-Reasoning siehe Wie man die GPT-5.5 API verwendet.

Welche Ratenbegrenzungen gelten?

Tier 1 beginnt bei 40.000 Token pro Minute und skaliert bis 15 Millionen TPM bei Tier 5. Ratenbegrenzungen gelten pro Modell; bestehende GPT-5-Kontingente werden nicht übertragen.

Zusammenfassung

GPT-Realtime-2 macht Sprachagenten näher an vollwertigen Textagenten: 128k Kontext, GPT-5-Klasse-Reasoning, Bildeingabe, MCP und SIP laufen in einer Realtime-Sitzung zusammen.

Für die Implementierung:

WebSocket mit gpt-realtime-2 öffnen.
session.update mit Stimme, Audioformat, VAD und Reasoning senden.
Audio per input_audio_buffer.append streamen.
Antworten über response.audio.delta abspielen.
Tools oder MCP nur dort hinzufügen, wo der Agent externe Daten benötigt.
Mit low Reasoning starten und nur bei messbarer Qualitätslücke erhöhen.

Der schnellste Weg zum Debugging ist eine gespeicherte WebSocket-Sitzung in Apidog: Headers, Session-Setup, Tool-Konfiguration und Testnachrichten versionieren, wiedergeben und zwischen Läufen vergleichen.

Beste Lokale LLMs 2026: Die Top Sprachmodelle im Vergleich

Emre Demir — Fri, 08 May 2026 06:46:29 +0000

TL;DR

Das „beste“ lokale LLM im Jahr 2026 hängt von VRAM-Budget, Latenzziel und Anwendungsfall ab: Coding, Reasoning, Mehrsprachigkeit oder Vision.
Für 24-GB-GPUs sind Qwen 3.6 32B und DeepSeek V4 Flash die stärksten Allrounder.
Für 8 GB und darunter sind Gemma 4 9B und Llama 5.1 8B die Favoriten.
Für reine Reasoning- oder Coding-Workloads führen DeepSeek V4 Pro quantisiert oder GLM 5 die offene Rangliste an.
Verwenden Sie Ollama oder LM Studio, um ein lokales Modell mit OpenAI-kompatiblem HTTP-Endpunkt bereitzustellen. Testen Sie diesen anschließend mit Apidog wie eine gehostete API.
Mit Apidog können Sie lokalen Modellverkehr simulieren, wiedergeben und benchmarken, ohne Token-Budget bei einem gehosteten LLM zu verbrauchen.

Dieser Leitfaden reduziert die Auswahl auf die lokalen LLMs, die 2026 praktisch relevant sind. Sie erfahren, welches Modell zu welcher Hardware passt, wie Sie es über einen OpenAI-kompatiblen Endpunkt bereitstellen und wie Sie lokale Modelle mit Apidog testen, als wären sie gehostete APIs. Wenn Sie DeepSeek V4 gezielt lokal ausführen möchten, finden Sie mehr Details im DeepSeek V4 Installationsleitfaden und in der DeepSeek V4 Übersicht.

Apidog noch heute ausprobieren

Warum lokale LLMs 2026 wieder wichtig sind

Vor drei Jahren bedeutete „lokales LLM“ meistens: schlechtere Qualität, mehr Setup-Aufwand und langsame Inferenz. Das gilt nicht mehr. Open-Weight-Modelle haben seit 2024 stark aufgeholt. Bei Reasoning, Coding, Extraktion, Klassifikation und Tool-Calling liegt der Abstand zu gehosteten Modellen oft nur noch im einstelligen Prozentbereich.

Auch die Hardware ist praktischer geworden:

Eine 24-GB-Consumer-GPU kann ein 32B-Modell in 4-Bit-Quantisierung ausführen.
Ein Mac Studio mit 64 GB gemeinsamem Speicher kann DeepSeek V4 Flash mit brauchbarer Geschwindigkeit ausführen.
Für Teams mit Anforderungen an Datenresidenz, Kostenkontrolle oder Anbieterunabhängigkeit ist lokale Inferenz keine Forschungsaufgabe mehr.

Die entscheidende Frage lautet daher nicht mehr nur: „Ist das Modell gut genug?“

Sondern: „Wie teste, dokumentiere und betreibe ich den lokalen Endpunkt wie eine Produktions-API?“

Auswahlkriterien

Die Shortlist basiert nicht nur auf Benchmark-Rankings. Wichtig waren diese Kriterien:

Offene Gewichte mit produktionsgeeigneter Lizenz, z. B. MIT, Apache 2.0 oder kompatible Community-Lizenz
Aktive Wartung im Jahr 2026
Bereitstellung über Ollama, vLLM oder LM Studio
OpenAI-kompatibler HTTP-Endpunkt
Stärke in mindestens einem Bereich: Reasoning, Code, Mehrsprachigkeit, Vision oder langer Kontext
Realistische Hardware-Anforderungen für Entwicklerteams

Getestet wurden dieselben acht Prompts auf einer 4090 und einem Mac Studio M3 Ultra. Die Ergebnisse wurden mit der LMSYS Arena und dem Hugging Face Open LLM Leaderboard abgeglichen.

Die lokalen LLMs, die 2026 relevant sind

1. DeepSeek V4 Pro

DeepSeek V4 Pro ist das Flaggschiff der V4-Reihe. Es ist als 4-Bit-GGUF und AWQ auf Hugging Face verfügbar. Das vollständige Modell hat 1,6 Billionen Parameter mit 49 Milliarden aktiven Parametern. Damit liegt es klar im Bereich großer Workstations oder Rechenzentren.

In Q4-Quantisierung benötigt es etwa:

192 GB gemeinsamen Speicher auf einem Mac Studio M3 Ultra
oder 2x 80 GB GPU-Speicher, z. B. H100

Für die meisten Entwickler ist V4 Pro lokal eher ein Spezialfall. Relevant ist es trotzdem, weil kleinere Distillationen viel von seinem Reasoning-Verhalten übernehmen.

Wenn Sie die gleichen Gewichte lieber gehostet nutzen möchten, ist der API-Weg in „Wie man die DeepSeek V4 API verwendet“ beschrieben.

Geeignet für:

Reasoning-intensive Agenten
große lokale Workstations
Teams mit Mac Studio M3 Ultra oder mehreren großen GPUs

Hardware:

192 GB gemeinsamer Speicher
oder 2x 80 GB GPU

Quelle:

DeepSeek V4 Pro GGUF auf Hugging Face

2. DeepSeek V4 Flash

DeepSeek V4 Flash ist die praktischere V4-Variante: 284B Parameter insgesamt, 13B aktiv. In 4-Bit-Quantisierung passt es in 24 GB VRAM und lässt Platz für ein 64K-Kontextfenster.

Auf einer 4090 liegt der Durchsatz bei Langform-Generierung im Test bei durchschnittlich etwa 28 Token pro Sekunde.

Für viele Teams ist V4 Flash das Modell, das tatsächlich lokal läuft. Die Reasoning-Qualität lag in den getesteten Prompts innerhalb von etwa 5 Prozent von V4 Pro. Beim Coding ist es etwas schwächer.

Der DeepSeek V4 Installationsleitfaden zeigt die Einrichtung mit Ollama Schritt für Schritt.

Geeignet für:

lokale Allzweck-Agenten
Coding-Assistenten
RAG-Generatoren
interne Automatisierungen

Hardware:

24 GB VRAM bei Q4
16 GB VRAM bei Q3, mit Qualitätsverlust

Installation mit Ollama:

ollama pull deepseek-v4-flash

Quelle:

DeepSeek V4 Flash auf Hugging Face

3. Qwen 3.6 32B

Qwen ist seit Jahren eine der stabilsten Open-Weight-Modellfamilien. Qwen 3.6 32B passt in Q4-Quantisierung in 24 GB VRAM und schlägt ältere Llama-3-70B-Modelle in vielen Reasoning- und Tool-Calling-Benchmarks.

Besonders stark ist Qwen bei Mehrsprachigkeit. Chinesisch, Japanisch, Koreanisch und Arabisch werden deutlich besser verarbeitet als bei vielen westlich fokussierten Modellen.

Wenn Ihr Produkt international genutzt wird und Sie ein lokales Modell für Reasoning, strukturierte Ausgaben und Mehrsprachigkeit benötigen, ist Qwen 3.6 32B eine sehr gute Wahl.

Geeignet für:

mehrsprachige Produkte
strukturierte Ausgabe
Tool Calling
ausgewogene Qualität bei 24 GB VRAM

Hardware:

24 GB VRAM bei Q4

Installation mit Ollama:

ollama pull qwen3.6:32b

Quelle:

Qwen 3.6 auf Hugging Face

4. GLM 5.1

Die GLM-Reihe von Zhipu AI ist besonders bei Tool Calling und strukturierter Extraktion stark. GLM 5.1 erzielt bei Tool-Calling-Benchmarks unter offenen Modellen Top-Ergebnisse. Nur DeepSeek V4 liegt in vielen Tests darüber.

Coding ist nicht seine stärkste Disziplin. Dafür ist GLM 5.1 gut geeignet für:

Reasoning
Klassifikation
JSON-Ausgabe
strukturierte Datenextraktion
Agenten-Workflows mit Tools

Die lokale Bereitstellung ist über Ollama und vLLM solide.

Geeignet für:

Tool-Calling-Agenten
strukturierte Extraktion
JSON-Modus-Pipelines
interne Automatisierungen mit klaren Schemas

Lokale LLMs wie gehostete APIs bereitstellen

Sobald das Modell läuft, erwartet Ihr Stack meistens keinen lokalen Prozess, sondern einen HTTP-Endpunkt. Deshalb sollten Sie lokale Modelle früh als API behandeln.

2026 sind drei Bereitstellungswege besonders relevant:

Option 1: Ollama

Ollama ist der einfachste Einstieg. Es stellt einen OpenAI-kompatiblen Endpunkt bereit:

ollama serve

Standard-URL:

http://localhost:11434/v1

Für viele Anwendungen reicht es, die Base URL von https://api.openai.com/v1 auf http://localhost:11434/v1 zu ändern.

Option 2: vLLM

vLLM ist die bessere Produktionsoption, wenn Durchsatz und Latenz wichtig sind. Es unterstützt kontinuierliches Batching und stellt ebenfalls eine OpenAI-kompatible API bereit.

Typische Base URL:

http://localhost:8000/v1

Nutzen Sie vLLM, wenn mehrere Nutzer oder Services denselben lokalen Modellserver aufrufen.

Option 3: LM Studio

LM Studio ist die GUI-Option. Sie eignet sich gut für einzelne Entwickler, lokale Tests und schnelle Modellvergleiche. Wenn der lokale Server in den Einstellungen aktiviert ist, stellt LM Studio ebenfalls einen HTTP-Endpunkt bereit.

Das Muster ist in „Wie man DeepSeek V4 kostenlos nutzt“ detailliert beschrieben.

Minimaler Python-Client für ein lokales Modell

Wenn Ihr Modell über Ollama läuft, können Sie den offiziellen OpenAI-Client weiterverwenden:

from openai import OpenAI

client = OpenAI(
    api_key="ollama",  # beliebiger String; Ollama ignoriert den Key
    base_url="http://localhost:11434/v1",
)

resp = client.chat.completions.create(
    model="qwen3.6:32b",
    messages=[
        {
            "role": "user",
            "content": "Fasse die Unterschiede zwischen MoE- und Dense-Modellen in drei Stichpunkten zusammen."
        }
    ],
    temperature=0.3,
)

print(resp.choices[0].message.content)

Für ein anderes Modell ändern Sie nur den Modellnamen:

model="deepseek-v4-flash"

oder:

model="llama5.1:8b"

Die Request-Struktur bleibt gleich.

Lokale Modelle mit Apidog testen

Für den produktiven Einsatz ist Debugging entscheidend. Bei gehosteten Modellen lesen Sie bei Problemen die Statusseite des Anbieters. Bei lokalen Modellen gehört der Fehler Ihnen: Treiber, VRAM, Quantisierung, Modellserver, Streaming, Timeouts und Formatabweichungen.

Apidog behandelt Ihren Ollama- oder vLLM-Endpunkt wie jede andere API.

Praktischer Workflow:

1. Lokalen Endpunkt anlegen

Base URL:

http://localhost:11434/v1

oder bei vLLM:

http://localhost:8000/v1

Endpoint:

POST /chat/completions

2. Standard-Request speichern

Beispiel für OpenAI-kompatible Chat Completions:

{
  "model": "qwen3.6:32b",
  "messages": [
    {
      "role": "user",
      "content": "Extrahiere Firmenname, Betrag und Fälligkeitsdatum aus folgendem Rechnungstext."
    }
  ],
  "temperature": 0.2,
  "max_tokens": 500
}

Speichern Sie solche Requests pro Modell und Use Case:

RAG-Antworten
JSON-Extraktion
Tool Calling
Klassifikation
Coding-Aufgaben
längere Zusammenfassungen

3. Modellantworten vergleichen

Spielen Sie denselben Prompt gegen mehrere Modelle ab:

Qwen 3.6 32B
DeepSeek V4 Flash
GLM 5.1
Llama 5.1 8B
Gemma 4 9B

So erkennen Sie Regressionen, Formatabweichungen oder Qualitätsunterschiede schneller als mit manuellen Curl-Aufrufen.

4. CI mit Mocks stabil halten

CI sollte nicht davon abhängen, ob gerade eine 24-GB-GPU verfügbar ist. Simulieren Sie den lokalen LLM-Endpunkt in Apidog mit realistischen JSON- oder Streaming-Antworten.

Das macht Tests stabiler, weil Unit- und Integrationstests nicht jedes Mal ein Modell laden müssen.

5. Durchsatz und Latenz benchmarken

Vergleichen Sie Läufe mit unterschiedlichen Parametern:

Q4 vs. Q5
8K vs. 32K Kontext
Temperatur 0.2 vs. 0.7
Ollama vs. vLLM
verschiedene GPUs oder Macs

Relevante Metriken:

Latenz
Time-to-First-Token
Tokens pro Sekunde
Fehlerrate
Timeout-Verhalten

6. Lokale API dokumentieren

Apidog-Projekte können OpenAPI 3.1 exportieren. Damit erhält Ihr Team einen klaren Vertrag für interne Modellendpunkte, z. B.:

POST /chat/completions
POST /embeddings
GET /models

Einen ähnlichen Workflow beschreibt Apidog als Postman-Alternative.

Häufige Fehler beim Ausführen lokaler LLMs

Fehler 1: Das größte Modell wählen, das gerade noch passt

Ein 32B-Modell bei Q3 ist oft schlechter als ein 14B-Modell bei Q5. Quantisierungsqualität ist nicht nur ein Detail. Ab 4 Bit kann sie mehr Einfluss haben als die reine Parameterzahl.

Fehler 2: Kontextlänge unterschätzen

Langer Kontext verbraucht VRAM über den KV-Cache. Ein 32K-Kontext auf einem 32B-Modell kann mehrere zusätzliche GB benötigen. Planen Sie den Speicherbedarf vor dem Start.

Fehler 3: Zufällige Fine-Tunes nutzen

Nicht jeder Hugging-Face-Upload ist vertrauenswürdig. Nutzen Sie bevorzugt:

offizielle Modellkarten
bekannte Fine-Tunes
Autoren mit nachvollziehbarer Historie
Modelle mit klarer Lizenz

Ein vergifteter Fine-Tune ist ein reales Risiko.

Fehler 4: Keine Mock-Schicht einbauen

Lokale Modelle können ausfallen:

Treiber stürzen ab
Prozesse werden durch OOM beendet
GPUs drosseln
Modellserver hängen
Streaming bricht ab

Wenn CI direkt gegen das Modell läuft, werden Tests unzuverlässig. Mocken Sie den Endpunkt mit Apidog.

Fehler 5: Tool-Call-Formate nicht testen

Llama 5.1, Qwen 3.6 und DeepSeek V4 unterstützen Tool Calls, können aber leicht unterschiedliche JSON-Strukturen ausgeben. Testen Sie jedes Modell mit Ihren echten Tool-Schemas, bevor Sie es in Produktion austauschen.

Praxisbeispiele

Ein Startup mit Kundensupport-Agent wechselte von GPT-5.5 zu Qwen 3.6 32B auf einer einzelnen 4090. Die Latenz blieb unter 800 ms, die monatliche Inferenzrechnung sank von 9.400 $ auf 0 $, und das Team nutzt Apidog-Mocks, um CI deterministisch zu halten.

Ein Solo-Entwickler für einen Sprachassistenten betreibt Gemma 4 9B auf einem M2 Pro mit 16 GB gemeinsamem Speicher. Multi-Token-Vorhersage-Drafter liefern 60 Token pro Sekunde, schnell genug für ein natives Nutzergefühl.

Ein Fintech-Forschungsteam betreibt DeepSeek V4 Flash auf zwei 4090ern für nächtliche Batch-Zusammenfassungen regulatorischer Einreichungen. Die Kosten pro Zusammenfassung bestehen im Wesentlichen aus Strom und Wartungszeit.

Fazit

Das beste lokale LLM im Jahr 2026 ist das Modell, das zu Ihrem VRAM, Ihrem Latenzbudget und Ihren Qualitätsanforderungen passt.

Für viele Teams ist die pragmatische Auswahl:

Qwen 3.6 32B für 24-GB-GPUs, Mehrsprachigkeit und Tool Calling
DeepSeek V4 Flash für 24-GB-GPUs, Reasoning und lokale Agenten
Llama 5.1 8B oder Gemma 4 9B für kleinere Hardware
GLM 5.1 für Tool-Calling- und JSON-lastige Workloads
DeepSeek V4 Pro für sehr große lokale Setups

Wichtigste Punkte:

Lokale Qualität ist bei vielen Aufgaben nah an gehosteten Modellen.
Ollama plus OpenAI-kompatibler Client ist der schnellste HTTP-Einstieg.
Quantisierung ist kritisch: Q4 oder Q5 ist oft besser als ein größeres Modell bei Q3.
Behandeln Sie lokale LLMs wie Produktions-APIs.
Speichern, simulieren, benchmarken und dokumentieren Sie Requests mit Apidog.

Nächster Schritt:

ollama pull <modellname>
ollama serve

Richten Sie anschließend Apidog auf diese Base URL:

http://localhost:11434/v1

Dann können Sie innerhalb kurzer Zeit Requests speichern, Modelle vergleichen und Benchmarks ausführen.

FAQ

Was ist das beste lokale LLM für eine 24-GB-GPU im Jahr 2026?

Für die meisten Workloads sind Qwen 3.6 32B bei Q4 oder DeepSeek V4 Flash bei Q4 geeignet. Wählen Sie Qwen für mehrsprachige oder Tool-intensive Aufgaben. Wählen Sie DeepSeek V4 Flash für Reasoning und Coding.

Mehr Details finden Sie im DeepSeek V4 lokalen Leitfaden.

Kann ich ein lokales LLM auf einem Mac ausführen?

Ja. Apple Silicon mit 16 GB oder mehr gemeinsamem Speicher kann Llama 5.1 8B und Gemma 4 9B ausführen. Ein M3 Ultra mit 192 GB gemeinsamem Speicher kann DeepSeek V4 Pro bei Q4 ausführen. Nutzen Sie dafür Ollama oder LM Studio.

Wie teste ich ein lokales LLM wie OpenAI?

Verwenden Sie denselben OpenAI-kompatiblen Client, ändern Sie aber die Base URL.

Ollama:

http://localhost:11434/v1

vLLM:

http://localhost:8000/v1

Dasselbe gilt für Ihr Apidog-Projekt: gleiche Request-Struktur, andere Base URL.

Ist die Qualität lokaler LLMs wirklich gleichwertig mit gehosteten Modellen?

Bei Reasoning, Coding, Klassifikation, Extraktion und Tool Calling liegen die besten offenen Modelle oft innerhalb eines einstelligen Prozentbereichs. Bei Vision, Langkontext-Dokumenten-QA und kreativem Schreiben haben gehostete Modelle weiterhin Vorteile.

Was ist mit den Kosten?

Eine 4090 kann DeepSeek V4 Flash im Wesentlichen zum Strompreis betreiben, z. B. etwa 30 $ pro Monat bei typischer Nutzung. Ein gehostetes Äquivalent mit gleichem Volumen kann Hunderte bis Tausende Dollar pro Monat kosten. Der Break-even liegt häufig bei etwa 5 Millionen Token pro Monat.

Wie wechsle ich eine Produktions-App zwischen gehostet und lokal?

Behalten Sie den OpenAI-Client bei und ändern Sie:

Base URL
Modellname
ggf. Tool-Call-Handling
Timeout- und Retry-Parameter

Testen Sie den Wechsel vorher mit Replay- und Vergleichstools, damit Verhaltensunterschiede sichtbar werden, bevor Nutzer sie bemerken. Siehe auch API-Tests ohne Postman.

Wo finde ich aktuelle Ranglisten?

Nutzen Sie beide Quellen, weil sie unterschiedliche Aspekte messen:

Computernutzung vs. Strukturierte APIs: Wann Was Besser Ist (2026)

Emre Demir — Fri, 08 May 2026 02:43:14 +0000

Das Steuern eines Browsers mit einem LLM über Computer-Nutzungsmodelle ist ungefähr 45-mal teurer, als denselben Anbieter über eine strukturierte API aufzurufen.

Apidog noch heute ausprobieren

Dieser Leitfaden zeigt, woher diese 45x-Kosten kommen, wann Computer-Nutzung trotzdem sinnvoll ist und wie Sie mit Apidog strukturierte API-Flows für Agenten entwerfen, mocken und testen. Das Framework gilt für OpenAI Operator, Anthropic Computer-Nutzung, Browser-Nutzung, Skyvern und alle Tools, die mit einer Screenshot-Schleife arbeiten.

Wenn Sie APIs für KI-Agenten schreiben, lesen Sie auch den ergänzenden Leitfaden zu agents.md-Dateien. Die dortigen Konventionen machen strukturierte APIs für Agenten zur naheliegenden Standardeinstellung.

TL;DR

Computer-Nutzung: Das LLM sieht Screenshots und gibt Klicks, Tastatureingaben und Scroll-Aktionen aus.
Strukturierte APIs: Das LLM erzeugt JSON-Tool-Aufrufe, die Ihr Backend ausführt.
Für dieselbe Aufgabe verbraucht Computer-Nutzung oft 30- bis 50-mal mehr Token, weil jeder Schritt einen neuen Screenshot und häufig Wiederholungen braucht.
Nutzen Sie Computer-Nutzung nur, wenn keine API existiert, die API stark limitiert ist oder der Workflow hinter einer schwer automatisierbaren Authentifizierung liegt.
Nutzen Sie für Zahlungen, Suche, CRM-Updates, interne Tools und alles mit OpenAPI-Dokumentation strukturierte APIs.
In der Praxis ist Hybrid meist richtig: APIs für die 90 Prozent mit Endpunkten, Computer-Nutzung für den Long Tail.
Mit Apidog können Sie JSON-Tool-Schemas entwerfen, Endpunkte mocken und Agenten-Flows testen, ohne unnötig Agenten-Guthaben zu verbrennen.

Warum der Kostenunterschied so groß ist

Die 45x-Zahl entsteht direkt aus der Token-Nutzung.

Ein strukturierter API-Aufruf besteht typischerweise aus:

Benutzeranfrage
Tool-Schema
JSON-Antwort des Modells
Backend-Aufruf

Das sind oft nur wenige hundert Eingabe-Token und eine kleine JSON-Ausgabe.

Eine Computer-Nutzungsschleife läuft anders:

Prompt senden
Screenshot senden
Modell gibt Klickkoordinate zurück
Browser führt Klick aus
Neuer Screenshot
Nächster Modellschritt
Wiederholen, bis die Aufgabe fertig ist

Eine Aufgabe wie „Flug buchen“ oder „Bericht im Dashboard abrufen“ kann 12 bis 30 Runden benötigen. Jeder Screenshot kostet bei typischer Auflösung etwa 1.500 Token. Dazu kommen Fehlklicks, Cookie-Banner, falsches Scrollen und Wiederholungsversuche.

Die Anthropic-Dokumentation zur Computer-Nutzung beschreibt die Screenshot-Token-Kosten offen. Der reale Overhead ist meist höher, weil der Agent UI-Zustände korrigieren muss. Der HN-Thread zu Computer-Nutzung ist 45-mal teurer als strukturierte APIs kommt auf eine typische Strafe von 30- bis 50-fach. Das entspricht dem, was sichtbar wird, wenn man denselben Workflow in Apidog einmal als API-Flow und einmal als Browser-Flow testet.

Wann strukturierte APIs gewinnen

Verwenden Sie standardmäßig strukturierte APIs, wenn eine dieser Bedingungen zutrifft.

1. Es gibt eine dokumentierte Schnittstelle

Wenn der Anbieter eine OpenAPI-Spezifikation, ein GraphQL-Schema oder auch nur eine REST-Dokumentation bereitstellt, sollte der Agent diese Schnittstelle nutzen.

Beispiel:

{
  "name": "update_deal_status",
  "description": "Aktualisiert den Status eines CRM-Deals",
  "parameters": {
    "type": "object",
    "properties": {
      "deal_id": {
        "type": "string"
      },
      "status": {
        "type": "string",
        "enum": ["open", "won", "lost"]
      }
    },
    "required": ["deal_id", "status"]
  }
}

Ein Agent kann dieses Schema direkt ausfüllen. Fehler sind leicht zu validieren und günstig zu wiederholen.

2. Die Aufgabe passt in ein oder zwei Endpunkte

Diese Aufgaben sollten nicht über einen Browser laufen:

Stripe-Kunden erstellen
HubSpot-Deal aktualisieren
Slack-Nachricht posten
CI-Rerun auslösen
Rechnungsliste abrufen
Support-Ticket schließen

Wenn ein einzelner HTTP-Aufruf reicht, ist eine Screenshot-Schleife unnötig langsam, teuer und fehleranfällig.

3. Der Workflow läuft unbeaufsichtigt

Cron-Jobs, Webhooks und Queue Worker sollten keine UI bedienen. Sie brauchen deterministische Netzwerkaufrufe, keine Agenten, die eventuell in die falsche Richtung scrollen.

4. Latenz ist relevant

Ein strukturierter API-Aufruf dauert oft 200 bis 800 Millisekunden. Eine Computer-Nutzungsschleife mit 15 Runden dauert 30 bis 90 Sekunden.

Wenn ein Nutzer auf das Ergebnis wartet, ist fast immer die API der richtige Weg.

5. Sie müssen vor dem Versand testen

JSON-Endpunkte lassen sich in Apidog schnell mocken. Eine Browser-Screenshot-Schleife zuverlässig zu mocken, ist deutlich komplexer.

Wann Computer-Nutzung sinnvoll ist

Computer-Nutzung ist nicht nutzlos. Sie ist nur kein guter Standardpfad.

Veraltete Anbieterportale

Einige Beschaffungs-, Fracht- oder Leistungsportale sind älter als moderne APIs. Sie laufen hinter ASP.NET-Sessions oder komplexen Formularen und bieten keine Maschinenschnittstelle.

Wenn die Alternative ein instabiles Selenium-Skript ist, das jedes Quartal bricht, kann Computer-Nutzung trotz höherer Laufkosten sinnvoll sein.

Interne Tools, die Sie nicht ändern können

Beispiele:

altes CRM
Legacy-ERP
SharePoint-Dashboard
internes Admin-Panel ohne API

Wenn Sie keine Integration liefern können und kein iPaaS-Budget existiert, kann eine Screenshot-Schleife eine pragmatische Lösung sein.

Einmalige Operator-Aufgaben

Beispiel:

Recherchiere diese 50 Wettbewerber und füge die Highlights in Notion ein.

Das ist möglicherweise kein Workflow, der einen stabilen API-Vertrag braucht. Für einmalige oder seltene Aufgaben können die Mehrkosten akzeptabel sein.

Scraping hinter fremden Oberflächen

Bei Anfragen wie „scrape diese Website mit Computer-Nutzung“ ist nicht nur der Preis relevant. Prüfen Sie zuerst Nutzungsbedingungen, Rechte und Zugriffserlaubnis. Die Token-Kosten sind hier oft das kleinste Problem.

Entscheidungsrahmenwerk

Prüfen Sie vor jeder Computer-Nutzung diese vier Fragen:

Prüfung	Wenn ja	Wenn nein
Existiert eine dokumentierte API?	Nutzen Sie die API.	Weiter prüfen.
Können Sie einen schlanken serverseitigen Adapter für einen privaten Endpunkt bauen?	Adapter erstellen und als JSON-Tool bereitstellen.	Weiter prüfen.
Ist die Aufgabe einmalig oder geringvolumig (<100 Läufe/Tag)?	Computer-Nutzung ist akzeptabel.	Weiter prüfen.
Sind 30-50x Token-Kosten pro Lauf akzeptabel?	Computer-Nutzung.	Stoppen und API-Zugang verhandeln.

In den meisten realen Workflows scheitert Computer-Nutzung bereits an Prüfung eins oder zwei.

Wie strukturierte APIs in einem Agenten aussehen

Beispiel: Der Agent soll „fehlgeschlagene Zahlungen von gestern“ abrufen.

Die strukturierte Variante definiert zuerst ein Tool-Schema:

import json
from openai import OpenAI

client = OpenAI()

tools = [{
    "type": "function",
    "function": {
        "name": "list_failed_payments",
        "description": "List failed payments in a date range",
        "parameters": {
            "type": "object",
            "properties": {
                "start": {"type": "string", "format": "date"},
                "end": {"type": "string", "format": "date"}
            },
            "required": ["start", "end"]
        }
    }
}]

resp = client.chat.completions.create(
    model="gpt-5.5",
    messages=[
        {
            "role": "user",
            "content": "Show yesterday's failed payments."
        }
    ],
    tools=tools,
    tool_choice="auto"
)

call = resp.choices[0].message.tool_calls[0]
args = json.loads(call.function.arguments)

payments = stripe.PaymentIntent.list(
    created={
        "gte": args["start"],
        "lte": args["end"]
    },
    limit=100
)

Der Agent sieht kein Dashboard. Er erzeugt nur strukturierte Argumente.

Die Computer-Nutzungs-Variante müsste dagegen:

Browser starten
Bei Stripe anmelden
Dashboard-Screenshot analysieren
Datumsauswahl anklicken
neuen Screenshot analysieren
Zeitraum auswählen
Filter für fehlgeschlagene Zahlungen setzen
scrollen
Werte aus Pixeln extrahieren

Jeder Schritt erzeugt neue Screenshot-Token. Zwölf Runden sind schnell erreicht.

Den strukturierten Pfad mit Apidog gestalten

Teams greifen oft nicht wegen technischer Notwendigkeit zu Computer-Nutzung, sondern weil keine saubere Tool-Oberfläche für den Agenten existiert. Genau dort hilft Apidog.

Schritt 1: Agentenoperationen als Endpunkte modellieren

Erstellen Sie in Apidog ein Projekt und definieren Sie nur die Operationen, die der Agent wirklich braucht.

Beispiele:

POST /invoices/search
POST /deals/update-status
POST /messages/send
GET /payments/failed
POST /tickets/close

Eine kleine Menge gut benannter Endpunkte ersetzt oft große Teile einer Browser-Automation.

Schritt 2: OpenAPI-Schema exportieren

Apidog generiert aus der Designansicht ein OpenAPI-3.1-Dokument. Dieses Schema wird zur Tool-Oberfläche für den Agenten.

Viele Agenten-Frameworks können OpenAPI direkt nutzen:

OpenAI tools
Anthropic Tool Use
LangChain OpenAPI Loader
DeepSeek Tool Calling

Schritt 3: Mock-Server aktivieren

Aktivieren Sie den Apidog-Mock-Server und lassen Sie den Agenten gegen Mock-URLs laufen.

Vorteile:

keine Produktionsdaten
keine Seiteneffekte
reproduzierbare Antworten
geringere Kosten während der Entwicklung
schnelleres Debugging

Dasselbe Pattern wird im Apidog-Leitfaden zur Contract-First-Entwicklung beschrieben.

Schritt 4: Requests und Responses vergleichen

Apidog zeichnet Anfragen und Antworten auf. Vergleichen Sie einen erfolgreichen Lauf mit einem fehlerhaften Lauf:

Wurde das richtige Tool gewählt?
Waren die Argumente valide?
Hat der Mock anders geantwortet als Produktion?
Fehlt ein Endpunkt?
Ist das Schema zu ungenau?

So debuggen Sie Agenten-Flows auf API-Ebene statt auf Screenshot-Ebene.

Schritt 5: Bereitstellen und versionieren

Das Apidog-Projekt dient gleichzeitig als:

API-Design
OpenAPI-Schema
Mock-Server
Testumgebung
Dokumentation
QA-Basis

Behandeln Sie Agenten-Tools wie öffentliche APIs: versioniert, getestet und dokumentiert.

Hybrid: Wenn Sie beide Wege benötigen

Produktionsagenten sind häufig hybrid.

Ein realistischer Aufbau:

90 Prozent der Operationen laufen über strukturierte Tools.
10 Prozent laufen über Computer-Nutzung für Legacy-Portale.
Ein Router entscheidet, welcher Pfad verwendet wird.

Beispiel für eine Router-Regel:

Wenn die gewünschte Operation in known_tools existiert, rufe das strukturierte Tool auf.
Wenn kein passendes Tool existiert, übergib die Aufgabe an den Browser-Agenten.

Anthropic Claude 4.5 und OpenAI GPT-5.5 können dieses Routing zuverlässig übernehmen. Dasselbe Muster lässt sich auch mit DeepSeek V4 umsetzen. Die Request-Form wird im Leitfaden wie man die DeepSeek V4 API verwendet gezeigt.

Wichtig: Messen Sie beide Pfade separat.

Erwartetes Kostenprofil:

strukturierte Tools: hohes Volumen, niedrige Kosten
Computer-Nutzung: niedriges Volumen, hohe Kosten

Wenn der Browser-Fallback plötzlich viel Volumen bekommt, fehlt wahrscheinlich ein Endpunkt in Ihrer Tool-Oberfläche.

Häufige Fehler

Fehler 1: Kein striktes Schema definieren

Nur mit Text-Prompts zu arbeiten, ist fragil. Definieren Sie immer ein JSON-Schema.

Schlecht:

Wenn der Nutzer eine Zahlung sucht, finde die passenden Daten.

Besser:

{
  "type": "object",
  "properties": {
    "customer_id": {"type": "string"},
    "status": {
      "type": "string",
      "enum": ["succeeded", "failed", "pending"]
    },
    "from": {"type": "string", "format": "date"},
    "to": {"type": "string", "format": "date"}
  },
  "required": ["status", "from", "to"]
}

Fehler 2: Den Agenten das Schema zur Laufzeit entwerfen lassen

Ein Schema ist eine Produktoberfläche. Entwerfen Sie es in Apidog, versionieren Sie es und behandeln Sie Änderungen wie API-Änderungen.

Selbstmodifizierende Schemas führen schnell zu Produktionsfehlern.

Fehler 3: Nur Tokens statt Kosten beobachten

Screenshot-Token werden in vielen Observability-Tools anders ausgewiesen als Text-Token. Prüfen Sie die Abrechnungskonsole Ihres Modellanbieters, nicht nur Ihr Tracing-Dashboard.

Fehler 4: Computer-Nutzung mit RPA verwechseln

RPA klickt geskriptet auf bekannte DOM-Elemente.

Computer-Nutzung entscheidet bei jedem Screenshot neu, was zu tun ist.

RPA ist günstiger und wiederholbarer. Computer-Nutzung ist flexibler, aber teurer. Nutzen Sie nicht Computer-Nutzung, wenn ein Playwright- oder Puppeteer-Skript reicht.

Fehler 5: Latenz ignorieren

Eine 45x-Token-Rechnung ist teuer. Noch problematischer ist oft die Wartezeit. Eine 60-Sekunden-Screenshot-Schleife passt selten in einen interaktiven Nutzerfluss.

Alternativen zur Computer-Nutzung

Wenn ein Anbieter keine öffentliche API hat, gibt es Zwischenlösungen.

1. Headless-Browser-Skripte

Tools:

Playwright
Puppeteer
Selenium

Vorteil: Nach der Entwicklung geringe Laufkosten.

Nachteil: Bricht, wenn sich die UI ändert.

2. Zapier- oder Make-Konnektoren

Manchmal hat der Anbieter keine gute öffentliche API-Dokumentation, aber fertige iPaaS-Konnektoren. Dann können Sie Integrationsaufwand einkaufen statt selbst bauen.

3. Private JSON-Endpunkte

Viele Dashboards sprechen intern mit JSON-Endpunkten. Über den Netzwerk-Tab der DevTools lassen sich diese Endpunkte identifizieren.

Wenn die Nutzung zulässig ist, können Sie sie in Apidog dokumentieren und als semi-stabile interne API behandeln. Ein ähnliches Vorgehen wird im Artikel API-Testen ohne Postman beschrieben.

Computer-Nutzung sollte der letzte Ausweg sein, nicht die Standardlösung.

Praxisbeispiele

Ein Fintech-Compliance-Team ersetzte einen 6-stufigen Stripe-Bericht, der Computer-Nutzung erforderte, durch drei strukturierte Aufrufe. Die Token-Kosten sanken um 92 Prozent, die Laufzeit von 41 auf 2 Sekunden.
Ein B2B-SaaS-Support-Agent nutzte Computer-Nutzung nur für ein Beschaffungsportal ohne API. Alle anderen Operationen liefen über OpenAPI-Tool-Aufrufe, die in Apidog entworfen wurden. Die monatlichen Token-Ausgaben sanken von 4.200 $ auf 310 $.
Ein Einzelgründer nutzte Computer-Nutzung einmal pro Woche, um ein Notion-Dashboard aus einem Legacy-ERP zu aktualisieren. Die 45x-Kosten waren bei einem wöchentlichen Lauf nur wenige Cents. Eine vollständige Integration hätte Wochen gedauert.

Fazit

Die 45x-Zahl ist realistisch genug, um Ihre Tool-Strategie zu beeinflussen.

Standardisieren Sie auf strukturierte APIs, die in Apidog entworfen, gemockt und getestet werden. Nutzen Sie Computer-Nutzung nur, wenn keine API existiert und der Workflow selten genug läuft, dass die Token-Kosten akzeptabel bleiben.

Fünf konkrete Regeln:

Nutzen Sie APIs, sobald ein dokumentierter Endpunkt existiert.
Definieren Sie für jedes Agenten-Tool ein striktes JSON-Schema.
Mocken Sie Tool-Endpunkte vor dem Live-Test.
Trennen Sie API- und Browser-Kosten in Ihrer Observability.
Bauen Sie neue Endpunkte, wenn der Agent häufig auf den Browser-Fallback ausweicht.

Nächster Schritt: Öffnen Sie Apidog, erstellen Sie ein Projekt für die Tool-Oberfläche Ihres Agenten und aktivieren Sie den Mock-Server. In kurzer Zeit sehen Sie, ob der geplante Computer-Nutzungs-Workflow auf zwei strukturierte API-Aufrufe reduziert werden kann.

FAQ

Ist Computer-Nutzung jemals günstiger als eine strukturierte API?

Nicht pro Lauf. Screenshot-Token dominieren die Kosten. Computer-Nutzung kann nur insgesamt günstiger sein, wenn die Integrationskosten höher wären als die Betriebskosten über die gesamte Lebensdauer. Das gilt vor allem für seltene Workflows ohne verfügbare API.

Wie mocke ich eine JSON-Tool-Oberfläche für einen Agenten?

Entwerfen Sie die Endpunkte in Apidog, aktivieren Sie den integrierten Mock-Server und konfigurieren Sie Ihren Agenten auf die Mock-URL. Jede Anfrage liefert realistische JSON-Antworten ohne Produktionsrisiko. Der Workflow wird auch in API-Test-Tools für QA-Ingenieure behandelt.

Kann ich OpenAPI für Tool-Aufrufe in jedem Modell verwenden?

Ja. OpenAI tools, Anthropic tool_use und DeepSeek V4 Tool Calling können mit OpenAPI-3.1-Schemas arbeiten. Apidog exportiert diese Schemas sauber. Siehe wie man die DeepSeek V4 API verwendet.

Unterstützt GPT-5.5 noch Computer-Nutzung?

OpenAI liefert Computer-Nutzung über Operator und über die Responses API. Das Kostenprofil ähnelt Anthropic bei vergleichbaren Screenshot-Schleifen. Die Empfehlung bleibt unabhängig vom Anbieter gleich: API zuerst, Browser nur als Fallback.

Was ist mit Skyvern, Browser-Nutzung und anderen Open-Source-Agenten?

Die Rechnung bleibt ähnlich. Günstigere Modelle senken den Preis pro Aufruf, aber Rundenanzahl und Screenshot-Größe bleiben das Problem. Wo APIs existieren, sind strukturierte Aufrufe weiterhin deutlich günstiger und zuverlässiger.

Woher weiß ich, wann für eine Agentenaufgabe ein Endpunkt fehlt?

Beobachten Sie, wann der Agent auf den Browser-Fallback ausweicht oder Tool-Aufrufe ablehnt. Wenn das wiederholt passiert, fehlt wahrscheinlich ein Endpunkt. Fügen Sie ihn in Apidog hinzu, exportieren Sie das Schema neu und lassen Sie den Agenten den strukturierten Pfad verwenden.

TradingAgents: Open Source LLM Trading Framework

Emre Demir — Thu, 07 May 2026 04:06:51 +0000

Die meisten Multi-Agenten-LLM-Frameworks versprechen mehr, als sie halten. TradingAgents ist eine der seltenen Ausnahmen: Open Source von Tauric Research mit arXiv-Paper, Version 0.2.4, und einer sauberen Rollenverteilung. Das System modelliert einen Research-Desk: Fundamentalanalyse, Sentimentanalyse, Nachrichtenanalyse und technische Analyse liefern Input für eine Bull/Bear-Debatte, danach entscheiden Trader und Risikomanagement-Komitee. Das Ergebnis ist eine strukturierte, protokollierte Entscheidung.

Teste Apidog noch heute

Diese Rezension zeigt, was TradingAgents praktisch leistet, was v0.2.4 mitbringt, wie es sich gegenüber LangGraph und CrewAI einordnet und wie du die darunterliegenden LLM- und Marktdaten-Schnittstellen mit Apidog testest. Wenn du dich mit Agenten-Vertragsschichten beschäftigst, passt der agents.md-Leitfaden für API-Teams gut dazu.

TL;DR

TradingAgents ist ein Multi-Agenten-LLM-Handelsframework von Tauric Research, arXiv 2412.20138, Open Source und aktuell in Version 0.2.4.
Es zerlegt den Workflow in spezialisierte Agenten: Fundamentalanalyse, Sentimentanalyse, Nachrichtenanalyse, technische Analyse, Bull/Bear-Forscher, Trader und Risikomanagement.
v0.2.4 bringt strukturierte Agenten-Ausgaben, LangGraph-Checkpoint-Wiederaufnahme, persistente Entscheidungslogs und Provider-Support für DeepSeek, Qwen, GLM und Azure OpenAI.
Das Framework läuft mit OpenAI-kompatiblen LLM-Endpunkten. Dadurch kannst du gehostete, lokale und selbst gehostete Modelle austauschen.
Mit Apidog kannst du Marktdaten-APIs mocken, LLM-Provider-Traffic reproduzieren und Kosten über DeepSeek, OpenAI und Anthropic vergleichen.
Lade Apidog herunter, wenn du diese Tests in CI integrieren willst, bevor Agenten mit realen Finanzdaten arbeiten.

Was TradingAgents tatsächlich ist

TradingAgents ist ein Python-Paket mit CLI, das einen Handels-Workflow in Rollen zerlegt. Jede Rolle ist ein LLM-Agent mit:

klarer Aufgabenbeschreibung,
fokussiertem Toolset,
LangGraph-Orchestrierung,
strukturierter Übergabe an den nächsten Schritt.

Der Ablauf ist:

Daten sammeln
Analysen erzeugen
Bull/Bear-Debatte führen
Entscheidung formulieren
Risiko prüfen
Ergebnis protokollieren

Wichtig: Das README beschreibt TradingAgents als Forschungscode, nicht als Anlageberatung. Praktisch heißt das: Nutze es zum Experimentieren mit Multi-Agenten-Workflows, nicht als direkten Produktions-Trading-Bot.

Die technische Stärke liegt in der Rollentrennung:

Rolle	Aufgabe
Fundamentalanalyse-Analyst	Unternehmensfinanzen bewerten
Sentiment-Analyst	soziale Medien und Stimmung auswerten
Nachrichten-Analyst	makroökonomische und aktuelle Nachrichten prüfen
Technischer Analyst	Indikatoren wie MACD und RSI berechnen
Bull-Researcher	Long-These formulieren
Bear-Researcher	Short-These formulieren
Trader	Berichte lesen und Handelsplan ableiten
Risikomanagement	Entscheidung anhand von Constraints prüfen

Dieses Muster ist nicht nur für Trading relevant. Es ist eine gute Referenz für jeden komplexen Agenten-Workflow: Spezialisten, Debatte, Entscheidung, Review und Audit-Log.

Was v0.2.4 ausgeliefert hat

Die Veröffentlichung im April 2026 ist besonders relevant, wenn du TradingAgents ernsthaft evaluieren willst.

Strukturierte Agenten-Ausgaben

Forschungsmanager, Trader und Portfoliomanager geben strukturierte Ergebnisse über die OpenAI Responses API oder Anthropics Tool-Use-Kanal zurück.

Statt Freitext bekommst du typisiertes JSON. Das macht nachgelagerte Automatisierung stabiler, zum Beispiel:

{
  "ticker": "AAPL",
  "decision": "hold",
  "confidence": 0.72,
  "rationale": "Bullish fundamentals offset by short-term valuation risk.",
  "risk_notes": [
    "Earnings volatility",
    "Macro uncertainty"
  ]
}

Das konkrete Schema hängt von der Implementierung ab, aber der wichtige Punkt ist: Parser müssen nicht mehr gegen unstrukturierten Text kämpfen.

LangGraph-Checkpoint-Wiederaufnahme

Langlaufende Ausführungen können pausiert und von einem gespeicherten Checkpoint fortgesetzt werden.

Das ist relevant, wenn:

eine Marktdaten-API drosselt,
ein LLM-Provider 429 zurückgibt,
ein lokales Modell abstürzt,
ein CI-Job unterbrochen wird.

Ohne Checkpoints müsstest du den kompletten Lauf neu starten. Mit Checkpoints setzt du beim letzten stabilen Zustand fort.

Persistentes Entscheidungslog

Jede Trader-Entscheidung landet in einem SQLite-Log mit:

Entscheidung,
Begründung,
Eingaben,
Zeitstempel.

Damit kannst du später prüfen:

Warum wurde ein bestimmter Plan erzeugt?
Welche Daten lagen vor?
Welches Modell war beteiligt?
Welche Agenten haben widersprochen?

Für Experimente ist dieser Audit-Trail wichtiger als die einzelne Empfehlung.

Multi-Provider-Unterstützung

v0.2.4 erweitert die Provider-Matrix um DeepSeek, Qwen, GLM und Azure OpenAI. Vorher waren bereits OpenAI, Anthropic, Gemini und Grok relevant.

Wenn du günstigeres Reasoning testen willst, kannst du zum Beispiel DeepSeek V4 über den OpenAI-kompatiblen Endpunkt verwenden. Wenn du lange Kontexte oder Vision brauchst, testest du Gemini.

Docker und Windows-UTF-8-Fix

Unspektakulär, aber praktisch:

Dockerfile für reproduzierbare Umgebungen
behobener Windows-Pfad-Codierungsfehler aus v0.2.3

Gerade für Teams ist Docker wichtig, weil LLM-Experimente sonst schnell an lokalen Python-Umgebungen scheitern.

Die Agentenarchitektur im Detail

Eine typische TradingAgents-Ausführung sieht so aus:

Die CLI erhält Tickersymbol und Datum.
Das Analysten-Team läuft parallel oder sequenziell:
- Fundamentalanalyse
- Sentimentanalyse
- Nachrichtenanalyse
- technische Analyse
Jeder Analyst ruft eigene Daten ab und schreibt einen Bericht.
Der Bull-Researcher formuliert eine Long-These.
Der Bear-Researcher formuliert eine Short-These.
Beide debattieren.
Der Forschungsmanager synthetisiert die Debatte.
Der Trader erstellt einen Handelsplan.
Das Risikomanagement prüft aus mehreren Perspektiven:
- aggressiv,
- konservativ,
- neutral.
Der Portfoliomanager genehmigt oder fordert Überarbeitung.
Die finale Entscheidung wird im SQLite-Log gespeichert.

Die teuersten Schritte sind meist:

Bull/Bear-Debatte
Risikomanagement-Debatte

Dort werden Reasoning-Modelle relevant. Kleine Modelle können sich in Wiederholungen verlieren oder inkonsistente Argumente liefern. Reasoning-Modelle wie DeepSeek V4 im Denkmodus, GPT-5.5 oder Claude 4.5 erzeugen eher strukturierte Gegenargumente.

Warum du die LLM-Schicht mit einem API-Tool testen solltest

In der Praxis brechen TradingAgents-Läufe meist an zwei Stellen:

Marktdaten-APIs
LLM-Provider-APIs

Marktdaten-APIs sind instabil

Typische Probleme:

Rate Limits in Free Tiers
Felder ändern Namen
Felder verschwinden
neue Felder kommen hinzu
Provider liefern leicht unterschiedliche Semantik

Beispiel: Ein Lauf funktioniert am Dienstag, bricht aber am Mittwoch, weil ein Anbieter regularMarketTime in regular_market_time geändert hat.

LLM-Provider sind ebenfalls nicht trivial

Auch LLM-Schnittstellen unterscheiden sich:

DeepSeek V4 Denkmodus kann Kosten erhöhen.
OpenAI Responses API hat eigene Antwortstrukturen.
Anthropic Tool Use liefert Inhaltsblöcke, die Parser beachten müssen.
OpenAI-kompatibel heißt nicht automatisch identisch.

Du brauchst deshalb wiederholbare API-Sammlungen mit Assertions. Dafür eignet sich Apidog. Ein ähnliches Testmuster auf Protokollebene wird im MCP Server Testing Playbook beschrieben.

Marktdaten-APIs in Apidog mocken

Ziel: Deine Tests sollen nicht von Yahoo Finance, FinnHub, Polygon oder OpenBB abhängen.

Schritt 1: Upstream-Endpunkte definieren

Lege in Apidog ein Projekt an und erfasse die Endpunkte, die TradingAgents nutzt.

Beispiele:

GET /quote/AAPL
GET /fundamentals/AAPL
GET /news?symbol=AAPL
GET /indicators/rsi?symbol=AAPL

Speichere zu jeder Anfrage Beispielantworten aus echten Provider-Antworten.

Schritt 2: Mock-Server aktivieren

Aktiviere den Apidog-Mock-Server und zeige die TradingAgents-Konfiguration auf die Mock-URL.

Konzeptionell sieht das so aus:

export MARKET_DATA_BASE_URL="https://mock.apidog.local/project-id"

Der konkrete Konfigurationsname hängt vom jeweiligen Tool/Provider-Adapter ab. Wichtig ist: Die Agenten rufen jetzt deterministische Fixtures ab.

Das Ergebnis:

keine Rate-Limit-Probleme in Tests,
reproduzierbare Agenten-Ausgaben,
schnellere CI-Läufe,
bessere Regressionstests.

Schritt 3: Provider-Abweichungen prüfen

Führe regelmäßig Live-Requests gegen die echten Provider aus und vergleiche sie mit deinen gespeicherten Fixtures.

Prüfe auf:

entfernte Felder,
neue Felder,
umbenannte Felder,
geänderte Datentypen,
geänderte Nullability.

Dieses Pattern entspricht der Contract-First-API-Entwicklung.

LLM-Provider-Schicht testen

Bevor du Läufe skalierst, solltest du drei Dinge testen.

1. Kosten pro Rolle messen

Führe einen einzelnen Ticker durch alle Agenten und erfasse Token-Nutzung pro Rolle.

Beispielhafte Tabelle:

Rolle	Input Tokens	Output Tokens	Kosten
Fundamentalanalyse	8.000	1.200	niedrig
Sentimentanalyse	5.000	900	niedrig
Bull/Bear-Debatte	30.000	6.000	hoch
Risikomanagement	18.000	4.000	hoch

Die Bull/Bear-Debatte ist häufig 3- bis 5-mal teurer als einzelne Analystenläufe. Wenn nicht, kann das ein Hinweis sein, dass das Modell zu knapp oder oberflächlich argumentiert.

2. Ausgabeform validieren

Für strukturierte Agenten-Ausgaben solltest du JSONPath-Assertions definieren.

Beispiele:

$.decision exists
$.confidence is number
$.rationale exists
$.risk_notes is array

Damit erkennst du sofort, wenn ein Provider plötzlich Freitext oder eine inkompatible Tool-Use-Struktur zurückgibt.

3. Provider-Parität vergleichen

Wenn du von OpenAI zu DeepSeek V4 wechselst, sollten einzelne Entscheidungen variieren dürfen. Über viele Läufe sollten die Schlussfolgerungen aber vergleichbar bleiben.

Praktischer Test:

Wähle 50 Ticker.
Führe alle Ticker mit Provider A aus.
Führe dieselben Ticker mit Provider B aus.
Vergleiche das persistente Entscheidungslog.
Miss Abweichungen bei:
- buy / hold / sell,
- Confidence,
- Risikobewertung,
- Begründungsmustern.

Der DeepSeek V4 API-Leitfaden zeigt die Request-Form. Der GPT-5.5 API-Leitfaden deckt die OpenAI-Seite ab. Mit Apidogs Response-Diff kannst du Unterschiede visuell vergleichen.

Minimaler TradingAgents-Lauf

Der Quickstart sieht ungefähr so aus:

git clone https://github.com/TauricResearch/TradingAgents
cd TradingAgents
pip install -r requirements.txt

export OPENAI_API_KEY="sk-..."
export FINNHUB_API_KEY="..."

python -m tradingagents.cli \
  --ticker AAPL \
  --date 2026-04-30 \
  --models gpt-5.5 \
  --rounds 2

Zwei Debattenrunden sind der kleinste sinnvolle Lauf. Die Ergebnisse landen in tradingagents/results/ als JSON und Markdown-Zusammenfassung.

Wenn du für reasoning-intensive Rollen DeepSeek V4 Pro testen willst:

export DEEPSEEK_API_KEY="sk-..."

python -m tradingagents.cli \
  --ticker AAPL \
  --date 2026-04-30 \
  --models deepseek-v4-pro \
  --provider deepseek \
  --rounds 2

Dasselbe Muster funktioniert für Qwen 3.6, GLM 5 oder lokale Modelle über Ollama oder vLLM. Der Beitrag zu den besten lokalen LLMs von 2026 behandelt lokale Bereitstellung.

Häufige Fallstricke

Zu kleines Modell verwenden

Ein 7B-Modell kann die Bull/Bear-Debatte in Wiederholungen treiben. Für sinnvolle Debatten brauchst du mindestens mittlere Reasoning-Qualität.

Realistische Untergrenze:

DeepSeek V4 Flash
Qwen 3.6 32B
GPT-5.5
Claude 4.5

Marktdaten-Caching überspringen

Jeder Analyst kann eigene Daten abrufen. Ohne Caching erzeugt ein einzelner Lauf schnell 4 bis 8 Provider-Requests.

Aktiviere Caching, sonst verbrauchst du Rate Limits unnötig.

Forschungscode als Trading-Bot behandeln

TradingAgents ist Forschungscode. Backtest-Ergebnisse hängen ab von:

Modell,
Prompt-Seed,
Debattenlänge,
Datenqualität,
Provider-Antworten.

Behandle jede Ausgabe als Hypothese, nicht als Strategie.

Token-Verbrauch nicht protokollieren

Ein einzelner Ticker-Lauf kann je nach Modell und Runden zwischen 0,10 und 5 US-Dollar kosten.

Protokolliere:

Modell,
Agentenrolle,
Input Tokens,
Output Tokens,
Kosten,
Laufzeit,
Fehler.

Die Replay-Historie von Apidog hilft, Ausreißer zu finden. Eine Endlosschleife in der Debatte kann schnell teuer werden.

Provider fest verdrahten

v0.2.0 brachte Multi-Provider-Support genau dafür, Modelle austauschbar zu machen.

Teste kleine Chargen über mehrere Provider, bevor du dich festlegst:

AAPL, MSFT, NVDA, TSLA, AMZN

Vergleiche danach das Entscheidungslog.

Wo Apidog in den Entwicklungszyklus passt

Apidog ist besonders nützlich an drei Stellen.

1. API-Design vor Live-Integration

Bevor du TradingAgents mit echten Providern verbindest, skizziere jeden Marktdaten-Endpunkt als Anfrage mit Beispielkörper.

Das zwingt dich zu klären:

Welche Felder nutzt das Framework wirklich?
Welche Felder sind optional?
Welche Antworttypen kommen vor?
Welche Provider sind austauschbar?

Viele Teams merken dabei, dass sie teure Datenfelder kaum verwenden.

2. Lokale CI mit Mocks

Der Mock-Server ersetzt externe Provider während Unit- und Integrationstests.

Vorteile:

Tests laufen schneller.
Tests funktionieren am Wochenende.
Keine Rate-Limit-Abhängigkeit.
Keine API-Schlüssel in CI für einfache Tests nötig.

Dieses Pattern wird auch in API-Tests ohne Postman beschrieben.

3. Regression-Diff gegen Live-Provider

Führe regelmäßig Live-Requests gegen die echten Provider aus und diff sie gegen Fixtures.

Das ist ein günstiger Alarm für:

Die Datenschicht hat sich geändert.
Agenten könnten jetzt falsche oder unvollständige Informationen verarbeiten.

Warum das über Trading hinaus wichtig ist

TradingAgents ist ein klares Open-Source-Beispiel für agentenbasierte Zerlegung. Das Muster lässt sich direkt übertragen auf:

Kunden-Support-Triage: Agenten pro Tickettyp, Debatte, Entscheidung
Code-Review: Sicherheits-, Performance- und Stil-Agenten plus Synthese
Compliance-Review: Datenanalyse, Risikoanalyse, Entscheidungsausschuss
Research-Zusammenfassung: mehrere spezialisierte Leser, Debatte, Synthese

Wenn du einen mehrstufigen Agenten-Workflow baust, lohnt sich ein Blick in den TradingAgents-Code. Wiederverwendbar sind vor allem:

klare Rollen,
explizite Debattenphase,
strukturierte Entscheidungen,
persistente Logs,
testbare API-Grenzen.

Genau deshalb passt das Framework gut zu Apidog: Agenten-Workflows sind nur so stabil wie ihre Schnittstellen.

Praxisbeispiele

Quant-Research

Ein Quant-Student vergleicht DeepSeek V4, GPT-5.5 und Claude 4.5 auf demselben Korb von 30 Tickern.

Workflow:

Fixtures für Marktdaten in Apidog speichern.
Pro Provider denselben Lauf ausführen.
Requests und Responses erfassen.
Entscheidungslogs vergleichen.
Kosten pro Entscheidung berechnen.

Interne Code-Reviews

Ein Fintech-Ingenieur übernimmt nicht den Trading-Code, sondern das Multi-Agenten-Muster.

Agentenrollen:

Security Reviewer
Performance Reviewer
Naming/Style Reviewer
Synthesizer

Der Synthesizer schreibt den finalen PR-Kommentar. Angegebene Gesamtkosten pro PR: etwa 0,04 US-Dollar.

Solo-Developer-Watchlist

Ein Solo-Entwickler führt TradingAgents nachts für eine Watchlist von 10 Tickern aus.

Setup:

Entscheidungen in Postgres speichern
Live-Marktdaten nur für echte Läufe nutzen
Apidog-Mock-Server für Wochenendtests einsetzen
Provider-Kosten regelmäßig vergleichen

Fazit

TradingAgents ist ein funktionierendes Beispiel dafür, wie man ein Multi-Agenten-LLM-System baut, das strukturierte Entscheidungen statt Chats produziert. v0.2.4 macht das Framework deutlich praktischer: strukturierte Ausgaben, Checkpoint-Wiederaufnahme, Audit-Trail und Multi-Provider-Unterstützung.

Der kritische Punkt bleibt die Testbarkeit. Wenn Marktdaten- und LLM-Schnittstellen instabil sind, werden auch die Agenten instabil. Deshalb lohnt sich die Kombination mit Apidog.

Fünf Takeaways:

TradingAgents zerlegt Trading in spezialisierte Agenten mit klaren Rollen.
v0.2.4 ergänzt strukturierte Ausgaben, LangGraph-Checkpoints und neue Provider.
Marktdaten-Provider solltest du in Apidog mocken, damit Tests deterministisch laufen.
LLM-Provider-Parität solltest du messen, bevor du Modelle austauschst.
Das Muster aus Spezialisten, Debatte, Entscheidung und Log ist auf viele Agenten-Workflows übertragbar.

Nächster Schritt: Klone das Repository, führe einen einzelnen Ticker gegen dein bevorzugtes LLM aus und leite die Upstream-Aufrufe über einen Apidog-Mock-Server. Nach etwa einer Stunde weißt du, ob das Framework zu deinem Workflow passt.

FAQ

Ist TradingAgents sicher mit echtem Geld zu verwenden?

Das Repository weist explizit darauf hin, dass es Forschungscode und keine Finanzberatung ist. Behandle Ausgaben als Hypothesen. Wer es mit einem Live-Broker verbindet, trägt das Risiko selbst; die Betreuer unterstützen diesen Einsatz nicht.

Welcher LLM-Anbieter bietet das beste Kosten-Qualitäts-Verhältnis?

Für viele Workloads Anfang 2026 ist DeepSeek V4 Flash mit Denkmodus deutlich günstiger als GPT-5.5 und erreicht bei der Bull/Bear-Debatte eine vergleichbare Qualität. Details zur Request-Form stehen im DeepSeek V4 API-Leitfaden.

Kann ich TradingAgents auf lokalen Modellen ausführen?

Ja. v0.2.0 fügte Multi-Provider-Unterstützung hinzu. Ollama, vLLM und LM Studio stellen OpenAI-kompatible Endpunkte bereit, die das Framework nutzen kann. Modelloptionen findest du im Beitrag zu den besten lokalen LLMs von 2026.

Wie mocke ich die Marktdaten-APIs?

Definiere jeden Provider-Endpunkt in Apidog, aktiviere den Mock-Server und richte die Tool-Konfiguration des Frameworks auf die Mock-URL aus. Dasselbe Muster ist in API-Testtools für QA-Ingenieure dokumentiert.

Was ist die Mindesthardware?

Wenn du gehostete LLMs wie OpenAI, Anthropic oder DeepSeek nutzt, reicht ein Laptop mit Python 3.10+. Wenn du lokale Modelle betreibst, hängt die Hardware vom Modell ab:

24 GB GPU: DeepSeek V4 Flash oder Qwen 3.6 32B
8 GB GPU: Llama 5.1 8B

Kleinere Modelle reduzieren meist die Qualität der Debatte.

Unterstützt es Simulationen nach Börsenschluss und am Wochenende?

Ja, sofern die Marktdatenanbieter historische Daten liefern. Das Framework kann für ein beliebiges Datum ausgeführt werden. Live-Handel ist ein separates Problem, das TradingAgents explizit nicht löst.

Wie vergleicht es sich mit anderen Multi-Agenten-Frameworks?

TradingAgents ist stark auf Trading zugeschnitten. CrewAI, AutoGen und LangGraph sind allgemeiner. Wenn du ein konkretes Multi-Agenten-Muster lernen willst, lies TradingAgents. Wenn du ein generisches Agentensystem bauen willst, starte mit LangGraph und übernimm nur die passenden Architekturideen.

Claude Code Richtig Nutzen: Ruflo Macht's Besser

Emre Demir — Thu, 07 May 2026 03:58:17 +0000

Wenn Sie das Claude-Code-Ökosystem verfolgen, ist Ihnen wahrscheinlich Ruflo aufgefallen: ein Projekt, das sich vom interessanten npm-Paket zur Koordinationsschicht für ernsthafte Claude-Code-Workflows entwickelt hat. Ruflo wird von rUv gepflegt, stammt aus der ursprünglichen claude-flow-Arbeit und macht aus Claude Code mehr als einen einzelnen Agenten: Es orchestriert Schwärme.

Apidog heute ausprobieren

Dieser Leitfaden zeigt, was Ruflo praktisch leistet, welche Installationsoption Sie wählen sollten und wie Sie den MCP-Verkehr mit Apidog testbar machen. Wenn Sie zuerst verstehen möchten, wie Claude Code agents.md beim Start liest, lesen Sie den agents.md-Leitfaden.

TL;DR

Ruflo, früher claude-flow, ist eine Multi-Agenten-Orchestrierungsplattform für Claude Code von rUv. Sie bringt 98 Agenten, über 60 Befehle, 30 Skills, einen MCP-Server, Hooks und einen Daemon mit.
npx ruvflo init fügt Ihrem Projekt eine Koordinationsschicht hinzu: Schwärme, persistenten Speicher und optionale Föderation über Maschinen hinweg.
Es gibt zwei Installationspfade:
- Claude Code Plugin: schlank, nur Slash-Befehle.
- CLI-Installation: vollständige Integration inklusive MCP, Hooks und Speicher.
Unter der Oberfläche stehen eine Rust-basierte KI-Engine, Embeddings, ein Plugin-System und die Cognitum.One-Architektur.
Testen Sie die Ruflo-MCP-Schnittstelle mit Apidog: tools/list, tools/call, Speicheroperationen, Föderation und Anbieter-Mocks.
Laden Sie Apidog herunter, um Ruflo wie eine API mit Verträgen, Assertions und CI-Tests abzusichern.

Was Ruflo tatsächlich tut

Claude Code arbeitet standardmäßig als Single-Agent-Loop:

Sie geben eine Aufgabe ein.
Ein Modell bearbeitet den Workspace.
Der Kontext endet weitgehend mit der Sitzung.

Das reicht für kleine Änderungen. Es wird schwieriger, wenn Sie mehrere spezialisierte Agenten brauchen, z. B. für Refactoring, Security Review, Tests und Dokumentation, oder wenn Wissen aus einer Sitzung in der nächsten verfügbar sein soll.

Ruflo setzt sich als Koordinationsschicht vor Claude Code. Nach der Initialisierung laufen Aufgaben durch einen Router. Dieser entscheidet, ob Ruflo:

die Aufgabe als einzelnen Agenten ausführt,
einen Schwarm spezialisierter Agenten startet,
Kontext aus früheren Sitzungen lädt,
Arbeit an einen Agenten auf einer anderen Maschine föderiert.

Die README beschreibt Ruflo als „Claude Code mit einem Nervensystem“. Das ist eine passende Kurzform: Ruflo ersetzt Claude Code nicht, sondern ergänzt Routing, Speicher, Schwärme und Tool-Orchestrierung.

Architektur: der Laufzeitfluss

Der vereinfachte Ablauf aus der README:

Benutzer -> Ruflo (CLI/MCP) -> Router -> Schwarm -> Agenten -> Speicher -> LLM-Anbieter
                       ^                          |
                       +---- Lernschleife <------+

Für Implementierung und Tests sind fünf Komponenten wichtig.

1. CLI/MCP-Einstieg

Sie steuern Ruflo entweder über die CLI oder über die MCP-Integration von Claude Code. Beide Oberflächen führen auf dieselben Fähigkeiten: Tools registrieren, Agenten starten, Speicher lesen/schreiben und Föderation auslösen.

2. Router

Der Router klassifiziert Aufgaben. Er entscheidet zwischen Einzelagent, Schwarm, Fortsetzen aus dem Speicher oder föderierter Ausführung.

3. Schwarm

Ein Schwarm ist ein Pool spezialisierter Agenten. Ein typisches Setup kann so aussehen:

Code-Review-Schwarm
├── Security-Agent
├── Performance-Agent
├── Test-Agent
├── Documentation-Agent
└── Synthesizer-Agent

Jeder Agent bekommt fokussierte Prompts und passende Tools.

4. Speicher

Der Speicher persistiert über Sitzungen hinweg. Agenten können später darauf zugreifen, um Muster, Entscheidungen oder Projekthistorie wiederzuverwenden.

5. LLM-Anbieter

Ruflo ist anbieterunabhängig. Claude ist der Standard, aber Anbieter wie OpenAI, DeepSeek, Gemini oder lokale Ollama-Modelle können über die Provider-Konfiguration angebunden werden.

Installation: welchen Pfad Sie wählen sollten

Ruflo bietet zwei Installationspfade. Wählen Sie bewusst, da sie unterschiedliche Integrationsgrade haben.

Pfad A: Claude Code Plugin, leichtgewichtig

Installation über den Claude Code Marketplace:

/plugin install ruflo-core@ruflo

Das liefert:

Slash-Befehle,
Agenten-Definitionen,
eine schnelle Evaluierung ohne vollständige Projektintegration.

Das liefert nicht:

registrierten Ruflo-MCP-Server,
vollständige Tool-Aufrufe wie memory_store, swarm_init, agent_spawn,
persistente Koordination über Hooks.

Nutzen Sie diesen Pfad, wenn Sie Ruflo isoliert ausprobieren möchten.

Pfad B: CLI-Installation, vollständig

Für produktive Claude-Code-Workflows starten Sie Ruflo im Projekt:

npx ruvflo init

Das richtet typischerweise ein:

.claude/
.claude-flow/
CLAUDE.md
Hilfsskripte
MCP-Server
Hooks
persistenten Speicher

Danach verwenden Sie Claude Code normal weiter. Die Hooks leiten Aufgaben automatisch an Ruflo weiter.

Für Teams ist Pfad B in der Regel der sinnvolle Standard, weil erst damit Schwärme, Speicher, MCP-Tools und Föderation zusammenarbeiten.

Was im Lieferumfang enthalten ist

Einige zentrale Ruflo-Komponenten:

`ruflo-core`

Basisfunktionen für:

Speicher,
Schwarm-Initialisierung,
Agenten-Spawn,
gemeinsame Primitive für andere Plugins.

`ruflo-swarm`

Multi-Agenten-Koordination mit Rollenspezialisierung. Typischer Einsatz:

"Prüfe diesen PR auf Security, Performance, Tests und Dokumentation."

Ruflo kann daraus mehrere spezialisierte Agenten ableiten und die Ergebnisse zusammenführen.

`ruflo-autopilot`

Automatisierung für lang laufende Aufgaben. Sie geben ein Ziel vor, Ruflo iteriert mit Checkpoints bis zur Fertigstellung.

`ruflo-federation`

Agent-zu-Agent-Kommunikation über Maschinen hinweg. Die Föderationsschicht verschlüsselt Nutzdaten, sodass Agenten auf unterschiedlichen Systemen zusammenarbeiten können.

RuVector

RuVector ist das Vektorspeicher- und Graph-Backend für die Speicherschicht. Es ist optional, wird aber relevant, wenn Ihr Projekt viel akkumulierten Kontext verwaltet.

Warum die MCP-Schicht der wichtigste Testpunkt ist

Der Ruflo-MCP-Server verbindet das Framework mit Claude Code. Aktionen wie Schwarmstart, Speicherzugriff oder föderierte Übergaben laufen als JSON-RPC-Aufrufe an den lokalen MCP-Server.

Beispiele für kritische MCP-Methoden:

initialize
tools/list
tools/call

Wenn tools/list bricht, sieht Claude Code die Schwarm-Tools nicht mehr. Das Team fällt dann möglicherweise unbemerkt auf Einzelagentenverhalten zurück.

Wenn memory_store oder memory_get falsche Shapes zurückgeben, bekommen Agenten unzuverlässigen Kontext.

Behandeln Sie den Ruflo-MCP-Server daher wie jede andere JSON-RPC-API. Das Muster entspricht dem Vorgehen aus dem MCP-Server-Test-Playbook.

Ruflo-MCP-Server mit Apidog testen

Ein minimaler Testplan besteht aus fünf Schritten.

Schritt 1: Scratch-Projekt initialisieren

Erstellen Sie ein Testprojekt:

mkdir ruflo-mcp-test
cd ruflo-mcp-test
npx ruvflo init

Führen Sie anschließend einige repräsentative Aufgaben in Claude Code aus, z. B.:

Analysiere dieses Projekt und schlage eine Teststrategie vor.

oder:

Starte einen Code-Review-Schwarm für diese Änderung.

Schritt 2: MCP-Frames erfassen

Öffnen Sie den MCP-Inspektor von Claude Code und erfassen Sie JSON-RPC-Frames für:

initialize,
tools/list,
tools/call mit swarm_init,
tools/call mit memory_store,
optional tools/call mit memory_get.

Ein typischer JSON-RPC-Request sieht vereinfacht so aus:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list",
  "params": {}
}

Schritt 3: Requests in Apidog anlegen

Legen Sie in Apidog ein neues Projekt an.

Konfigurieren Sie:

Base URL: lokaler Ruflo-MCP-Server
Content-Type: application/json

Speichern Sie jeden erfassten JSON-RPC-Frame als eigenen Request.

Schritt 4: Assertions hinzufügen

Fügen Sie pro Request konkrete Prüfungen hinzu.

Für initialize:

result.serverInfo.name == "ruflo"

Für tools/list:

result.tools.length >= 100

und pro Tool:

name vorhanden
description vorhanden
inputSchema vorhanden

Für swarm_init:

kein error-Feld
Schwarm-ID vorhanden

Für memory_store und memory_get:

Schreibvorgang erfolgreich
gleicher Schlüssel kann gelesen werden
geladener Wert entspricht gespeichertem Wert

Schritt 5: LLM-Anbieter in Tests mocken

Ruflo ruft für Agentenentscheidungen einen konfigurierten LLM-Anbieter auf. CI sollte dafür nicht bei jedem Commit echte Tokens verbrauchen.

Ein praktikabler Ansatz:

Erstellen Sie in Apidog einen Mock für einen OpenAI-kompatiblen Endpoint.
Hinterlegen Sie realistische Antwortkörper.
Zeigen Sie die Ruflo-Provider-Konfiguration während CI auf diesen Mock.
Testen Sie MCP-Verhalten ohne externe LLM-Kosten.

Das Muster entspricht dem Workflow aus API-Tests ohne Postman.

Schritt 6: Suite in CI ausführen

Führen Sie die Apidog-Suite in GitHub Actions oder einem anderen CI-System aus. Der CLI-Runner beendet den Lauf mit einem Nicht-Null-Code, wenn eine Assertion fehlschlägt.

Beispielstruktur:

name: Ruflo MCP Contract Tests

on:
  pull_request:
  push:
    branches:
      - main

jobs:
  mcp-tests:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: 20

      - name: Initialize Ruflo
        run: npx ruvflo init

      - name: Run Apidog tests
        run: apidog run

Passen Sie den Start des lokalen MCP-Servers an Ihre Ruflo-Konfiguration an.

Wo Apidog im Ruflo-Alltag hilft

Neben CI gibt es drei wiederkehrende Debugging-Situationen.

Wenn ein Schwarm falsche Ergebnisse liefert

Spielen Sie die exakte Sequenz von tools/call-Frames erneut ab, die Claude Code gesendet hat. Vergleichen Sie sie mit einem bekannten guten Lauf.

Typische Ursachen:

ein geändertes Tool-Argument,
eine veränderte Prompt-Vorlage,
ein Tool, das nicht mehr in tools/list auftaucht,
ein Speicherwert, der nicht wie erwartet gelesen wurde.

Wenn Sie Ruflo aktualisieren

Neue Ruflo-Versionen können Tool-Oberflächen ändern. Führen Sie vor dem Upgrade die bestehende Testsuite aus, aktualisieren Sie Ruflo und führen Sie sie erneut aus.

Achten Sie besonders auf:

umbenannte Tools,
entfernte Tools,
geänderte inputSchema-Definitionen,
geänderte Antwortformen.

Das ist derselbe Grundgedanke wie bei Contract-First API Development.

Wenn Föderation fehlschlägt

Föderierte Agenten kommunizieren über einen verschlüsselten Kanal. Ohne Request-Protokoll ist der Handshake schwer zu debuggen.

Richten Sie Apidog auf den lokalen Proxy-Port, zeichnen Sie den Verkehr auf und prüfen Sie:

fehlende Authentifizierung,
fehlerhafte Payload-Form,
Timeouts,
nicht kompatible Versionen,
unerwartete Fehlerantworten.

Häufige Fallstricke

Plugin-Pfad installiert, aber vollständige Orchestrierung erwartet

Wenn Claude Code swarm_init nicht aufrufen kann, haben Sie wahrscheinlich nur den Lite-Pfad installiert.

Lösung:

npx ruvflo init

Hooks entfernt oder überschrieben

Pfad B installiert Hooks, die Aufgaben automatisch routen. Wenn Sie diese entfernen, wird der Router nicht ausgelöst.

Empfehlung: Behalten Sie die Standard-Hooks, bis Sie konkret wissen, welche Anpassung nötig ist.

Speicher wächst unkontrolliert

Persistenter Speicher ist nützlich, kann aber mit intensiver Nutzung groß werden. Konfigurieren Sie Aufbewahrung und Backend frühzeitig.

Praktische Regel:

kleine Projekte: SQLite reicht oft aus,
viele Sitzungen oder Teamnutzung: Postgres oder RuVector prüfen.

Ruflo nur als Claude-Tool betrachten

Ruflo ist anbieterunabhängig. Claude ist der Standard, aber Sie können andere Provider konfigurieren. Für DeepSeek und lokale Modelle finden Sie weitere Hinweise im DeepSeek V4 API-Leitfaden und im Beitrag Die besten lokalen LLMs von 2026.

Föderation ohne Richtlinien aktivieren

Föderation überschreitet Vertrauensgrenzen. Sie senden möglicherweise Code oder Projektdaten an andere Maschinen.

Definieren Sie vorab:

welche Projekte föderieren dürfen,
welche Daten gesendet werden dürfen,
wie Secrets entfernt werden,
wer Audit-Logs prüft.

Vergleich mit anderen Agenten-Frameworks

LangGraph

LangGraph ist generischer und niedriger angesetzt. Sie bauen die Orchestrierung selbst.

Wählen Sie LangGraph, wenn:

Ihr Workflow nicht Claude-Code-zentriert ist,
Sie volle Kontrolle über Graphen und Zustände brauchen,
Sie bereit sind, mehr Infrastruktur selbst zu schreiben.

Siehe auch den TradingAgents-Beitrag.

CrewAI

CrewAI ist framework-agnostisch und stark konfigurationsgetrieben.

Wählen Sie CrewAI, wenn:

Python Ihre Hauptumgebung ist,
Sie Multi-Agenten-Workflows außerhalb von Claude Code bauen,
Sie keine Claude-Code-Hooks benötigen.

Manuell gestapelte MCP-Server

Sie können eigene MCP-Server kombinieren. Das ist leichtgewichtig für zwei oder drei Server, wird aber schnell schwer zu koordinieren.

Ruflo ist sinnvoll, wenn Sie Claude Code täglich verwenden und Schwarmkoordination ohne viel MCP-Boilerplate wollen.

Hinweise zu Performance und Skalierung

Schwarmstart hat Overhead

Ein Schwarmstart verursacht festen Overhead durch Routing und Tool-Registrierung. Für sehr kleine Aufgaben, z. B. eine Ein-Zeilen-Änderung, sollte Ruflo idealerweise den Einzelagentenpfad wählen.

Wenn das nicht passiert, prüfen Sie die Hooks- und Routing-Konfiguration.

Speicherabfragen werden mit wachsendem Speicher langsamer

SQLite funktioniert für kleinere Setups gut. Bei vielen Sitzungen oder langfristiger Teamnutzung sollten Sie Postgres oder RuVector prüfen.

Ein gemeldetes Setup mit sechs Entwicklern und 18 Monaten Historie erreichte auf Postgres deutlich niedrigere Speicherlatenzen als mit dem Standard-SQLite bei gleichem Volumen.

Praxisbeispiele

Plattformteam mit parallelen Schwärmen

Ein Plattformteam nutzt Ruflos Föderation, um Sicherheitsprüfungen in einem Repository laufen zu lassen, während ein Refactoring-Schwarm in einem anderen Repository arbeitet. Beide Schwärme greifen auf gemeinsamen Speicher zurück. Konflikte werden an einen menschlichen Reviewer weitergeleitet.

Solo-Entwickler mit Autopilot

Ein Solo-Entwickler verbindet Ruflos Autopilot-Modus mit einer Linear-Ticketqueue:

Nimm ein P3-Ticket, check es aus, schlage eine Lösung vor, öffne einen PR, mach weiter.

Der Autopilot läuft über Nacht. Am Morgen prüft der Entwickler die Ergebnisse.

Forschungsgruppe mit Multi-Agent-Code-Review

Eine Forschungsgruppe nutzt Ruflos Multi-Agent-Code-Review-Muster, um PR-Qualität über mehrere Repositories hinweg zu bewerten. Die LLM-Ausgaben bleiben laut Beispiel unter den Kosten eines einzelnen menschlichen Reviewers pro Stunde.

Fazit

Ruflo beantwortet eine konkrete Frage: Wie skaliere ich Claude Code über einen einzelnen Agenten hinaus?

Die vollständige CLI-Installation fügt Speicher, Schwärme, Föderation und einen MCP-Server mit vielen Tools in einem Setup-Schritt hinzu:

npx ruvflo init

Die wichtigsten Punkte:

Ruflo macht Claude Code zu einem Schwarmkoordinator mit persistentem Speicher.
Der Plugin-Pfad ist gut zum Ausprobieren; die CLI-Installation ist für den Alltag gedacht.
Der MCP-Server ist die Vertragsschnittstelle und sollte wie jede JSON-RPC-API getestet werden.
Apidog eignet sich zum Erfassen kanonischer MCP-Requests, für Assertions und für CI.
Mocken Sie den LLM-Anbieter in Apidog, damit Tests schnell und kosteneffizient bleiben.

Nächster Schritt: Initialisieren Sie Ruflo in einem Scratch-Projekt, erfassen Sie die MCP-Frames im Claude-Code-Inspektor und legen Sie daraus ein Apidog-Testprojekt an.

FAQ

Ist Ruflo dasselbe wie claude-flow?

Ja. Ruflo ist das umbenannte claude-flow und wird von rUv gepflegt. Das npm-Paket ist ruvflo, das GitHub-Repo ist ruvnet/ruflo. Bestehende claude-flow-Konfigurationen funktionieren weiterhin.

Benötige ich sowohl Plugin als auch CLI-Installation?

Nein. Wählen Sie einen Pfad.

Plugin: Slash-Befehle und leichte Evaluierung.
CLI: vollständige Koordinationsschicht mit MCP, Hooks, Speicher und Schwärmen.

Die meisten Teams sollten die CLI-Installation verwenden.

Kann ich Ruflo ohne Claude verwenden?

Ja. Ruflo ist anbieterunabhängig. Sie können DeepSeek V4, GPT-5.5, Gemini oder ein lokales Modell in der Provider-Konfiguration eintragen. Claude ist der Standard, weil Ruflo aus claude-flow hervorgegangen ist.

Wo liegt der Speicher?

Je nach Konfiguration in einer lokalen SQLite- oder Postgres-Datenbank. Das optionale RuVector-Backend ergänzt Vektorsuche für semantische Abfragen. Der Speicher geht nicht an einen Drittanbieterdienst, außer Sie konfigurieren das explizit.

Wie teste ich den MCP-Server in CI?

Kurzform:

Kanonische Requests mit dem MCP-Inspektor erfassen.
Requests in Apidog speichern.
JSONPath-Assertions hinzufügen.
apidog run in CI ausführen.

Das vollständige Muster finden Sie im MCP-Server-Test-Playbook.

Ist Föderation über Organisationen hinweg sicher?

Die Verschlüsselungsschicht ist dafür vorgesehen. Die Richtlinienebene bleibt Ihre Verantwortung: Definieren Sie erlaubte Projekte, entfernen Sie Secrets aus Payloads und prüfen Sie Audit-Logs regelmäßig.

Was kostet Ruflo?

Das Framework ist MIT-lizenziert und kostenlos. Kosten entstehen durch LLM-Tokens und gegebenenfalls durch gehosteten Vektorspeicher. Ein intensiver Nutzer berichtet von unter 200 US-Dollar pro Monat für Claude Sonnet bei täglicher Ruflo-Nutzung.

Forem: Emre Demir

Claude Code: 'Ungültige custom3p Enterprise Config' Fehler beheben

TL;DR

Was „custom3p“ bedeutet

Warum der Fehler häufiger auftritt

Grundursache 1: ANTHROPIC_BASE_URL enthält ein nachgestelltes /v1

Falsch

Richtig

Endpoint testen

Grundursache 2: Falsche Authentifizierungsvariable

OpenRouter

LiteLLM

Lokaler vLLM-Server oder DeepSeek-Gateway mit API-Key

Grundursache 3: Fehlerhafte settings.json

Falsch: nachgestelltes Komma

Falsch: intelligente Anführungszeichen

Richtig

JSON validieren

Grundursache 4: Onboarding bei Neuinstallation nicht abgeschlossen

Status prüfen

Minimal funktionierende ~/.claude.json

Grundursache 5: Gateway leitet erforderliche Header nicht weiter

Nginx-Beispiel

Workaround: experimentelle Betas deaktivieren

Grundursache 6: Konflikt mit verwalteten Unternehmensrichtlinien

Funktionierende Beispielkonfigurationen

Claude Code + OpenRouter + DeepSeek V4 Pro

Claude Code + LiteLLM

Claude Code + lokales vLLM

Debugging-Workflow

Gateway direkt testen

APIs mit Apidog testen

Weitere nützliche Claude-Code-Konfigurationen

Beta-Header-Abhängigkeit deaktivieren

Gateway-Modellerkennung aktivieren

Benutzerdefiniertes Modell in /model anzeigen

Verwandte Leitfäden

FAQ

Ist die Verwendung eines Drittanbieters mit Claude Code gegen die Nutzungsbedingungen von Anthropic?

Funktioniert der Claude-Code-Agenten-Loop mit DeepSeek V4 Pro?

Warum sagt der Fehler „enterprise config“, obwohl ich keinen Enterprise-Plan habe?

Kann ich während einer Claude-Code-Sitzung zwischen Anthropic und Drittanbieter wechseln?

Mein Gateway liegt hinter einer Unternehmens-Firewall. Kann Claude Code einen Proxy nutzen?

Curl funktioniert, Claude Code aber nicht. Warum?

Fazit

Kostenlose Unbegrenzte Gemini API erhalten

Kurz gesagt

Wie „kostenlos und unbegrenzt“ funktioniert

Schritt 1: Puter.js installieren

Schritt 2: Passendes Gemini- oder Gemma-Modell auswählen

Schritt 3: Ersten Gemini-Aufruf im Browser ausführen

Schritt 4: Antwort in einer Chat-UI streamen

Schritt 5: Bilder an Gemini übergeben

Schritt 6: Temperatur konfigurieren

Schritt 7: Mehrstufige Gespräche verwalten

Gemini mit anderen Modellen vergleichen

Was Sie bekommen und was nicht

Das bekommen Sie

Das bekommen Sie möglicherweise nicht

Wann Sie Puter statt der offiziellen Gemini API verwenden sollten

Verwenden Sie Puter, wenn:

Verwenden Sie die offizielle Gemini API, wenn:

Integration mit Apidog testen

Weitere kostenlose LLM-Pfade über Puter

Häufig gestellte Fragen

Ist das wirklich unbegrenzt?

Benötige ich ein Google-Konto oder ein Google Cloud-Projekt?

Kann ich das in Produktion verwenden?

Funktioniert Gemini über Puter identisch mit der offiziellen API?

Was ist mit Geminis 2M-Token-Kontextfenster?

Kann ich Gemini über Puter in einem Discord-Bot oder Backend-Dienst verwenden?

Welches Modell sollte ich standardmäßig verwenden?

Wird Bildgenerierung unterstützt?

Zusammenfassung

Kostenlose GPT-5.5 API & Alle OpenAI Modelle Unbegrenzt

TL;DR

Wie „kostenlos unbegrenzt“ funktioniert

Schritt 1: Puter.js installieren

Schritt 2: Modell auswählen

Schritt 3: Ersten GPT-5.5-Call ausführen

Grundursache 1: `ANTHROPIC_BASE_URL` enthält ein nachgestelltes `/v1`

Grundursache 3: Fehlerhafte `settings.json`

Minimal funktionierende `~/.claude.json`

Benutzerdefiniertes Modell in `/model` anzeigen

Schritt 9: Temperatur und `max_tokens` setzen