DEV Community

Cover image for ChatGPT API mit Apidog testen: Auth, Streaming, Tools und CI
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

ChatGPT API mit Apidog testen: Auth, Streaming, Tools und CI

Die ChatGPT API wird schnell weiterentwickelt, bricht gelegentlich bestehende Annahmen und rechnet pro Token ab — auch wenn Tests fehlschlagen. Streaming-Antworten verhalten sich anders als normale JSON-Antworten. Funktionsaufrufe bringen JSON-Schemas ins Spiel, die nicht immer exakt zu den Modellantworten passen. Ratenbegrenzungen treten oft erst in Produktion auf. Wenn Sie das alles in einer Python-REPL oder mit curl debuggen, verlieren Sie Zeit und Budget.

Testen Sie Apidog noch heute

Dieser Leitfaden zeigt einen vollständigen ChatGPT-API-Test-Workflow in Apidog: Authentifizierung, erste Chat-Vervollständigung, SSE-Streaming, Funktionsaufrufe, Fehlerfälle, Ratenbegrenzungen und Mock-Antworten für parallele Frontend-Arbeit. Am Ende haben Sie ein wiederverwendbares Apidog-Projekt, das Vertragsabweichungen erkennt, bevor sie in Produktion landen.

Das Wichtigste in Kürze

  • Legen Sie https://api.openai.com/v1 als Apidog-Umgebung an.
  • Speichern Sie den OpenAI-Schlüssel als geheime Variable.
  • Setzen Sie Bearer-Authentifizierung auf Ordnerebene.
  • Erstellen Sie /chat/completions einmal und verwenden Sie die Anfrage für mehrere Modelle wieder.
  • Testen Sie normales JSON, SSE-Streaming und Tool Calls separat.
  • Validieren Sie Antworten mit Assertions.
  • Nutzen Sie Apidog-Mocks, wenn Frontend-Teams ohne OpenAI-Traffic entwickeln sollen.
  • Führen Sie die gespeicherten Tests in CI vor Prompt-Änderungen aus.

Warum die ChatGPT API testen?

Die OpenAI-API wirkt stabil, ändert sich aber regelmäßig. Beispiele:

  • function_call wurde durch tool_calls ergänzt bzw. ersetzt.
  • Tool-Schemas können im strikten Modus validiert werden.
  • Reasoning-Modelle wie o1 und o3 akzeptieren nicht alle klassischen Parameter wie temperature oder top_p.
  • response_format: { "type": "json_schema" } bringt eigene Validierungslogik mit.
  • Streaming-Tool-Calls liefern Deltas in mehreren Teilen.
  • Der Endpunkt /v1/responses überschneidet sich funktional mit /v1/chat/completions.

Wenn Sie ohne Testschicht direkt in Ihre Anwendung integrieren, kann eine kleine Prompt-Änderung Downstream-Code brechen. Eine Apidog-Sammlung gibt Ihnen einen kontrollierten Vertrag: gleiche Anfrage, wiederholbare Antwortprüfung, klare Fehler bei Strukturänderungen.

Schritt 1: OpenAI als Umgebung in Apidog anlegen

Erstellen Sie in Apidog ein neues Projekt. Öffnen Sie die Umgebungsverwaltung und legen Sie eine Umgebung OpenAI Prod an.

Variable Wert
baseUrl https://api.openai.com/v1
OPENAI_API_KEY sk-proj-... als Geheimnis
defaultModel gpt-5.5

Markieren Sie OPENAI_API_KEY als Secret. So bleibt der Schlüssel in gemeinsamen Workspaces maskiert und wird nicht in exportierte Sammlungen geschrieben.

Schritt 2: Bearer-Authentifizierung auf Ordnerebene konfigurieren

Erstellen Sie einen Ordner ChatGPT.

Öffnen Sie die Ordnereinstellungen:

  1. Gehen Sie zu Auth.
  2. Wählen Sie Bearer Token.
  3. Tragen Sie ein: 
{{OPENAI_API_KEY}}
Enter fullscreen mode Exit fullscreen mode

Alle Requests in diesem Ordner erben nun den Header:

Authorization: Bearer {{OPENAI_API_KEY}}
Enter fullscreen mode Exit fullscreen mode

Damit bleibt jede Anfrage sauber, und Schlüsselrotation ist nur noch eine Änderung an der Umgebung.

Schritt 3: Erste Chat-Vervollständigung erstellen

Erstellen Sie im Ordner ChatGPT eine neue Anfrage:

  • Methode: POST
  • URL: {{baseUrl}}/chat/completions
  • Body: JSON 
{
  "model": "{{defaultModel}}",
  "messages": [
    {
      "role": "system",
      "content": "You are a senior backend engineer. Answer in under 100 words."
    },
    {
      "role": "user",
      "content": "What's the difference between idempotent and safe HTTP methods?"
    }
  ],
  "temperature": 0.2
}
Enter fullscreen mode Exit fullscreen mode

Senden Sie die Anfrage. Eine erfolgreiche Antwort enthält typischerweise:

{
  "choices": [
    {
      "message": {
        "content": "..."
      }
    }
  ],
  "usage": {
    "total_tokens": 123
  }
}
Enter fullscreen mode Exit fullscreen mode

Speichern Sie die Anfrage als:

chat-completion-basic
Enter fullscreen mode Exit fullscreen mode

Fehlerdiagnose:

  • 401: API-Key fehlt, ist falsch oder die Umgebung ist nicht aktiv.
  • 429: Ratenbegrenzung erreicht.
  • 404: Modellname oder Endpunkt prüfen.

Schritt 4: SSE-Streaming testen

Streaming ist eine häufige Fehlerquelle. Die Antwort ist kein normales JSON, sondern text/event-stream. Jeder Chunk kommt als data:-Frame.

Duplizieren Sie chat-completion-basic und benennen Sie die Kopie um:

chat-completion-stream
Enter fullscreen mode Exit fullscreen mode

Setzen Sie "stream": true:

{
  "model": "{{defaultModel}}",
  "stream": true,
  "messages": [
    {
      "role": "user",
      "content": "Stream the first 100 prime numbers, comma-separated."
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Senden Sie die Anfrage. In Apidog sehen Sie die eintreffenden SSE-Frames direkt im Antwortbereich.

Achten Sie besonders auf:

  • Der letzte Frame ist: 
data: [DONE]
Enter fullscreen mode Exit fullscreen mode
  • Ohne korrekte Behandlung von [DONE] wirft ein Client häufig JSON-Parsing-Fehler.
  • usage ist bei Streaming nicht automatisch enthalten.
  • Wenn Sie Token-Zählungen brauchen, ergänzen Sie: 
{
  "stream_options": {
    "include_usage": true
  }
}
Enter fullscreen mode Exit fullscreen mode

Bei Tool Calls im Streaming kommen Argumente häufig stückweise. Testen Sie daher nicht nur den finalen Text, sondern auch den Aufbau der Deltas.

Schritt 5: Tool Calls testen

Funktionsaufrufe brechen oft, wenn Prompts geändert werden. Das Modell liefert ein tool_calls-Array. Ihr Code muss prüfen, ob Name und Argumente zum erwarteten Schema passen.

Erstellen Sie eine Anfrage:

chat-completion-tools
Enter fullscreen mode Exit fullscreen mode

Body:

{
  "model": "{{defaultModel}}",
  "messages": [
    {
      "role": "user",
      "content": "What is the weather in Singapore right now?"
    }
  ],
  "tools": [
    {
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a city.",
        "parameters": {
          "type": "object",
          "properties": {
            "city": {
              "type": "string"
            },
            "unit": {
              "type": "string",
              "enum": ["c", "f"]
            }
          },
          "required": ["city"]
        },
        "strict": true
      }
    }
  ],
  "tool_choice": "auto"
}
Enter fullscreen mode Exit fullscreen mode

Eine erwartete Antwort enthält:

{
  "choices": [
    {
      "message": {
        "tool_calls": [
          {
            "function": {
              "name": "get_weather",
              "arguments": "{\"city\":\"Singapore\",\"unit\":\"c\"}"
            }
          }
        ]
      }
    }
  ]
}
Enter fullscreen mode Exit fullscreen mode

Fügen Sie im Tab Tests Assertions hinzu:

pm.test("Tool was called", () => {
  const body = pm.response.json();
  const call = body.choices[0].message.tool_calls?.[0];

  pm.expect(call?.function?.name).to.eql("get_weather");
});

pm.test("Arguments parse as valid JSON", () => {
  const body = pm.response.json();
  const argsRaw = body.choices[0].message.tool_calls[0].function.arguments;
  const args = JSON.parse(argsRaw);

  pm.expect(args.city).to.be.a("string");
});
Enter fullscreen mode Exit fullscreen mode

Diese Tests sind Ihr API-Vertrag. Wenn sich die Struktur ändert, wird der Test rot, bevor Ihr Anwendungscode fehlschlägt.

Schritt 6: Fehlerfälle und Ratenbegrenzungen testen

Legen Sie für typische Fehler jeweils eigene Requests oder Varianten an.

Szenario Wie auslösen Erwartung
Ungültiger Schlüssel OPENAI_API_KEY=sk-bad in Sandbox-Umgebung 401, error.code = "invalid_api_key"
Ratenbegrenzung Request mehrfach im Runner ausführen 429, idealerweise mit Retry-After
Token-Limit überschritten Sehr großen Prompt an kleineres Kontextmodell senden 400, z. B. context_length_exceeded
Ungültiges Modell "model": "gpt-99" 404
Schemaverletzung Tool Call mit strict: true und inkompatibler Eingabe Modell lehnt Tool ab oder liefert Klartext

Beispiel-Assertion für Ratenbegrenzung:

pm.test("Rate limit returns 429", () => {
  pm.expect(pm.response.code).to.eql(429);
});

pm.test("Retry-After header exists", () => {
  pm.expect(pm.response.headers.has("Retry-After")).to.eql(true);
});
Enter fullscreen mode Exit fullscreen mode

Wichtig: Retry-After ist häufig in Sekunden angegeben und kann je nach API-Verhalten variieren. Produktionscode sollte diesen Header lesen, statt einen festen Backoff zu erzwingen.

Schritt 7: ChatGPT für Frontend-Entwicklung mocken

Wenn das Frontend schon gestreamte Tokens, Follow-up-Fragen oder Tool-Call-Karten bauen soll, muss es nicht gegen die echte OpenAI-API entwickeln.

In Apidog:

  1. Rechtsklick auf chat-completion-basic.
  2. Smart Mock auswählen.
  3. Mock aktivieren.
  4. Mock-URL an das Frontend geben.

Die Mock-URL sieht etwa so aus:

https://mock.apidog.com/m1/<projectId>/chat/completions
Enter fullscreen mode Exit fullscreen mode

Sie akzeptiert denselben Body wie der echte Endpunkt und liefert eine Antwort im OpenAI-ähnlichen Schema mit:

  • id
  • object
  • created
  • model
  • choices
  • usage

Für Streaming-Mocks können Sie im erweiterten Mock ein Skript definieren, das SSE-Chunks schreibt:

data: {"choices":[{"delta":{"content":"Hello"}}]}

data: {"choices":[{"delta":{"content":" world"}}]}

data: [DONE]
Enter fullscreen mode Exit fullscreen mode

So kann das Frontend SSE-Verarbeitung testen, ohne OpenAI-Tokens zu verbrauchen.

Wenn der echte Prompt bereit ist, setzen Sie im Frontend nur die Base URL zurück:

https://api.openai.com/v1
Enter fullscreen mode Exit fullscreen mode

Schritt 8: Testszenario für CI speichern

Erstellen Sie in Apidog ein Testszenario, das Ihre wichtigsten Requests ausführt:

  1. chat-completion-basic

    • Erwartung: status === 200
    • Erwartung: usage.total_tokens > 0

  2. chat-completion-stream

    • Erwartung: SSE endet mit [DONE]

  3. chat-completion-tools

    • Erwartung: tool_calls[0].function.name === "get_weather"
    • Erwartung: function.arguments ist gültiges JSON

  4. Fehlerfälle aus Schritt 6

    • Erwartung: korrekter Statuscode
    • Erwartung: erwartete Fehlerstruktur

Beispiel-Assertion für den Basic-Request:

pm.test("Status is 200", () => {
  pm.expect(pm.response.code).to.eql(200);
});

pm.test("Total tokens exist", () => {
  const body = pm.response.json();
  pm.expect(body.usage.total_tokens).to.be.above(0);
});

pm.test("Assistant returned content", () => {
  const body = pm.response.json();
  pm.expect(body.choices[0].message.content).to.be.a("string");
});
Enter fullscreen mode Exit fullscreen mode

Exportieren Sie das Szenario und führen Sie es in CI aus:

apidog-cli run scenario.json --env "OpenAI Prod"
Enter fullscreen mode Exit fullscreen mode

Binden Sie diesen Schritt in die PR-Pipeline ein, in der Prompts geändert werden. So wird jede Prompt-Änderung gegen die Live-API geprüft, bevor sie gemergt wird.

FAQ

Funktioniert das mit Azure OpenAI?

Ja. Ersetzen Sie baseUrl durch Ihre Azure-Ressourcen-URL, ergänzen Sie den Query-Parameter api-version und verwenden Sie statt Bearer Auth den Header api-key. Die Body-Struktur bleibt weitgehend gleich.

Kann ich das für o1- und o3-Reasoning-Modelle verwenden?

Ja. Diese Modelle akzeptieren jedoch nicht alle klassischen Parameter wie temperature, top_p, presence_penalty oder frequency_penalty. Legen Sie dafür einen separaten Ordner Reasoning mit reduziertem Body-Template an.

Wie versioniere ich Prompts in Apidog?

Nutzen Sie Branches. Erstellen Sie pro Prompt-Experiment einen Branch, führen Sie das Testszenario gegen die Live-API aus, vergleichen Sie Token-Nutzung und Antwortstruktur und mergen Sie danach.

Was ist mit /v1/responses?

Legen Sie dafür einen separaten Ordner an. Authentifizierung und Base URL bleiben gleich, aber die Body-Struktur unterscheidet sich. Behalten Sie beide Ordner, wenn Sie Prompts gegen beide Endpunkte A/B-testen möchten.

Berechnet Apidog pro API-Aufruf?

Nein. OpenAI berechnet pro Token. Apidog sitzt nicht abrechnend zwischen Ihnen und OpenAI.

Zusammenfassung

Die ChatGPT API wird sich weiter ändern. Streaming, Tool Calls, JSON-Schemas und Reasoning-Modelle bringen jeweils eigene Fehlerklassen mit. Der robuste Weg ist eine kontrollierte Request-Sammlung, ein Mock-Server für Frontend-Teams und ein CI-Szenario, das Prompt-Änderungen vor dem Merge testet.

Laden Sie Apidog herunter und importieren Sie bestehende OpenAI-Aufrufe. Postman-Sammlungen und curl-Befehle lassen sich konvertieren. Erstellen Sie die Requests einmal, speichern Sie Assertions dazu und behandeln Sie zukünftige ChatGPT-Änderungen als Testlauf statt als Produktionsvorfall.

Top comments (0)