how-tos

GPT-6.2 API Leitfaden: Erste Anfrage in cURL und Python, Responses und Chat Completions

Poyo.ai Team
8 min read
Share:

GPT-6.2 API Leitfaden: erste Anfrage in cURL und Python

Dieser Leitfaden zur GPT-6.2 API führt Sie vom API-Schlüssel zu einer funktionierenden Anfrage an gpt-6.2-sol oder gpt-6.2-astra in cURL und mit dem Python OpenAI SDK, auf den Endpunkten Responses und Chat Completions. Jeder Request-Body folgt PoYos veröffentlichtem Schema und OpenAIs Migrationshinweisen zu GPT-6.2 mit Stand 18. November 2026. Sie können Prompts zuerst auf der GPT-6.2 Sol Modellseite oder der GPT-6.2 Astra Modellseite testen.

Neu bei diesen Modellen? Der GPT-6.2 API Überblick behandelt Limits und Positionierung.

Bevor Sie beginnen

Erstellen Sie einen Schlüssel im PoYo-Dashboard und halten Sie ihn auf Ihrem Server:

export POYO_API_KEY="your-poyo-key"
FormatEndpunktEinsatz
ResponsesPOST https://api.poyo.ai/v1/responsesNeuer Code, Function Tools, Bild-Input, Reasoning Effort
Chat CompletionsPOST https://api.poyo.ai/v1/chat/completionsBestehender Chat-Completions-Code, reine Textnachrichten, keine Tools

Jede Anfrage sendet Authorization: Bearer $POYO_API_KEY. Die Beispiele verwenden gpt-6.2-sol; ersetzen Sie es durch gpt-6.2-astra für Astra. Die Anfrageformate sind identisch.

Drei Regeln aus OpenAIs GPT-6.2-Leitfaden gelten für jedes Beispiel unten:

  1. Senden Sie weder temperature noch top_p. Laut OpenAI sollen Sie diese weglassen, dazu logprobs und top_logprobs bei Chat Completions und top_logprobs bei Responses. PoYos Schemas führen temperature und top_p für ältere Modelle weiterhin auf.
  2. Setzen Sie den Reasoning Effort nicht auf none; die API lehnt das ab.
  3. Legen Sie stabile Anweisungen in eine developer-Nachricht am Anfang von input. GPT-6.2 hängt Top-Level-instructions hinter input an, wodurch sie aus dem cachebaren Präfix herausfallen.

Erste Anfrage an die GPT-6.2 API mit cURL

curl https://api.poyo.ai/v1/responses \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-sol",
    "input": [
      {"role": "developer", "content": "You are a code reviewer. Be specific and cite line numbers."},
      {"role": "user", "content": "Review this function for race conditions: ..."}
    ],
    "reasoning": {"effort": "medium"},
    "max_output_tokens": 8000,
    "store": false
  }'

model und input sind Pflichtfelder. input ist ein einfacher String oder ein Array von Items mit role (developer, system, user, assistant) und content. Weitere dokumentierte Felder, die dieser Leitfaden nutzt: reasoning, max_output_tokens, stream, store, tools, tool_choice, previous_response_id und metadata.

Die Antwort ist ein Responses-Objekt, das direkt zurückgegeben wird. Der Text steht in output[].content[]-Blöcken mit type: "output_text", der Status des Aufrufs in status und die Zählwerte in usage.input_tokens, usage.output_tokens und usage.total_tokens.

Python mit dem OpenAI SDK

Richten Sie das SDK auf PoYo aus:

import os
from openai import OpenAI

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

resp = client.responses.create(
    model="gpt-6.2-sol",
    input=[
        {"role": "developer", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Write a migration plan from Celery 4 to Celery 5."},
    ],
    reasoning={"effort": "medium"},
    max_output_tokens=8000,
)

print(resp.output_text)
print(resp.status, resp.usage)

resp.output_text ist der Helfer des SDK, der alle output_text-Blöcke zusammenfügt. Loggen Sie resp.usage bei jedem Aufruf; der Kostenabschnitt unten liest es aus.

Chat Completions für bestehenden Code

Wenn Ihr Code bereits chat.completions.create verwendet, ändern Sie das Modell und entfernen Sie die Sampling-Felder:

resp = client.chat.completions.create(
    model="gpt-6.2-sol",
    messages=[
        {"role": "system", "content": "You are a senior backend engineer."},
        {"role": "user", "content": "Explain the CAP theorem with one example per trade-off."},
    ],
    max_tokens=4000,
)
print(resp.choices[0].message.content, resp.choices[0].finish_reason)

Dieselbe Anfrage in cURL:

curl https://api.poyo.ai/v1/chat/completions \
  -H "Authorization: Bearer $POYO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6.2-sol",
    "messages": [{"role": "user", "content": "Explain vector databases in one sentence."}],
    "max_tokens": 1000
  }'

PoYos Chat-Completions-Schema dokumentiert model, messages (content als String; Rollen system, user, assistant), max_tokens, stream, stop, n und die Penalty-Felder. tools dokumentiert es nicht, und laut OpenAI erfordert Tool Calling bei GPT-6.2 Responses, Agenten gehören also auf /v1/responses.

Reasoning Effort über die GPT-6.2 API setzen

OpenAI nennt das Feld reasoning.effort in Responses und reasoning_effort in Chat Completions. PoYos Responses-Referenz dokumentiert reasoning (Beispiel {"effort": "medium"}); die Chat-Completions-Referenz führt reasoning_effort noch nicht auf, daher setzt dieser Leitfaden den Effort nur über Responses.

SituationEinstellungQuelle
Neue IntegrationmediumOpenAI: „Beginnen Sie bei einer neuen Integration mit medium.“
Bisher none oder minimallowOpenAIs Migrationshinweis zu GPT-6.2
Lange oder komplexe AufgabenEine höhere StufeOpenAI: Höherer Effort „kann helfen, bis zu den abschließenden Prüfungen durchzuhalten“
noneAbgelehntOpenAIs Modellseiten

OpenAIs Reasoning-Leitfaden nennt low, medium, high, xhigh und max unter den möglichen Werten, sagt aber, dass sie modellabhängig sind. Die GPT-6.2-Modellseiten listen die akzeptierten Werte nicht auf, senden Sie also eine Testanfrage, bevor Sie eine Stufe über medium fest einprogrammieren. Reasoning-Token werden als Output abgerechnet und zählen gegen max_output_tokens; OpenAI weist sie in usage.output_tokens_details.reasoning_tokens aus.

Antworten der GPT-6.2 API streamen

Mit "stream": true liefert PoYo text/event-stream. Jede data:-Zeile ist JSON, dessen type das Event benennt; Text kommt als response.output_text.delta, und response.completed enthält das finale Objekt mit usage. PoYo sendet keine separaten event:-Zeilen, und der Stream endet mit data: [DONE].

stream = client.responses.create(
    model="gpt-6.2-sol",
    input="Write a 100-word product introduction for a log search tool.",
    reasoning={"effort": "low"},
    max_output_tokens=2000,
    stream=True,
    store=False,
)

usage = None
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
    elif event.type == "response.completed":
        usage = event.response.usage
    elif event.type == "response.failed":
        raise RuntimeError(event.response)
print("\n", usage)

Bei Chat Completions liefert stream=True Events vom Typ chat.completion.chunk; der Text steht in choices[0].delta.content, und der letzte Chunk enthält usage.

Bild-Input

GPT-6.2 akzeptiert Bilder zusammen mit Text. Bei PoYo senden Sie sie an Responses als input_image-Blöcke mit einer öffentlichen URL oder einer vollständigen Data-URI (data:image/png;base64,...). PoYos Dokumentation empfiehlt, den Text vor die Bilder zu setzen:

{
  "model": "gpt-6.2-sol",
  "input": [
    {
      "role": "user",
      "content": [
        {"type": "input_text", "text": "List every service in this architecture diagram that writes to the database."},
        {"type": "input_image", "image_url": "https://example.com/diagram.png"}
      ]
    }
  ],
  "max_output_tokens": 3000
}

Usage auslesen und die Kosten einer Anfrage berechnen

PoYo-Preise pro 1M Token: Sol $1.60 Input, $8 Output, $0.08 Cache-Read, $2 Cache-Write; Astra $6.40, $32, $0.32, $8 (1 Credit = $0.005).

OpenAIs Caching-Leitfaden weist abgerechnete Cache-Reads in usage.input_tokens_details.cached_tokens und Writes in usage.input_tokens_details.cache_write_tokens aus. PoYos Schema enthält input_tokens_details und output_tokens_details, ohne deren Schlüssel aufzulisten, lesen Sie sie also defensiv aus:

PRICES = {  # PoYo USD per 1M tokens: input, output, cache read, cache write
    "gpt-6.2-sol":   (1.60, 8.00, 0.08, 2.00),
    "gpt-6.2-astra": (6.40, 32.00, 0.32, 8.00),
}

def estimate_cost_usd(model: str, usage) -> float:
    p_in, p_out, p_read, p_write = PRICES[model]
    details = getattr(usage, "input_tokens_details", None)
    cached = getattr(details, "cached_tokens", 0) or 0
    written = getattr(details, "cache_write_tokens", 0) or 0
    fresh = usage.input_tokens - cached - written
    return (fresh * p_in + cached * p_read + written * p_write
            + usage.output_tokens * p_out) / 1_000_000

Betrachten Sie das als Schätzung und gleichen Sie es mit Ihrem PoYo-Nutzungsprotokoll ab. Alle Preise hier sind Preise für kurzen Kontext. OpenAI verlangt über 272K Input-Token mehr, prüfen Sie also bei jeder so großen Anfrage die Modellseite. Durchgerechnete Beispiele finden Sie unter GPT-6.2 API Preise.

Fehler, die Sie behandeln sollten

HTTPUrsacheVorgehen
400Ungültiges Feld (validation_error, mit Details)Body korrigieren; ein Effort none oder ein undokumentiertes Feld kann hier landen
401Fehlender oder ungültiger API-SchlüsselAuthorization-Header prüfen
402Nicht genügend CreditsVor dem erneuten Versuch aufladen
404Unbekanntes Modell (model_not_found)ID prüfen: gpt-6.2-sol, gpt-6.2-astra
429Rate LimitWarten und erneut versuchen
500 / 502 / 503Server- oder Upstream-FehlerMit exponentiellem Backoff erneut versuchen

Laut PoYos Dokumentation sind LLM-Endpunkte derzeit nicht rate-limitiert, behandeln Sie 429 aber trotzdem. Fangen Sie mit dem OpenAI SDK openai.APIStatusError ab und verzweigen Sie nach status_code. Wiederholen Sie nur 5xx und 429; ein 400 schlägt erneut fehl, solange sich der Body nicht ändert. Die vollständigen Bodies finden Sie unter PoYo-Fehlercodes.

Checkliste vor dem Release

  • Halten Sie POYO_API_KEY auf dem Server; liefern Sie ihn nie in Browser- oder Mobile-Code aus.
  • Entfernen Sie temperature und top_p aus jedem Anfragepfad für GPT-6.2, auch aus gemeinsam genutzten Hilfsfunktionen.
  • Setzen Sie immer max_output_tokens (oder max_tokens) und lassen Sie innerhalb dieser Obergrenze Platz für Reasoning-Token.
  • Loggen Sie status / finish_reason und den vollständigen usage-Block neben Ihrer eigenen Request-ID, damit abgeschnittene Antworten und Kostenspitzen sichtbar werden.
  • Legen Sie langen, stabilen Kontext in die erste developer-Nachricht und die wechselnde Frage ans Ende, damit Prompt Caching greifen kann.
  • Hinterlegen Sie die Modell-ID fest in der Konfiguration, damit Sie ohne Deploy zwischen gpt-6.2-sol und gpt-6.2-astra wechseln können.

Für Tools, gestreamte Tool Calls und Caching in langen Agenten-Sessions geht es weiter mit GPT-6.2 API für Coding-Agenten.

Häufig gestellte Fragen

Wie rufe ich die GPT-6.2 API in Python auf?

Verwenden Sie das OpenAI SDK mit base_url="https://api.poyo.ai/v1", Ihrem PoYo-Schlüssel und model="gpt-6.2-sol" oder "gpt-6.2-astra" in client.responses.create.

Unterstützt die GPT-6.2 API Streaming?

Ja, auf beiden Endpunkten. Setzen Sie stream: true; Responses sendet typisierte Events wie response.output_text.delta, Chat Completions sendet chat.completion.chunk-Events. Beide enden mit data: [DONE].

Wie setze ich den Reasoning Effort der GPT-6.2 API?

Senden Sie "reasoning": {"effort": "medium"} an /v1/responses. OpenAI empfiehlt medium für den Einstieg und lehnt none ab.

Warum schlägt meine GPT-6.2 API Anfrage mit temperature fehl?

Laut OpenAI sollen Sie temperature und top_p bei GPT-6.2 weglassen. Entfernen Sie sie und steuern Sie die Ausgabelänge mit max_output_tokens oder max_tokens.

Wie sende ich ein Bild an die GPT-6.2 API?

Verwenden Sie /v1/responses mit einem input_image-Block (URL oder Data-URI) nach einem input_text-Block. PoYos Chat-Completions-Schema dokumentiert nur String-Content.

Share: