
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"
| Format | Endepunkt | Bruk det når |
|---|---|---|
| Responses | POST https://api.poyo.ai/v1/responses | Ny kode, funksjonsverktøy, bildeinput, resonneringsnivå |
| Chat Completions | POST https://api.poyo.ai/v1/chat/completions | Eksisterende 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:
- Ikke send
temperatureellertop_p. OpenAI sier at de skal utelates, i tillegg tillogprobsogtop_logprobspå Chat Completions ogtop_logprobspå Responses. PoYos skjemaer lister fortsatttemperatureogtop_pfor eldre modeller. - Ikke sett resonneringsnivået til
none; API-et avviser det. - Legg stabile instruksjoner i en
developer-melding i starten avinput. GPT-6.2 legger toppnivå-instructionsetterinput, 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.
| Situasjon | Innstilling | Kilde |
|---|---|---|
| Ny integrasjon | medium | OpenAI: "Start med medium for en ny integrasjon." |
Tidligere none eller minimal | low | OpenAIs migreringsnotat for GPT-6.2 |
| Lange eller komplekse oppgaver | Et høyere nivå | OpenAI: et høyere nivå "kan hjelpe den med å holde ut gjennom de siste kontrollene" |
none | Avvises | OpenAIs 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 | Årsak | Hva du gjør |
|---|---|---|
| 400 | Ugyldig felt (validation_error, med detaljer) | Rett forespørselskroppen; nivået none eller et udokumentert felt kan havne her |
| 401 | Manglende eller ugyldig API-nøkkel | Sjekk Authorization-headeren |
| 402 | Ikke nok kreditter | Fyll på før du prøver igjen |
| 404 | Ukjent modell (model_not_found) | Sjekk ID-en: gpt-6.2-sol, gpt-6.2-astra |
| 429 | Rate limit nådd | Vent og prøv igjen |
| 500 / 502 / 503 | Feil på serveren eller oppstrøms | Prø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_KEYpå serversiden; legg den aldri i nettleser- eller mobilkode. - Fjern
temperatureogtop_pfra alle kodestier for GPT-6.2-forespørsler, også i delte hjelpefunksjoner. - Sett alltid
max_output_tokens(ellermax_tokens), og la det være plass til resonneringstokens innenfor den grensen. - Logg
status/finish_reasonog heleusage-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-sologgpt-6.2-astrauten 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.