how-tos

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

Poyo.ai Team
8 min read
Share:

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

Denne guiden til GPT-6.2 API tar deg fra en API-nøkkel til en fungerende forespørsel mot gpt-6.2-sol eller gpt-6.2-astra i cURL og Python OpenAI SDK, både på Responses- og Chat Completions-endepunktet. Alle forespørselskroppene følger PoYos publiserte skjema og OpenAIs migreringsnotater for GPT-6.2 per 18. november 2026. Du kan teste prompter først på modellsiden for GPT-6.2 Sol eller modellsiden for GPT-6.2 Astra.

Ny med disse modellene? Oversikten over GPT-6.2 API dekker grenser og posisjonering.

Før du begynner

Opprett en nøkkel i PoYo-dashbordet og hold den på serveren din:

export POYO_API_KEY="your-poyo-key"
FormatEndepunktBruk det når
ResponsesPOST https://api.poyo.ai/v1/responsesNy kode, funksjonsverktøy, bildeinput, resonneringsnivå
Chat CompletionsPOST https://api.poyo.ai/v1/chat/completionsEksisterende Chat Completions-kode, rene tekstmeldinger, ingen verktøy

Hver forespørsel sender Authorization: Bearer $POYO_API_KEY. Eksemplene bruker gpt-6.2-sol; bytt til gpt-6.2-astra for Astra. Forespørselsformatene er identiske.

Tre regler fra OpenAIs GPT-6.2-guide gjelder for alle eksemplene nedenfor:

  1. Ikke send temperature eller top_p. OpenAI sier at de skal utelates, i tillegg til logprobs og top_logprobs på Chat Completions og top_logprobs på Responses. PoYos skjemaer lister fortsatt temperature og top_p for eldre modeller.
  2. Ikke sett resonneringsnivået til none; API-et avviser det.
  3. Legg stabile instruksjoner i en developer-melding i starten av input. GPT-6.2 legger toppnivå-instructions etter input, noe som flytter dem ut av prefikset som kan caches.

Første GPT-6.2 API-forespørsel 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åkrevd. input er en ren streng eller en liste med elementer som har role (developer, system, user, assistant) og content. Andre dokumenterte felt som brukes i denne guiden: reasoning, max_output_tokens, stream, store, tools, tool_choice, previous_response_id og metadata.

Svaret er et Responses-objekt som returneres direkte. Teksten ligger i output[].content[]-blokker med type: "output_text"; statusen for kallet står i status; og tellingene ligger i usage.input_tokens, usage.output_tokens og usage.total_tokens.

Python med OpenAI SDK-et

Pek SDK-et mot 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 hjelpefelt som slår sammen alle output_text-blokker. Logg resp.usage for hvert kall; kostnadsavsnittet nedenfor leser det.

Chat Completions for eksisterende kode

Hvis koden din allerede bruker chat.completions.create, bytter du modell og fjerner sampling-feltene:

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 forespørselen 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
  }'

PoYos Chat Completions-skjema dokumenterer model, messages (content som streng; rollene system, user, assistant), max_tokens, stream, stop, n og straffefeltene. Det dokumenterer ikke tools, og OpenAI sier at verktøykall i GPT-6.2 krever Responses, så agenter hører hjemme på /v1/responses.

Sett resonneringsnivå via GPT-6.2 API

OpenAI kaller feltet reasoning.effort i Responses og reasoning_effort i Chat Completions. PoYos Responses-referanse dokumenterer reasoning (eksempel {"effort": "medium"}); Chat Completions-referansen lister ikke reasoning_effort ennå, så denne guiden setter nivået bare på Responses.

SituasjonInnstillingKilde
Ny integrasjonmediumOpenAI: "Start med medium for en ny integrasjon."
Tidligere none eller minimallowOpenAIs migreringsnotat for GPT-6.2
Lange eller komplekse oppgaverEt høyere nivåOpenAI: et høyere nivå "kan hjelpe den med å holde ut gjennom de siste kontrollene"
noneAvvisesOpenAIs modellsider

OpenAIs resonneringsguide lister low, medium, high, xhigh og max blant mulige verdier, men sier at de avhenger av modellen. Modellsidene for GPT-6.2 lister ikke hvilke verdier som godtas, så send én testforespørsel før du hardkoder et nivå over medium. Resonneringstokens faktureres som output og teller mot max_output_tokens; OpenAI rapporterer dem i usage.output_tokens_details.reasoning_tokens.

Strømming av svar fra GPT-6.2 API

Med "stream": true returnerer PoYo text/event-stream. Hver data:-linje er JSON der type angir hendelsen; teksten kommer som response.output_text.delta, og response.completed inneholder det endelige objektet med usage. PoYo sender ingen egne event:-linjer, og strømmen avsluttes 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 hendelser av typen chat.completion.chunk; teksten ligger i choices[0].delta.content, og den siste chunken inneholder usage.

Bildeinput

GPT-6.2 tar imot bilder sammen med tekst. På PoYo sender du dem til Responses som input_image-blokker med en offentlig URL eller en fullstendig Data URI (data:image/png;base64,...). PoYos dokumentasjon anbefaler tekst før bilder:

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

Les forbruket og beregn kostnaden for en forespørsel

PoYo-priser per 1M tokens: Sol $1.60 input, $8 output, $0.08 cache-lesing, $2 cache-skriving; Astra $6.40, $32, $0.32, $8 (1 kreditt = $0.005).

OpenAIs caching-guide rapporterer fakturerte cache-lesinger i usage.input_tokens_details.cached_tokens og skrivinger i usage.input_tokens_details.cache_write_tokens. PoYos skjema inneholder input_tokens_details og output_tokens_details uten å liste nøklene deres, så les 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

Se på dette som et estimat, og avstem det mot forbruksloggen din i PoYo. Alle prisene her er satser for kort kontekst. OpenAI tar mer betalt over 272K input-tokens, så sjekk modellsiden for enhver forespørsel av den størrelsen. Utregnede eksempler finner du i GPT-6.2 API-priser.

Feil som er verdt å håndtere

HTTPÅrsakHva du gjør
400Ugyldig felt (validation_error, med detaljer)Rett forespørselskroppen; nivået none eller et udokumentert felt kan havne her
401Manglende eller ugyldig API-nøkkelSjekk Authorization-headeren
402Ikke nok kreditterFyll på før du prøver igjen
404Ukjent modell (model_not_found)Sjekk ID-en: gpt-6.2-sol, gpt-6.2-astra
429Rate limit nåddVent og prøv igjen
500 / 502 / 503Feil på serveren eller oppstrømsPrøv igjen med eksponentiell backoff

PoYos dokumentasjon sier at LLM-endepunktene foreløpig ikke har rate limit, men håndter 429 likevel. Med OpenAI SDK-et fanger du openai.APIStatusError og forgrener på status_code. Prøv bare 5xx og 429 på nytt; en 400 feiler igjen helt til forespørselskroppen endres. Fullstendige feilsvar finner du i PoYos feilkoder.

Sjekkliste før du lanserer

  • Hold POYO_API_KEY på serversiden; legg den aldri i nettleser- eller mobilkode.
  • Fjern temperature og top_p fra alle kodestier for GPT-6.2-forespørsler, også i delte hjelpefunksjoner.
  • Sett alltid max_output_tokens (eller max_tokens), og la det være plass til resonneringstokens innenfor den grensen.
  • Logg status / finish_reason og hele usage-blokken sammen med din egen forespørsels-ID, slik at avkortede svar og kostnadstopper blir synlige.
  • Legg lang, stabil kontekst i den første developer-meldingen og det skiftende spørsmålet sist, så får prompt-caching en sjanse til å slå inn.
  • Lås modell-ID-en i konfigurasjonen, så du kan bytte mellom gpt-6.2-sol og gpt-6.2-astra uten en ny deploy.

For verktøy, strømming av verktøykall og caching i lange agentøkter, fortsett med GPT-6.2 API for kodeagenter.

Ofte stilte spørsmål

Hvordan kaller jeg GPT-6.2 API i Python?

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

Støtter GPT-6.2 API strømming?

Ja, på begge endepunktene. Sett stream: true; Responses sender typede hendelser som response.output_text.delta, og Chat Completions sender chat.completion.chunk-hendelser. Begge avsluttes med data: [DONE].

Hvordan setter jeg resonneringsnivået i GPT-6.2 API?

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

Hvorfor feiler GPT-6.2 API-forespørselen min med temperature?

OpenAI sier at temperature og top_p skal utelates for GPT-6.2. Fjern dem, og styr lengden på outputen med max_output_tokens eller max_tokens.

Hvordan sender jeg et bilde til GPT-6.2 API?

Bruk /v1/responses med en input_image-blokk (URL eller Data URI) etter en input_text-blokk. PoYos Chat Completions-skjema dokumenterer bare content som streng.

Share: