Arendaja platvorm

OpenAI API

OpenAI ülevaade arendajatele, mis hõlmab API-juurdepääsu, hinnastust, SDK-tuge, lõppunkte, võimekusi ja platvormi reegleid.

API võti Nõutud
Peamine API Responses API
SDK tugi Ametlikud SDK-d ja klienditeegid on saadaval JavaScripti/TypeScripti, Pythoni, .NET-i, Java, Go ja Ruby jaoks. Agents SDK on ametlikult saadaval TypeScripti ja Pythoni jaoks. PHP klienditeeke hooldab kogukond, seega on PHP puhul kõige portatiivsem lahendu
Päringupiirangud Organisatsiooni- ja projektitaseme piirangud sõltuvad mudelist ja kasutustasemest. Piirangud võivad hõlmata RPM-i, RPD-d, TPM-i, TPD-d, pilte minutis, heli-, pakett-, vektorihoidla- ja pika konteksti piiranguid. Piirangud on nähtavad arendajakonsoolis ja
Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL) https://api.openai.com/v1
Peamine API Responses API
Hinnad

API Hinnad

Hinnakujundusmudel Kasutuspõhine hinnastamine, mille korral tasutakse peamiselt iga miljoni sisend-, vahemällu salvestatud sisendi, vahemällu kirjutamise ja väljundtokeni eest; mõne tööriista ja eriteenuse puhul lisanduvad eraldi tasud.

Praegused hinnad varieeruvad mudeli ja töötlemisrežiimi järgi. Praegusel hinnalehel toodud näidete hulgas on lipulaevamudel GPT-6 Astra, mille Standard-töötlemise korral maksab lühikese konteksti sisend 10 dollarit 1 miljoni tokeni kohta ja väljund 50 dollarit 1 miljoni tokeni kohta; GPT-6 Soli puhul on sisendi hind 2 dollarit ja väljundi hind 1

Arendaja töömugavus

SDK info

SDK Ametlikud SDK-d ja klienditeegid on saadaval JavaScripti/TypeScripti, Pythoni, .NET-i, Java, Go ja Ruby jaoks. Agents SDK on ametlikult saadaval TypeScripti ja Pythoni jaoks. PHP klienditeeke hooldab kogukond, seega on PHP puhul kõige portatiivsem lahendu
Kasutusmugavus Levinud kasutusjuhtude puhul kõrge. Responses API-l on ühtne päringuvorming, ametlikud SDK-d, autentimine keskkonnamuutujate kaudu, otseühendus HTTPS-i kaudu, Playgroundi testimisvõimalus ning abistavad atribuudid, näiteks output_text. Täiustatud mitmeast
Dokumentatsioon Kõrge. Praegune ametlik dokumentatsioon sisaldab kiirjuhendit, API viitejuhendit ning Responsesi, tööriistade, struktureeritud väljundite, failide, päringulimiitide, tootmiskeskkonna, privaatsuse, latentsuse, SDK-de, mudelite ja migratsioonide juhendeid.
Viivitus Kõigi mudelite kohta ei ole avaldatud ühtset universaalset latentsusgarantiid. Latentsust mõjutavad peamiselt mudeli valik, genereeritud tokenite arv, sisendi ja väljundi suurus, võrguühenduse aeg, tööriistakutsed, järjestikuste päringute arv ning viip
Featuurid

API võimekused

✓ Voogedastus
✓ Funktsioonide kasutamine
✓ Assistants API
✓ Failide üleslaadimine
✓ Peenhäälestamine
✓ Veebiotsing
✓ Pildi sisend
✓ Struktureeritud väljund
✓ Liivakast
Lühikirjeldus

Responses API on soovitatav arhitektuur uute otseühenduste loomiseks API kaudu. See võtab vastu teksti-, pildi- ja failisisendeid ning võib tagastada teksti või struktureeritud JSON-i. Olenevalt mudelist ja konto juurdepääsuõigustest toetab see voogedastust, funktsioonikutseid, sisseehitatud veebiotsingut, failiotsingut, piltide genereerimist, arvuti kasutamise töövooge ja muid tööriistu. TypeScripti ja Pythoni Agents SDK lisab koodipõhise orkestreerimise, üleandmised, turvapiirded, jälgimise ja tööriistade käivitamise. Pärandfunktsiooniga Assistants API kasutamine lõpetati ning selle sulgemine on kavandatud 26. augustiks 2026; uusi integratsioone selle peale rajada ei tohiks. Ka Agent Builderi kasutamine lõpetatakse ning selle sulgemine on kavandatud 30. novembriks 2026. Praegune mudelite saadavus, toetatud tööriistad ja piirangud sõltuvad mudelist, kontost, piirkonnast ja projektist.

Näited

API Näited

set -euo pipefail

: "${OPENAI_API_KEY:?Set OPENAI_API_KEY first}"

response=$(curl --fail-with-body --silent --show-error https://api.openai.com/v1/responses \
  -H "Authorization: Bearer ${OPENAI_API_KEY}" \
  -H "Content-Type: application/json" \
  -d @- <<'JSON'
{
  "model": "gpt-6-astra",
  "instructions": "You are a concise technical assistant.",
  "input": "Explain idempotency in one sentence."
}
JSON
)

printf '%s\n' "$response" | jq -r '.output_text // .error.message // "No text output returned"'

# Structured JSON output
curl --fail-with-body --silent --show-error https://api.openai.com/v1/responses \
  -H "Authorization: Bearer ${OPENAI_API_KEY}" \
  -H "Content-Type: application/json" \
  -d @- <<'JSON' | jq -r '.output_text // .error.message // "No text output returned"'
{
  "model": "gpt-6-astra",
  "input": "Classify this request: I need a refund for an accidental purchase.",
  "text": {
    "format": {
      "type": "json_schema",
      "name": "classification",
      "strict": true,
      "schema": {
        "type": "object",
        "properties": {
          "category": {"type": "string", "enum": ["billing", "technical", "general"]},
          "urgent": {"type": "boolean"}
        },
        "required": ["category", "urgent"],
        "additionalProperties": false
      }
    }
  }
}
JSON
# Install: pip install openai
import json
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.responses.create(
    model="gpt-6-astra",
    instructions="You are a concise technical assistant.",
    input=[
        {"role": "user", "content": "Explain API retries in one sentence."},
        {"role": "assistant", "content": "Retries repeat a failed request according to a controlled policy."},
        {"role": "user", "content": "Now give one practical rule."}
    ],
)
print(response.output_text)

# Streaming
stream = client.responses.create(
    model="gpt-6-astra",
    input="List three benefits of server-sent event streaming.",
    stream=True,
)
for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()

# Structured output
structured = client.responses.create(
    model="gpt-6-astra",
    input="Classify: The payment was charged twice.",
    text={
        "format": {
            "type": "json_schema",
            "name": "classification",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "category": {"type": "string", "enum": ["billing", "technical", "general"]},
                    "urgent": {"type": "boolean"},
                },
                "required": ["category", "urgent"],
                "additionalProperties": False,
            },
        }
    },
)
print(json.loads(structured.output_text))

# Tool calling
weather_tool = {
    "type": "function",
    "name": "get_weather",
    "description": "Get the current weather for a city.",
    "parameters": {
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
        "additionalProperties": False,
    },
}
first = client.responses.create(
    model="gpt-6-astra",
    input="What is the weather in Boston?",
    tools=[weather_tool],
)

follow_up = list(first.output)
for item in first.output:
    if item.type == "function_call" and item.name == "get_weather":
        args = json.loads(item.arguments)
        tool_result = {"city": args["city"], "temperature_f": 58, "condition": "cloudy"}
        follow_up.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps(tool_result),
        })

if len(follow_up) > len(first.output):
    final = client.responses.create(
        model="gpt-6-astra",
        input=follow_up,
        tools=[weather_tool],
    )
    print(final.output_text)

try:
    client.responses.create(model="gpt-6-astra", input="Test request")
except Exception as exc:
    print(f"OpenAI API request failed: {exc}")
// Install: npm install openai
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

try {
  const response = await client.responses.create({
    model: "gpt-6-astra",
    instructions: "You are a concise technical assistant.",
    input: [
      { role: "user", content: "What is an API?" },
      { role: "assistant", content: "An API is an interface that lets software systems communicate." },
      { role: "user", content: "Give one example." }
    ]
  });
  console.log(response.output_text);

  const stream = await client.responses.create({
    model: "gpt-6-astra",
    input: "Explain streaming in two sentences.",
    stream: true
  });
  for await (const event of stream) {
    if (event.type === "response.output_text.delta") process.stdout.write(event.delta);
  }
  process.stdout.write("\n");

  const structured = await client.responses.create({
    model: "gpt-6-astra",
    input: "Classify: The application crashes after login.",
    text: {
      format: {
        type: "json_schema",
        name: "classification",
        strict: true,
        schema: {
          type: "object",
          properties: {
            category: { type: "string", enum: ["billing", "technical", "general"] },
            urgent: { type: "boolean" }
          },
          required: ["category", "urgent"],
          additionalProperties: false
        }
      }
    }
  });
  console.log(JSON.parse(structured.output_text));
} catch (error) {
  if (error instanceof OpenAI.APIError) {
    console.error(`OpenAI API error ${error.status}: ${error.message}`);
  } else {
    console.error(error);
  }
}
<?php
$apiKey = getenv('OPENAI_API_KEY');
if (!$apiKey) {
    fwrite(STDERR, "OPENAI_API_KEY is not set\n");
    exit(1);
}

$payload = [
    'model' => 'gpt-6-astra',
    'instructions' => 'You are a concise technical assistant.',
    'input' => 'Explain API retries in one sentence.'
];

$ch = curl_init('https://api.openai.com/v1/responses');
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json'
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_TIMEOUT => 120
]);

$body = curl_exec($ch);
if ($body === false) {
    $message = curl_error($ch);
    curl_close($ch);
    throw new RuntimeException('Network error: ' . $message);
}

$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
$data = json_decode($body, true, 512, JSON_THROW_ON_ERROR);

if ($status < 200 || $status >= 300) {
    $message = $data['error']['message'] ?? 'Unknown OpenAI API error';
    throw new RuntimeException("HTTP $status: $message");
}

echo $data['output_text'] ?? "No text output returned\n";

// Structured JSON output can be requested by adding a text.format object.
$structuredPayload = [
    'model' => 'gpt-6-astra',
    'input' => 'Classify: The payment was charged twice.',
    'text' => [
        'format' => [
            'type' => 'json_schema',
            'name' => 'classification',
            'strict' => true,
            'schema' => [
                'type' => 'object',
                'properties' => [
                    'category' => ['type' => 'string', 'enum' => ['billing', 'technical', 'general']],
                    'urgent' => ['type' => 'boolean']
                ],
                'required' => ['category', 'urgent'],
                'additionalProperties' => false
            ]
        ]
    ]
];

// Send $structuredPayload with the same cURL configuration when structured output is needed.
Põhimõtted

Andmete kasutus

Andmete kasutus

OpenAI märgib, et API-le saadetud andmeid ei kasutata vaikimisi OpenAI mudelite treenimiseks ega täiustamiseks, välja arvatud juhul, kui klient annab selleks sõnaselge nõusoleku. API kliendid vastutavad jätkuvalt kohaldatavate seaduste, kasutuspõhimõtete ja oma andmekaitsekohustuste järgimise eest.

Andmete säilitamine

Kuritarvituste jälgimise logisid säilitatakse üldjuhul kuni 30 päeva, välja arvatud juhul, kui pikem säilitamine on seadusega nõutud või ohutuse tagamiseks põhjendatult vajalik. Mõned funktsioonid säilitavad rakenduse olekut, sealhulgas vestlusi, faile, vektorhoidlaid ja salvestatud Responses API andmeid. Abikõlblikud organisatsioonid võivad taotleda muudetud kuritarvituste jälgimist (Modified Abuse Monitoring) või nullandmete säilitamist (Zero Data Retention), kuid selleks on vaja heakskiitu ning mõned lõpp-punktid või võimalused ei ole taotlemiseks sobilikud. Responses API võib rakenduse olekut säilitada, kui kasutatakse salvestatud vastuseid, vestlusi, taustarežiimi või muid olekupõhiseid funktsioone.

Päringupiirangud

Organisatsiooni- ja projektitaseme piirangud sõltuvad mudelist ja kasutustasemest. Piirangud võivad hõlmata RPM-i, RPD-d, TPM-i, TPD-d, pilte minutis, heli-, pakett-, vektorihoidla- ja pika konteksti piiranguid. Piirangud on nähtavad arendajakonsoolis ja

Arendaja juhend

OpenAI API juhend: vastused, tööriistad, hinnad ja näited

OpenAI praegune arendajaplatvorm keskendub Responses API-le ning hõlmab ametlikke SDK-sid, majutatud tööriistu, struktureeritud väljundeid, multimodaalseid sisendeid, failihaldust, vestluse oleku säilitamist, reaalajas toimimise võimalusi ja Agents SDK-d. Selles juhendis selgitatakse, kuidas algajad saavad hankida vajalikud autentimisandmed, teha esimese päringu, mõista vastuseid, hinnata kasutuspõhiseid kulusid ning võtta arvesse tootmiskeskkonnaga seotud tegureid.
OpenAI API võimaldab arendajatel lisada oma rakendustesse mudelipõhiseid teksti-, nägemis-, heli-, pildi- ja videofunktsioone ning otsingu-, otsinguabilise teabe hankimise (retrieval), modereerimise ja agentide võimalusi. Uute otseühenduste loomiseks mudelitega soovitab OpenAI kasutada Responses API-t. See pakub ühtset päringumustrit teksti genereerimiseks, voogedastuseks, funktsioonikutseteks, struktureeritud JSON-väljundiks, pildi- ja failisisenditeks, majutatud tööriistadeks ning vestluse jätkamiseks. See juhend käsitleb praktilist teekonda alates API-võtme loomisest kuni töökindla integratsiooni juurutamiseni.
OpenAI API kasutab uute mudelite otseintegratsioonide jaoks Responses API-t ning toetab teksti, multimodaalseid sisendeid, voogedastust, tööriistu, struktureeritud väljundeid, faile, vestluse olekut ja agentide käituskeskkondi. Kasutamiseks on vaja serveripoolset API-võtit, hinnastus põhineb kasutusel ning tootmissüsteemides tuleb arvestada päringupiirangute, privaatsuse, andmete säilitamise, mudelite kättesaadavuse ja tööriistade turvalisusega.

Mis on OpenAI API ja millal seda kasutada?

OpenAI API on majutatud arendajaplatvorm. Rakendus saadab HTTPS-päringu, mis sisaldab mudelit, juhiseid ja sisendit; OpenAI töötleb päringu ning tagastab genereeritud väljundi või muud vastuselemendid. Seejärel saab rakendus tulemust kuvada, salvestada või kasutada seda täiendava koodi käivitamiseks.

Uute otse mudeliga integreerimiste soovitatav lähtekoht on Responses API aadressil POST /v1/responses. See toetab nii tavalist teksti genereerimist kui ka voogedastust, pildi- ja failisisendeid, majutatud tööriistu, kohandatud funktsioonikutseid, struktureeritud väljundeid ja vestluse jätkamist. Chat Completions on ühilduvate olemasolevate integratsioonide jaoks endiselt saadaval, kuid uued rakendused peaksid üldjuhul alustama Responses API-st.

API on mõeldud serveripoolsetele rakendustele, taustsüsteemidele, automatiseerimissüsteemidele, otsingu- ja andmeotsingulahendustele, klienditoe tööriistadele, dokumenditöötluse töövoogudele ning agentsetele rakendustele. See sobib vähem olukordadesse, kus vajate täielikult võrguühenduseta töötavat mudelit, kindlat taristut ilma sõltuvuseta majutatud teenusest või kulu, mis ei tohi kasutuse mahust sõltuda.

Kellele see on mõeldud?

See sobib nii algajale, kes ehitab väikest serveri lõpp-punkti, kui ka kesktaseme arendajale, kes rakendab tööriistu, dokumenditöötlust, olekuga vestlusi või agentide orkestreerimist. Lihtsad päringud vajavad ainult API-võtit, saadaolevat mudelit ning SDK-d või HTTPS-klienti. Keerukamad rakendused peavad arvestama ka tööriistade käivitamise, korduskatsete, päringulimiitide, privaatsusseadete, vastuste salvestamise ja mudelipõhise hinnastamisega.

Kuidas API-le juurdepääs saada?

  1. Looge OpenAI arendajaplatvormil konto ja projekt.
  2. Looge platvormi võtmehaldusvahendite abil API-võti.
  3. Salvestage võti serveripoolsesse keskkonnamuutujasse, näiteks OPENAI_API_KEY.
  4. Installige ametlik SDK või saatke HTTPS-päringuid API baas-URL-ile.
  5. Jälgige algusest peale kasutust, arveldust, vigu, päringute ID-sid ja päringulimiitide päiseid.

Standardne baas-URL on https://api.openai.com/v1. Päringud autentitakse kandjapääsuloaga päises Authorization. Ärge kunagi paigutage API-võtit brauseri JavaScripti, mobiilirakendusse, avalikku koodihoidlasse ega muusse kliendipoolsesse paketti. Turvalisem lahendus on saata päringud oma serverist, nii jääb mandaat kasutaja seadmest välja.

Töölaud ja Playground

Arendaja töölaud pakub API-võtmete haldust, projekte, kasutuse jälgimist, arveldusseadeid, Chat Playgroundi, Agent Builderit ja seotud arendustööriistu. Playground kasutab sama API-taristut, seega lähevad selle päringud API kasutuse ja hinnastamise alla. See on kasulik viipade ja konfiguratsioonide testimiseks enne päringu rakenduse koodi viimist.

Millise API ja mudeli peaks valima?

Uue otse mudelile saadetava päringu puhul alustage Responses API-st. Valige ülesande, vajaliku modaalsuse, latentsuse, väljundikvaliteedi, konteksti vajaduste ja eelarve põhjal praegu saadaolev mudel. Mudelite saadavus ja täpne hinnastamine võivad muutuda, seega kontrollige valitud mudelit enne juurutamist kehtivast mudelite ja hinnastamise dokumentatsioonist.

NõueAsjakohane API võimalus
Tavaline teksti- või arutluspõhine vastusResponses API
Järk-järguline väljund genereerimise ajalResponses API voogedastus
Rakenduse kood peab toimingu sooritamaFunktsioonikutse või majutatud tööriist
Vastused peavad järgima määratletud JSON-skeemiStructured Outputs
Esitada tuleb dokumente või piltePildi- ja failisisendid, Files API või failotsing
Püsiv olek mitme seansi või orkestreerimise jaoksConversations API, Agents SDK või praegused Agents API-d

Responses API on ühe mudelisuhtluse peamine liides. Kergekaaluliseks jätkamiseks edastage previous_response_id. Seansside, seadmete, tööprotsesside või tööde vahel jagatava püsiva oleku jaoks kasutage Conversations API-t. Tööriistu, üleandmisi, kaitsemeetmeid, seansse, jälgimist või liivakastikäitumist hõlmavate hallatud agentide töövoogude puhul kasutage aegunud Assistants API asemel Agents SDK-d või praeguseid Agents API-sid.

Esimese päringu tegemine

Installige ametlik Python SDK käsuga pip install openai, määrake serverikeskkonnas OPENAI_API_KEY ja tehke Responses API päring. Allolev mudelinimi on näide esitatud praeguse platvormiteabe põhjal; kontrollige enne näite käivitamist, et see oleks teie kontol saadaval.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.responses.create(
    model="gpt-6-astra",
    instructions="You are a concise technical assistant.",
    input="Explain idempotent API retries in two sentences."
)

print(response.output_text)

Sama toimingu saab saata otse HTTPS-i kaudu:

curl -sS https://api.openai.com/v1/responses 
  -H "Authorization: Bearer $OPENAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "gpt-6-astra",
    "instructions": "You are a concise technical assistant.",
    "input": "Explain idempotent API retries in two sentences."
  }'

Tootmiskeskkonnas kontrollige HTTP olekut, käsitlege struktureeritud API-vigu, logige päringu ID ning vältige täieliku vastuse või tundliku sisendi logidesse lisamist, välja arvatud juhul, kui teie andmekäitluspoliitika seda lubab.

Kuidas vastust mõista?

Responses API tulemus ei piirdu ühe lihtsa tekstijadaga. See võib sisaldada väljundelemente, näiteks sõnumeid, arutlusega seotud elemente, tööriistakutseid ja tööriistade tulemusi. Ametlik SDK pakub mugavat viisi genereeritud teksti eraldamiseks, kui tekst on olemas: response.output_text.

Kui vastus nõuab funktsioonikutset, käivitab funktsiooni teie rakendus, mitte mudel. Teie kood loeb funktsiooni nime ja argumendid, valideerib need, sooritab toimingu ning saadab tulemuse koos seotud kutse identifikaatoriga tagasi. Seejärel saab mudel koostada kasutajale mõeldud lõpliku vastuse. Ärge käsitlege mudeli genereeritud argumente automaatselt usaldusväärse sisendina; valideerige rakenduse koodis õigused, tüübid, vahemikud ja soovitud toiming.

Vestluse jätkamine

Kergekaaluliseks serveri hallatavaks jätkamiseks edastage varasema vastuse identifikaator järgmiselt: previous_response_id:

second = client.responses.create(
    model="gpt-6-astra",
    previous_response_id=response.id,
    input="Now rewrite those tips as a checklist."
)

print(second.output_text)

Vastuseid säilitatakse vaikimisi 30 päeva, kui salvestamist ei ole keelatud. Vestlusobjektidel ja nende elementidel on eraldi püsivuskäitumine, seega valige olekumehhanism teadlikult, kui andmed peavad säilima kauem või olema jagatud rakenduse komponentide vahel.

Kuidas OpenAI API hinnastamine toimib?

OpenAI API hinnastamine põhineb peamiselt kasutusel, mitte ühel fikseeritud kuutasuga API-tellimusel. Mudeli järeldamine maksustatakse üldjuhul sisendtokenite, asjakohasel juhul vahemällu salvestatud sisendtokenite ja väljundtokenite alusel. Heli, pildid, video, reaalaja seansid ja muud modaalsused võivad kasutada erinevaid arvestusühikuid.

Majutatud võimalustega võivad kaasneda eraldi tasud. Näiteks veebotsingu päringud, failotsingu salvestus ja tööriistakutsed, majutatud konteinerid või kooditõlgenduse seansid, piltide genereerimine, video genereerimine ja reaalajaheli. Batch-, Flex-, Fast-, piirkondliku töötlemise, Scale Tieri ja Reserved Tieri valikud võivad hinda või jõudlusnäitajaid muuta.

Kõigi mudelite ja funktsioonide jaoks ei ole ühtset päringu hinda. Hinnastamine muutub sageli ning enne kulude modelleerimist või hankimist tuleks kontrollida ametlikku ajakohast hinnalehte. Jälgige rakenduses nii sisendi kui ka väljundi kasutust ning pidage meeles, et korduskatsed, pikk vestlusajalugu, tööriistakutsed, failitöötlus ja multimodaalsed sisendid võivad kogutarbimist suurendada.

API kaudu saadaolevad võimalused

Väljundi voogedastus

Voogedastus kasutab serveri saadetud sündmusi, et edastada väljundit järk-järgult. See vähendab tajutavat latentsust, sest rakendus saab osalist väljundit kuvada enne täieliku vastuse valmimist. SDK väljastab muu hulgas sündmusi, näiteks response.output_text.delta, tekstifragmentide jaoks.

stream = client.responses.create(
    model="gpt-6-astra",
    input="Explain server-sent events briefly.",
    stream=True
)

for event in stream:
    if getattr(event, "type", "") == "response.output_text.delta":
        print(event.delta, end="", flush=True)
print()

Voogedastus ei kaota vajadust käsitleda vigu ega mittetäielikku väljundit. Kasutajaliides peab arvestama ühenduse katkemise, tühistamise, modereerimise või eeskirjade rakendamisega ning võimalusega, et vastus sisaldab mittetekstilisi sündmusi.

Funktsiooni- ja tööriistakutsed

Funktsioonikutsed võimaldavad mudelil taotleda teie rakenduse kirjeldatud toimingut, näiteks tellimuse otsimist või tarnehinna arvutamist. Teie server määratleb funktsiooni skeemi, võtab kutse vastu, käivitab usaldusväärse rakenduse koodi ja saadab tulemuse. Mudel ei saa sellega otsest juurdepääsu teie andmebaasile ega ärisüsteemidele.

OpenAI pakub ka majutatud tööriistu, sealhulgas veebiotsingut, failotsingut, kooditõlgendust, piltide genereerimist, arvuti kasutamisega seotud võimalusi, kaug-MCP-d, shelli ja tööriistaotsingut. Saadavus sõltub mudelist, lõpp-punktist, kontost ja tööriistapõhistest piirangutest. Käsitlege tööriistu eraldi kulude, turvalisuse ja töökindluse piiridena.

Structured Outputs

Structured Outputs piirab toetatud mudelite ja skeemide puhul vastuse esitatud JSON Schema järgimiseks. Responses API-s seadistage teksti vorming range skeemiga:

schema = {
    "type": "object",
    "properties": {
        "answer": {"type": "string"},
        "confidence": {"type": "number"}
    },
    "required": ["answer", "confidence"],
    "additionalProperties": False
}

structured = client.responses.create(
    model="gpt-6-astra",
    input="State whether HTTPS encrypts data in transit.",
    text={
        "format": {
            "type": "json_schema",
            "name": "answer",
            "strict": True,
            "schema": schema
        }
    }
)

print(structured.output_text)

Structured Outputs erineb varasemast JSON-režiimist. JSON-režiimi eesmärk on luua korrektne JSON, Structured Outputs on aga mõeldud esitatud skeemi jõustamiseks JSON Schema toetatud alamhulgas. Rakendus peab siiski tagastatud andmeid valideerima ning käsitlema keeldumist, kärpimist ja transpordivigu.

Failid, pildid ja multimodaalne sisend

Ühilduvad mudelid võivad vastu võtta piltide URL-e, üleslaaditud pilte, failide identifikaatoreid ja dokumendisisendeid. Files API toetab failide üleslaadimist, hankimist, allalaadimist, kustutamist, aegumispoliitikate määramist ja eri otstarbeks mõeldud failide käsitlemist. Faile saab kasutada ka failotsingus, pakettöötluses, hindamistes ja muudes töövoogudes.

Piltide ja failide töötlemisega kaasnevad täiendavad privaatsuse, turvalisuse, saadavuse ja hinnastamise kaalutlused. Veenduge, et valitud mudel ja lõpp-punkt toetaksid vajalikku sisendit, ning vältige tundliku materjali üleslaadimist, kui säilitus- ja lepingulised nõuded ei ole täidetud.

Agendid, heli ja reaalajar rakendused

Laiem platvorm sisaldab reaalajas suhtluse, heli, piltide genereerimise, video genereerimise, manuste, modereerimise, failide, pakettide, hindamiste ja agentide töövoogude API-sid ning tööriistu. Agents SDK lisab orkestreerimisfunktsioonid, näiteks tööriistad, üleandmised, agentidena kasutatavad tööriistad, kaitsemeetmed, seansid, jälgimise, voogedastusega käitused, hääleagendid, reaalajaagendid ja liivakastiagendid. OpenAI mudelite kutsumiseks kasutab see vaikimisi Responses API-t, pakkudes samal ajal kõrgema taseme käituskeskkonda.

SDK-d ja toetatud programmeerimiskeeled

Ametlikud SDK-d ja teegid on saadaval Pythonile, JavaScriptile ja TypeScriptile, Go-le, Javale, .NET-ile ja Rubyle. Ametlikud Pythoni ja JavaScripti SDK-d pakuvad Responses API-le otsest ligipääsu. PHP-rakendused saavad kasutada REST API-t cURL-i või muu HTTP-kliendi kaudu; teenusepakkuja spetsiifiline PHP SDK ei ole vajalik.

Kasutage järjepidevalt üht praegust SDK versioonipõlvkonda. Hoidke SDK versioonid kontrolli all, testige mudelite ja funktsioonide saadavust tootmisevälises projektis ning tutvuge praeguse API viitega, kui päring kasutab tööriistu, struktureeritud väljundeid, voogedastust, faile või olekut.

Täiustatud näide: funktsiooni deklareerimine

Järgnev JavaScripti muster deklareerib funktsiooni. See näitab deklaratsiooni etappi; tootmiskood peab kontrollima tagastatud funktsioonikutsete elemente, valideerima argumendid, käivitama funktsiooni ja saatma tulemuse järelpäringuga.

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: "What is the weather in Paris?",
  tools: [{
    type: "function",
    name: "get_weather",
    description: "Get the current weather for a city.",
    parameters: {
      type: "object",
      properties: { city: { type: "string" } },
      required: ["city"],
      additionalProperties: false
    },
    strict: true
  }]
});

console.log(response.output);

Päris rakenduses peaks funktsioon kutsuma heakskiidetud ilmateenust, jõustama autoriseerimise ja sisendi valideerimise ning tagastama piiratud tulemuse. Ärge lubage mudelil valida suvalisi URL-e, shellikäske, andmebaasipäringuid ega õigustega toiminguid ilma selgesõnalise turvakihita.

Piirangud ja tootmiskeskkonna kaalutlused

Päringulimiidid, korduskatsed ja latentsus

Piirangud sõltuvad organisatsioonist, projektist, mudelist, lõpp-punktist, kasutustasemest ja töötlemisrežiimist. Responses API vastused sisaldavad päringu- ja tokenipäiseid, näiteks x-ratelimit-limit-requests, x-ratelimit-remaining-requests ja x-ratelimit-reset-requests, koos nende tokenipõhiste vastetega.

Tootmiskliendid peaksid neid päiseid kontrollima, järgima võimaluse korral edastatud väärtust retry-after, kasutama korduskatseteks piiratud eksponentsiaalset tagasiviivitust ning logima päringute ID-d. Korduskatsed tuleb hoolikalt kavandada: kirjutuskaitstud genereerimise kordamine võib olla sobiv, kuid kliendilt tasu võtva või olekut muutva tööriistakutse kordamine võib tekitada topeltmõjusid. Vajaduse korral kasutage oma rakenduses idempotentsuse kontrolli.

Latentsus sõltub mudelist, viiba ja väljundi suurusest, arutluse intensiivsusest, tööriistade kasutamisest, järjekorrast, võrgutingimustest ja töötlemistasemest. Voogedastus parandab esimese nähtava väljundini jõudmise aega, kuid ei pruugi vähendada genereerimise koguaega. Fast- ja ettevõtetele mõeldud mahutavusvalikud võivad sobilike kontode jõudlust parandada.

Privaatsus ja andmete säilitamine

OpenAI sõnul ei kasutata API andmeid vaikimisi mudelite treenimiseks ega täiustamiseks, välja arvatud juhul, kui klient sellega sõnaselgelt nõustub. Kuritarvituste jälgimise logisid säilitatakse vaikimisi üldjuhul kuni 30 päeva. Responses API vastuseid säilitatakse vaikimisi 30 päeva ning neid saab luua salvestamiseta; failidel ja vestlustel on oma püsivuskäitumine.

Nõuetele vastavad organisatsioonid võivad taotleda selliseid kontrolle nagu Zero Data Retention või Modified Abuse Monitoring, kuid kehtivad lõpp-punkti, funktsiooni, geograafilised ja lepingulised piirangud. Piltide ja failide sisendeid võidakse töödelda spetsiaalse turvakontrolli abil. Enne isikuandmete, konfidentsiaalse, reguleeritud või kliendile kuuluva teabe saatmist tutvuge kohaldatavate andmekontrollidega.

Pärandfunktsioonid ja saadavuse erandid

Pärandfunktsioon Assistants API ei ole mõeldud uute integratsioonide jaoks. Soovitatavad üleminekuteed on Responses API, Conversations API, Agents SDK või praegused Agents API-d. Peenhäälestus on sobilikele olemasolevatele kasutajatele endiselt dokumenteeritud, kuid praegune hinnastamisteave kirjeldab peenhäälestusplatvormi sulgemist ja seda, et uued kasutajad sellele enam ligi ei pääse. Ärge muutke uut projekti peenhäälestusest sõltuvaks, ilma et oleksite konto sobivust kinnitanud.

Üksikutel mudelitel, tööriistadel, piirkondadel, modaalsustel, töötlemistasemetel ja skeemidel võivad olla eraldi piirangud. Kontrollige saadavust ja täpset käitumist kehtivast dokumentatsioonist, mitte ärge eeldage, et iga võimalus töötab iga mudeliga.

Millal on OpenAI API hea või halb valik?

See on hea valik, kui:

  • Soovite majutatud API-t ametlike SDK-de ja ühtse ajakohase liidesega.
  • Rakendus vajab teksti kõrval pildi-, faili-, heli-, otsingu- või tööriistafunktsioone.
  • Soovite voogedastust, funktsioonikutseid, struktureeritud JSON-väljundit või hallatud vestlusolekut.
  • Eelistate kasutuspõhist arveldamist ega soovi mudelitaristut ise hallata.
  • Vajate võimalust liikuda lihtsast mudelipäringust tööriistade või agentide orkestreerimiseni.

See võib olla halb valik, kui:

  • Rakendus peab töötama täielikult võrguühenduseta või taristus, mis ei saa välise teenusega ühendust võtta.
  • Muutuv kasutuspõhine kulu on vastuvõetamatu või raskesti jälgitav.
  • Nõuded sõltuvad mudelist, tööriistast, piirkonnast, säilituspoliitikast või peenhäälestuse töövoost, mida teie konto ei toeta.
  • Süsteem ei talu võrgu latentsust, teenusekatkestusi, mudelite muutuva saadavuse ega lõpp-punktide arenguga kaasnevaid muutusi.
  • Te ei saa töödeldava teabe jaoks kehtestada vastuvõetavat privaatsus- ja andmete säilitamise korda.

Esimese rakenduse puhul alustage ühe serveripoolse Responses API päringuga, lisage kasutuse ja vigade logimine ning võtke voogedastus, struktureeritud väljundid, failid, tööriistad või Agents SDK orkestreerimine kasutusele alles siis, kui rakendus neid vajab. Nii jääb esialgne integratsioon arusaadavaks, kuid alles jääb võimalus täiustatud töövoogudeks.

Allikad 18