how-tos

GPT-6.2 API-guide: første anmodning i cURL og Python, Responses og Chat Completions

Poyo.ai Team
8 min read
Share:

GPT-6.2 API-guide: første anmodning i cURL og Python

Denne GPT-6.2 API-guide fører dig fra en API-nøgle til en fungerende anmodning til gpt-6.2-sol eller gpt-6.2-astra i cURL og med Python OpenAI SDK'et, på både Responses- og Chat Completions-endpointet. Alle anmodningskroppe følger PoYo's offentliggjorte skema og OpenAI's migreringsnoter for GPT-6.2 pr. 18. november 2026. Du kan teste prompts først på GPT-6.2 Sol-modelsiden eller GPT-6.2 Astra-modelsiden.

Ny i modellerne? Overblikket over GPT-6.2 API dækker grænser og positionering.

Før du starter

Opret en nøgle i PoYo-dashboardet, og behold den på din server:

export POYO_API_KEY="your-poyo-key"
FormatEndpointBrug det, når
ResponsesPOST https://api.poyo.ai/v1/responsesNy kode, funktionsværktøjer, billedinput, ræsonnementsniveau
Chat CompletionsPOST https://api.poyo.ai/v1/chat/completionsEksisterende Chat Completions-kode, beskeder kun med tekst, ingen værktøjer

Hver anmodning sender Authorization: Bearer $POYO_API_KEY. Eksemplerne bruger gpt-6.2-sol; erstat det med gpt-6.2-astra for Astra. Anmodningernes struktur er identisk.

Tre regler fra OpenAI's GPT-6.2-guide gælder for alle eksemplerne nedenfor:

  1. Send ikke temperature eller top_p. OpenAI siger, at de skal udelades, sammen med logprobs og top_logprobs på Chat Completions og top_logprobs på Responses. PoYo's skemaer angiver stadig temperature og top_p for ældre modeller.
  2. Sæt ikke ræsonnementsniveauet til none; API'et afviser det.
  3. Læg faste instruktioner i en developer-besked i starten af input. GPT-6.2 tilføjer instructions på topniveau efter input, hvilket flytter dem ud af det præfiks, der kan caches.

Første GPT-6.2 API-anmodning med 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 og input er påkrævede. input er en almindelig streng eller et array af elementer med role (developer, system, user, assistant) og content. Andre dokumenterede felter, som guiden bruger: reasoning, max_output_tokens, stream, store, tools, tool_choice, previous_response_id og metadata.

Svaret er et Responses-objekt, der returneres direkte. Teksten ligger i output[].content[]-blokke med type: "output_text"; kaldets status står i status; og token-tallene står i usage.input_tokens, usage.output_tokens og usage.total_tokens.

Python med OpenAI SDK'et

Peg SDK'et mod PoYo:

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 er SDK'ets hjælper, der samler alle output_text-blokke. Log resp.usage ved hvert kald; prisafsnittet nedenfor læser det.

Chat Completions til eksisterende kode

Hvis din kode allerede bruger chat.completions.create, så skift modellen, og fjern sampling-felterne:

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)

Den samme anmodning i 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
  }'

PoYo's Chat Completions-skema dokumenterer model, messages (content som streng; rollerne system, user, assistant), max_tokens, stream, stop, n og penalty-felterne. Det dokumenterer ikke tools, og OpenAI siger, at værktøjskald i GPT-6.2 kræver Responses, så agenter hører hjemme på /v1/responses.

Indstil ræsonnementsniveau via GPT-6.2 API

OpenAI kalder feltet reasoning.effort i Responses og reasoning_effort i Chat Completions. PoYo's Responses-reference dokumenterer reasoning (eksempel {"effort": "medium"}); Chat Completions-referencen angiver endnu ikke reasoning_effort, så denne guide indstiller kun niveauet på Responses.

SituationIndstillingKilde
Ny integrationmediumOpenAI: "Start med medium til en ny integration."
Tidligere none eller minimallowOpenAI's migreringsnote for GPT-6.2
Lange eller komplekse opgaverEt højere niveauOpenAI: et højere niveau "kan hjælpe den med at holde ud gennem de afsluttende kontroller"
noneAfvisesOpenAI's modelsider

OpenAI's ræsonnementsguide nævner low, medium, high, xhigh og max blandt de mulige værdier, men siger, at de afhænger af modellen. GPT-6.2's modelsider angiver ikke, hvilke værdier der accepteres, så send én testanmodning, før du hardcoder et niveau over medium. Ræsonnements-tokens afregnes som output og tæller med i max_output_tokens; OpenAI rapporterer dem i usage.output_tokens_details.reasoning_tokens.

Streaming af svar fra GPT-6.2 API

Med "stream": true returnerer PoYo text/event-stream. Hver data:-linje er JSON, hvor type angiver hændelsen; tekst kommer som response.output_text.delta, og response.completed indeholder det endelige objekt med usage. PoYo sender ingen separate event:-linjer, og streamen slutter med 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)

På Chat Completions returnerer stream=True hændelser af typen chat.completion.chunk; teksten ligger i choices[0].delta.content, og den sidste chunk indeholder usage.

Billedinput

GPT-6.2 accepterer billeder sammen med tekst. På PoYo sender du dem til Responses som input_image-blokke med en offentlig URL eller en komplet Data URI (data:image/png;base64,...). PoYo's dokumentation anbefaler tekst før billeder:

{
  "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
}

Læs forbruget, og beregn prisen for en anmodning

PoYo-priser pr. 1M tokens: Sol $1.60 input, $8 output, $0.08 cache-læsning, $2 cache-skrivning; Astra $6.40, $32, $0.32, $8 (1 kredit = $0.005).

OpenAI's caching-guide rapporterer afregnede cache-læsninger i usage.input_tokens_details.cached_tokens og skrivninger i usage.input_tokens_details.cache_write_tokens. PoYo's skema indeholder input_tokens_details og output_tokens_details uden at angive deres nøgler, så læs dem defensivt:

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

Betragt dette som et estimat, og afstem det med din PoYo-forbrugslog. Alle priser her er takster for kort kontekst. OpenAI tager mere over 272K input-tokens, så tjek modelsiden for enhver anmodning af den størrelse. Udregnede eksempler finder du i GPT-6.2 API-priser.

Fejl, der er værd at håndtere

HTTPÅrsagHvad du skal gøre
400Ugyldigt felt (validation_error, med detaljer)Ret anmodningskroppen; et none-niveau eller et udokumenteret felt kan ende her
401Manglende eller ugyldig API-nøgleTjek Authorization-headeren
402Utilstrækkelige kreditterFyld op, før du prøver igen
404Ukendt model (model_not_found)Tjek ID'et: gpt-6.2-sol, gpt-6.2-astra
429Rate limit ramtVent, og prøv igen
500 / 502 / 503Server- eller upstream-fejlPrøv igen med eksponentiel backoff

PoYo's dokumentation siger, at LLM-endpoints i øjeblikket ikke er rate-limited, men håndtér alligevel 429. Med OpenAI SDK'et fanger du openai.APIStatusError og forgrener på status_code. Prøv kun 5xx og 429 igen; en 400 fejler igen, indtil anmodningskroppen ændres. De fulde fejlsvar står i PoYo's fejlkoder.

Tjekliste, før du går i produktion

  • Hold POYO_API_KEY på serversiden; send den aldrig med i browser- eller mobilkode.
  • Fjern temperature og top_p fra alle anmodningsstier til GPT-6.2, også fra delte hjælpefunktioner.
  • Sæt altid max_output_tokens (eller max_tokens), og levn plads til ræsonnements-tokens inden for den grænse.
  • Log status / finish_reason og hele usage-blokken sammen med dit eget anmodnings-ID, så afkortede svar og prisudsving bliver synlige.
  • Læg lang, stabil kontekst i den første developer-besked og det skiftende spørgsmål til sidst, så prompt caching har en chance for at virke.
  • Fastlås model-ID'et i konfigurationen, så du kan skifte mellem gpt-6.2-sol og gpt-6.2-astra uden en deploy.

Om værktøjer, streaming af værktøjskald og caching i lange agentsessioner kan du læse videre i GPT-6.2 API til kodeagenter.

Ofte stillede spørgsmål

Hvordan kalder jeg GPT-6.2 API i Python?

Brug OpenAI SDK'et med base_url="https://api.poyo.ai/v1", din PoYo-nøgle og model="gpt-6.2-sol" eller "gpt-6.2-astra" i client.responses.create.

Understøtter GPT-6.2 API streaming?

Ja, på begge endpoints. Sæt stream: true; Responses sender typede hændelser som response.output_text.delta, og Chat Completions sender chat.completion.chunk-hændelser. Begge slutter med data: [DONE].

Hvordan indstiller jeg ræsonnementsniveauet i GPT-6.2 API?

Send "reasoning": {"effort": "medium"} på /v1/responses. OpenAI anbefaler at starte med medium og afviser none.

Hvorfor fejler min GPT-6.2 API-anmodning med temperature?

OpenAI siger, at temperature og top_p skal udelades for GPT-6.2. Fjern dem, og styr outputlængden med max_output_tokens eller max_tokens.

Hvordan sender jeg et billede til GPT-6.2 API?

Brug /v1/responses med en input_image-blok (URL eller Data URI) efter en input_text-blok. PoYo's Chat Completions-skema dokumenterer kun indhold som streng.

Share: