xAI API juhend: Groki hinnad, tööriistad, SDK-d ja näited

Platvorm

API ülevaade

Lõppunktid (endpoints)

API ligipääs

Juuraadress (Base URL)


					https://api.x.ai

Peamine API Responses API

Hinnad

API Hinnad

Hinnakujundusmudel Kasutuspõhine hinnastamine, mille arvestus põhineb teenusest sõltuvalt tokenitel, tööriistakutsetel, piltidel, video kestusel, heli kestusel või tähemärkide arvul; saadaval on ettemakstud krediit ja ettevõtetele mõeldud arveldamine.

Dokumenteeritud Grok 4.7 hind on 2 dollarit 1 miljoni lühikese konteksti sisendtokeni ja 6 dollarit 1 miljoni väljundtokeni kohta. Pika konteksti, vahemällu salvestatud sisendi, arutlusvõime, meedia, hääle ning serveripoolsete tööriistade hinnad varieeruvad mudeli ja toimingu järgi.

Arendaja töömugavus

SDK info

SDK Ametlik Pythoni SDK xai-sdk koos natiivse gRPC-toega; ühilduvus OpenAI Pythoni ja JavaScripti SDK-dega xAI baas-URL-i kaudu; JavaScripti tugi @ai-sdk/xai ja Vercel AI SDK kaudu; toetatud on ka gRPC ja otse HTTP-päringud.

Kasutusmugavus Kõrge kasutusmugavus arendajatele, kes tunnevad OpenAI-ga ühilduvaid API-sid. API-võtmed luuakse Console'is, REST API järgib tuttavaid skeeme ning saadaval on ametlikud või ühilduvad SDK-d.

Dokumentatsioon Põhjalik ja aktiivselt ajakohastatud dokumentatsioon, mis sisaldab kiirjuhendeid, mudelite kataloogi, REST- ja gRPC-viiteid, võimaluste juhendeid, hinnateavet, päringumäärade piiranguid, turvalisuse KKK-d ning koodinäiteid. Mõned API-d ja integratsioonid

Viivitus Mudeliti erinev; sõltub konteksti pikkusest, arutlusseadistusest, väljundi mahust ja tööriistade kasutamisest. Interaktiivsete ja agentpõhiste päringute puhul on soovitatav kasutada voogedastust. Korduvate voorude korral on saadaval Responses API WebSocke

Allikad

Viited arendajale

Dokumentatsioon ↗ API juhend ↗ Liivakast ↗

Featuurid

API võimekused

✓ Voogedastus

✓ Funktsioonide kasutamine

✓ Assistants API

✓ Failide üleslaadimine

✓ Veebiotsing

✓ Pildi sisend

✓ Struktureeritud väljund

✓ Liivakast

Lühikirjeldus

Praegune platvorm hõlmab Responses API-t, Chat Completionsit ning piltide, video, hääle, failide, pakettide, mudelite, halduse ja gRPC liideseid. Responses API on uute agentipõhiste rakenduste eelistatud arhitektuur ning toetab mitme vooruga olekut, voogedastust, serveripoolseid tööriistu ja kohandatud funktsioonikutseid. Chat Completions on tavapäraste vestluspõhiste töökoormuste jaoks endiselt toetatud. Structured Outputs toetab JSON Schema ja JSON-objekti režiime. Web Search ja X Search pakuvad lubamise korral ajakohast teavet; ilma otsingutööriistadeta ei ole mudelitel automaatselt juurdepääsu reaalajas teadmistele. Piltsisend on saadaval nägemisvõimekusega mudelitel; dokumenteeritud on JPEG- ja PNG-vormingu tugi ning pildi maksimaalne suurus on 20 MiB. Faile saab üles laadida ja lisada dokumentide mõistmise töövoogudesse; dokumenteeritud maksimaalne failisuurus on 512 MB. Console pakub API-võtmeid, arveldamist, kasutuse jälgimist, juurdepääsu mudelitele ja Playgroundi. Ettevõtetele mõeldud võimaluste hulka kuuluvad SSO, auditeerimislogid, igakuine arveldamine, andmete paiknemise valik, kohandatud päringumäärad, spetsiaalne tugi ja valikuline Zero Data Retention. Peenhäälestust ei õnnestunud läbi vaadatud esimese osapoole arendajadokumentatsioonis kinnitada ning seetõttu on selle olek teadmata.

Näited

API Näited

curl --fail-with-body https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "input": [
      {
        "role": "system",
        "content": "You are a concise technical assistant."
      },
      {
        "role": "user",
        "content": "Return a JSON object describing three benefits of streaming APIs."
      }
    ],
    "text": {
      "format": {
        "type": "json_schema",
        "name": "benefits",
        "schema": {
          "type": "object",
          "properties": {
            "benefits": {
              "type": "array",
              "items": {"type": "string"}
            }
          },
          "required": ["benefits"],
          "additionalProperties": false
        },
        "strict": true
      }
    }
  }' | jq -r '.output[]?.content[]?.text // empty'

# Streaming example
curl -N https://api.x.ai/v1/responses \
  -H "Authorization: Bearer $XAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "grok-4.7",
    "input": "Explain server-sent events in two sentences.",
    "stream": true
  }'

# Install: pip install xai-sdk pydantic
import json
import os
from pydantic import BaseModel
from xai_sdk import Client
from xai_sdk.chat import system, user

class Answer(BaseModel):
    summary: str
    points: list[str]

api_key = os.environ["XAI_API_KEY"]
client = Client(api_key=api_key)

chat = client.chat.create(
    model="grok-4.7",
    response_format=Answer,
)
chat.append(system("You are a concise technical assistant."))
chat.append(user("Explain why streaming is useful for an API client."))

response = chat.sample()
result = Answer.model_validate_json(response.content)
print(result.summary)
for point in result.points:
    print(f"- {point}")

# Multi-turn streaming conversation
chat.append(user("Now explain the main tradeoff."))
for accumulated, chunk in chat.stream():
    if chunk.content:
        print(chunk.content, end="", flush=True)
print()

# Client-side function calling
from xai_sdk.tools import function

weather_tool = function(
    name="get_weather",
    description="Get the current weather for a city.",
    parameters={
        "type": "object",
        "properties": {"city": {"type": "string"}},
        "required": ["city"],
        "additionalProperties": False,
    },
)

tool_chat = client.chat.create(model="grok-4.7", tools=[weather_tool])
tool_chat.append(user("What is the weather in Seattle?"))
tool_response = tool_chat.sample()
for call in tool_response.tool_calls:
    print(call.function.name, call.function.arguments)

// Install: npm install openai
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

async function main() {
  try {
    const response = await client.responses.create({
      model: "grok-4.7",
      input: [
        {
          role: "system",
          content: "You are a concise technical assistant.",
        },
        {
          role: "user",
          content: "Explain the value of streaming APIs in two sentences.",
        },
      ],
    });

    console.log(response.output_text);

    const stream = await client.responses.create({
      model: "grok-4.7",
      input: "Give me three practical API retry tips.",
      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 toolResponse = await client.responses.create({
      model: "grok-4.7",
      input: "Find the weather for Seattle using the available function.",
      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,
          },
        },
      ],
    });

    for (const item of toolResponse.output ?? []) {
      if (item.type === "function_call") {
        console.log(item.name, item.arguments);
      }
    }
  } catch (error) {
    console.error(error);
    process.exitCode = 1;
  }
}

main();

<?php
$apiKey = getenv('XAI_API_KEY');
if (!$apiKey) {
    fwrite(STDERR, "XAI_API_KEY is not set\n");
    exit(1);
}

$url = 'https://api.x.ai/v1/responses';
$payload = [
    'model' => 'grok-4.7',
    'input' => [
        [
            'role' => 'system',
            'content' => 'You are a concise technical assistant.'
        ],
        [
            'role' => 'user',
            'content' => 'Return a short explanation of why API streaming is useful.'
        ]
    ]
];

$ch = curl_init($url);
curl_setopt_array($ch, [
    CURLOPT_POST => true,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
        'Accept: application/json'
    ],
    CURLOPT_POSTFIELDS => json_encode($payload, JSON_THROW_ON_ERROR),
    CURLOPT_CONNECTTIMEOUT => 15,
    CURLOPT_TIMEOUT => 120
]);

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

$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'] ?? $body;
    throw new RuntimeException('xAI API error (' . $status . '): ' . $message);
}

$text = $data['output_text'] ?? '';
if ($text === '' && isset($data['output'])) {
    foreach ($data['output'] as $item) {
        foreach ($item['content'] ?? [] as $content) {
            if (($content['type'] ?? '') === 'output_text') {
                $text .= $content['text'] ?? '';
            }
        }
    }
}

echo $text . PHP_EOL;

Põhimõtted

Andmete kasutus

xAI kinnitab, et ei kasuta klientide API kaudu saadud sisendeid ega väljundeid mudelite treenimiseks ilma sõnaselge loata. Ettevõtete ja äriklientide andmeid ei kasutata ettevõtete KKK kohaselt mudelite treenimiseks, kuigi xAI võib pakkuda erikokkuleppeid, mille alusel antakse luba äriliste andmete kasutamiseks treeningul. Tarbijatele mõeldud Groki eeskirjad on eraldiseisvad ning neid ei tohiks API-klientidele kohaldada.

Andmete säilitamine

Vaikimisi säilitatakse API-päringuid ja -vastuseid xAI serverites 30 päeva väärkasutuse auditeerimiseks ning need on puhkeolekus krüpteeritud. Seejärel kustutatakse sisu automaatselt. Nõuetele vastavad tiimid saavad lubada kogu tiimi hõlmava Zero Data Retentioni (ZDR), mis takistab viipade ja väljundite püsivat säilitamist. ZDR keelab salvestamisest sõltuvad funktsioonid, sealhulgas olekupõhise Responses API, Filesi, Collections'i ja Batch API. Ettevõtete lepingud või andmetöötlustingimused võivad ette näha täiendavaid kontrolle.

Päringupiirangud

Mudelitepõhised piirangud on keelemudelite ja manustamismudelite puhul määratud päringute arvuna sekundis ning tokenite arvuna minutis. Piirangud suurenevad kulupõhiste tasemete järgi: tase 0 – 0 dollarit, tase 1 – 50 dollarit, tase 2 – 250 dollarit, tase

Arendaja juhend

xAI API: algaja juhend Groki, hindade, tööriistade ja SDK-de kohta

xAI API annab arendajatele OpenAI-ga ühilduva platvormi kaudu programmilise juurdepääsu Groki teksti- ja arutlusmudelitele, agentide töövoogudega Responses API-le, otsingutööriistadele, failianalüüsile, struktureeritud väljunditele, pildi- ja videoteenustele, häälfunktsioonidele ning kohandatud funktsioonikutsetele.

xAI API on mõeldud arendajatele, kes loovad Grokiga rakendusi, selle asemel et kasutada Groki ainult vestlusliidese kaudu. See pakub uute agentipõhiste rakenduste jaoks soovitatavat Responses API-t, tavapäraste vestlusrakenduste jaoks toetatud Chat Completionsi liidest, kasutuspõhist hinnastamist, voogedastust, tööriistade kutsumist, failide üleslaadimist, struktureeritud JSON-väljundit ning ametlikke või ühilduvaid SDK-sid. Selles juhendis selgitatakse, kuidas hankida autentimisandmeid, teha esimene päring, valida sobiv API-muster, hinnata kulusid ning arvestada kasutuse ja privaatsusega seotud piirangutega.

xAI API pakub kasutuspõhise hinnastusega juurdepääsu Groki teksti- ja arutlusmudelitele, agentipõhistele Responses API töövoogudele, otsingule, failidele, struktureeritud JSON-väljundile, kohandatud funktsioonidele, pildi- ja videoteenustele, häälefunktsioonidele ning muudele arendajatööriistadele. See toetab OpenAI-ga ühilduvaid REST-päringuid, ametlikku Pythoni SDK-d, JavaScripti integratsioone, voogedastust, Playgroundi, kulutustel põhinevaid päringulimiitide tasemeid ja valikulist nullandmete säilitamist (Zero Data Retention).

Mis on xAI API ja millal seda kasutada?

xAI API on arendajatele mõeldud platvorm, mille abil saab Groki mudeleid ja nendega seotud teenuseid rakendustesse integreerida. Selle asemel et saata viipasid käsitsi aadressil grok.com, saadab rakendus xAI-le autentitud HTTP-päringuid ning saab vastu genereeritud teksti, struktureeritud andmeid, tööriistakutseid või meediatulemusi.

See sobib vestlusrakenduste, dokumentide analüüsi, uurimisabiliste, kodeerimistööriistade, automatiseeritud töövoogude, klienditoesüsteemide ja agentsete rakenduste jaoks, mis vajavad otsingut või väliseid funktsioone. Platvorm pakub ka pildi- ja videogenereerimise, kõne-, faili-, pakettöötluse, mudelihalduse ja muid seotud lõpp-punkte.

Uute rakenduste puhul, mis vajavad tööriistu, mitme vooruga olekut või agendilaadset käitumist, soovitab xAI kasutada Responses API-t. Chat Completions on endiselt kasulik lihtsa tekstigenereerimise, käsitsi hallatavate vestlusajalugude ja olemasolevate rakenduste puhul, mis põhinevad OpenAI-ga ühilduval vestlusskeemil.

Kuidas saada juurdepääs xAI API-le?

Looge xAI Console'is konto, lisage ettemakstud krediiti või leppige kokku ettevõtte arveldus ning looge API-võti. Käsitlege võtit nagu parooli: hoidke seda serveripoolses saladuste halduris või keskkonnamuutujas, mitte brauserikoodis, mobiilirakenduse paketis, lähtekoodihoidlas ega avalikult jagatud näidetes.

export XAI_API_KEY="your_api_key"

Päringud kasutavad bearer-tokeni autentimist ja peamine API host on https://api.x.ai. Versioonitud järelduspunktid kasutavad tavaliselt rada /v1, sealhulgas /v1/responses ja /v1/chat/completions.

API ja mudeli valimine

Uue agentse funktsionaalsuse puhul kasutage Responses API-t. See suudab esitada genereeritud teksti, tööriistakutseid, otsingutegevust ja muid vastuselemente ning toetab voogedastust, kohandatud funktsioone, serveripoolseid tööriistu ja mitme vooruga jätkamist previous_response_id kaudu. Olekupõhised funktsioonid pole Zero Data Retentioni lubamisel saadaval.

Valige Chat Completions siis, kui teie rakendusel on juba tavapärane rollide ja sõnumite jada või kui soovite säilitada OpenAI-ga ühilduva integratsiooni. Täpne mudelite kataloog ja aliased võivad muutuda, seega kontrollige enne aegunud identifikaatori koodi sisse kirjutamist xAI praegust mudelidokumentatsiooni. Esitatud ajakohases dokumentatsioonis on grok-4.7 märgitud juhtivaks tekstimudeliks, mille kontekstiaken on 500 000 tokenit.

Esimese päringu tegemine Responses API-ga

Järgmine päring saadab lihtsa tekstiviiba. input võib lihtsa päringu korral olla string või suurema kontrolli saavutamiseks struktureeritud sõnumikogum.

curl --fail-with-body https://api.x.ai/v1/responses 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "grok-4.7",
    "input": "Explain server-sent events in two sentences."
  }'

Vastus sisaldab genereeritud väljundit ja kasutusteavet. Rakendused peaksid lugema tagastatud väljundit, mitte eeldama, et alati on olemas kindlal massiiviindeksil paiknev element või üks tekstiväli. Paljude SDK-integratsioonide puhul pakub kombineeritud teksti mugavusatribuut, näiteks output_text.

SDK kasutamine toore HTTP asemel

xAI pakub xai-sdk Pythoni paketti, millel on natiivne gRPC-tugi. REST API ühildub ka OpenAI Pythoni ja JavaScripti SDK-dega, kui baasaadress muuta xAI lõpp-punktiks. JavaScripti arendajad saavad lisaks kasutada Vercel AI SDK-ga @ai-sdk/xai pakkujat.

See JavaScripti näide kasutab praegust OpenAI-ga ühilduva kliendi stiili ja Responses API-t:

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.XAI_API_KEY,
  baseURL: "https://api.x.ai/v1",
});

const response = await client.responses.create({
  model: "grok-4.7",
  input: [
    { role: "system", content: "You are a concise technical assistant." },
    { role: "user", content: "List three benefits of API streaming." }
  ]
});

console.log(response.output_text);

Kasutage ametlikku Pythoni SDK-d, kui vajate selle kõrgema taseme vestlusliidest, tüübitud vastusevorminguid või natiivset gRPC-käitumist. Toorest HTTP-d kasutage siis, kui vajate päringute üle otsest kontrolli või integreerite teenust keelest, mille jaoks sobivat SDK-d pole.

Vastuste voogedastus interaktiivsete rakenduste jaoks

Voogedastus saadab osalised tulemused nende valmimise järel, selle asemel et oodata täieliku vastuse valmimist. xAI toetab serverist saadetavaid sündmusi (SSE), kui stream väärtuseks on määratud true. See on kasulik vestlusliideste ning pikaajaliste arutlus- või tööriistapõhiste töövoogude puhul, sest kasutajad näevad edenemist varem.

curl -N https://api.x.ai/v1/responses 
  -H "Authorization: Bearer $XAI_API_KEY" 
  -H "Content-Type: application/json" 
  -d '{
    "model": "grok-4.7",
    "input": "Give me three practical API retry tips.",
    "stream": true
  }'

JavaScripti SDK vood edastavad selliseid sündmusi nagu response.output_text.delta. Klient peaks käsitlema lõpetamissündmusi, tõrkeid ja katkestusi, mitte pidama iga sündmust tekstiks. Korduvate järjestikuste Responses API voorude jaoks pakub xAI ka WebSocketi režiimi, mis võib vähendada ühenduste loomisega seotud koormust.

Kuidas xAI API hinnastamine toimib?

xAI kasutab kasutuspõhist hinnastamist, mitte üht piiramatut API-tellimust. Tekstikasutust võidakse arvestada sisendtokenite, vahemällu salvestatud sisendtokenite, arutlustokenite ja väljundtokenite alusel. Hinnad sõltuvad mudelist ning võivad lühikese ja pika konteksti puhul erineda.

Esitatud dokumentatsioonis on grok-4.7 hinnaks märgitud 2 dollarit 1 miljoni lühikese konteksti sisendtokeni eest ja 6 dollarit 1 miljoni väljundtokeni eest. Pika kontekstiga päringutel, vahemällu salvestatud sisendil, arutlusel ja teistel mudeliperedel on eraldi hinnad. Pildi-, video-, kõne-, kõnetuvastus-, kõnesünteesi- ja serveripoolsed tööriistad võivad kasutada teistsuguseid hinnastamisühikuid.

Vastused võivad sisaldada tegelikku päringu maksumust kasutuse metaandmetes cost_in_usd_ticks kaudu. Lisage need andmed rakenduse seiresse, et võrrelda kulu kasutaja, funktsiooni, mudeli ja töövoo lõikes. Tööriistakutsed võivad suurendada nii latentsust kui ka kulu, sest üks kasutajapäring võib käivitada mitu mudeli- või teenusetoimingut.

Platvormi kaudu saadaolevad võimalused

Tekst ja arutlus: genereerige Groki mudelite abil vastuseid, kokkuvõtteid, koodi, klassifikatsioone ja muud tekstilist väljundit.
Otsing: kasutage serveripoolset veebiotsingut ja X Searchi, kui rakendus vajab ajakohast teavet. Mudelitel pole automaatselt reaalajas teadmisi, kui lubatud otsingutööriista ei kasutata.
Nägemisvõime ja failid: nägemisvõimega mudelid saavad vastu võtta pildisisendeid, sealhulgas toetatud JPEG- ja PNG-pilte. Dokumentatsioonis on pildi maksimaalseks suuruseks märgitud 20 MiB. Files API toetab dokumentide üleslaadimist; dokumenteeritud faili maksimaalne suurus on 512 MB.
Meedia ja kõne: eraldi teenused pakuvad pildi- ja videogenereerimist, kõne-, kõnetuvastus- ja kõnesünteesivõimalusi.
Struktureeritud väljund: taotlege JSON Schema piirangutega väljundit või JSON-objekti väljundit, kui järgmine töötlemisetapp vajab ettearvatavaid välju.
Agentsed töövood: ühendage mudeli vastused otsingu, koodi käivitamise, failiotsingu, kollektsioonide, MCP-integratsioonide ja kohandatud funktsioonidega.

Rakenduse loogika ühendamine funktsioonikutsete abil

Funktsioonikutsed võimaldavad mudelil taotleda toimingut, mille rakendus ise ellu viib. Näiteks võib mudel koostada struktureeritud päringu get_weather kohta; teie server valideerib argumendid, kutsub ilmateenust ja saadab tulemuse järgmise mudelivooru jaoks tagasi. Mudel ei käivita teie privaatset funktsiooni automaatselt.

const response = await client.responses.create({
  model: "grok-4.7",
  input: "Find the weather for Seattle using the available function.",
  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
    }
  }]
});

for (const item of response.output ?? []) {
  if (item.type === "function_call") {
    console.log(item.name, item.arguments);
  }
}

Määratlege selge piiritlusega tööriistad, kasutades üheselt määratletud JSON Schem'it, valideerige kõik argumendid serveris, rakendage autoriseerimiskontrolle ja ärge käivitage suvalisi mudeli genereeritud käske. xAI pakub ka serveripoolseid tööriistu, näiteks veebiotsingut, X Searchi, koodi käivitamist, kollektsioonide otsingut, manuste otsingut, pildigenereerimist ja MCP-integratsioone.

Struktureeritud väljundid ja failitöövood

Structured Outputs saab piirata vastuse esitatud JSON Schema järgimisega. REST API toetab vorminguid, sealhulgas json_schema ja json_object. See on kasulik, kui rakendus peab tulemused andmebaasi salvestama või teisele programmile edastama, kuid kood peab siiski arvestama keeldumise, lõpetamata väljundi, valideerimistõrgete ja ootamatu sisuga.

Faile saab üles laadida ja lisada dokumentide mõistmise töövoogudesse või kasutada kollektsioonidega semantilise otsingu tegemiseks. Toetatud dokumenditüüpide hulka kuuluvad levinud teksti-, koodi-, CSV-, JSON- ja PDF-vormingud ning muud formaadid. Failihaldus ja kollektsioonifunktsioonid sõltuvad xAI-poolsest salvestusest ning pole seetõttu saadaval, kui Zero Data Retention keelab salvestusest sõltuvad võimalused.

Playground ja arendajatööriistad

xAI Console pakub API-võtmete haldust, arveldamist, kasutuse jälgimist, meeskonna haldust ja Playgroundi, kus saab viipasid ning mudeleid enne rakendusse integreerimist katsetada. Platvorm pakub ka REST- ja gRPC-liideseid, mudelidokumentatsiooni, võimaluste juhendeid ja API-viiteid.

Kasutage Playgroundi kiireteks katsetusteks, kuid testige tootmiskäitumist sama SDK- või HTTP-tee kaudu, mida teie rakendus hakkab kasutama. Pange kirja valitud mudel, viip või süsteemijuhised, tööriistade määratlused, sisendi suurus, väljundi suurus, latentsus ja kulu, et muudatusi saaks järjepidevalt hinnata.

Päringupiirangud, töökindlus ja privaatsus

Keele- ja manustamismudelite päringupiirangud põhinevad päringutel sekundis ja tokenitel minutis ning need määratakse mudeli ja meeskonna kaupa. Dokumenteeritud kulupõhised tasemed algavad 0. tasemest, mille kumulatiivne kulu on 0 dollarit, sellele järgnevad 1. tase 50 dollari, 2. tase 250 dollari, 3. tase 1000 dollari ja 4. tase 5000 dollari juures; ettevõtetele on taotluse alusel saadaval eraldi piirangud. Meedia- ja kõneteenustel on toimingupõhised päringu-, samaaegsus- või seansipiirangud. Piirangu ületamisel tagastatakse HTTP 429.

Kasutage ajutiste piiranguvastuste korral eksponentsiaalset tagasijätmist, lisage päringutele ajalõpud ja vältige kogu minuti liikluse koondamist ühte sekundisse. Latentsus sõltub mudelist, konteksti pikkusest, arutluse seadistusest, väljundi suurusest ja tööriistade kasutamisest. Interaktiivsete või agentsete toimingute puhul on voogedastus üldjuhul eelistatav.

xAI väidab, et ei treeni kliendi API sisendite ega väljundite põhjal ilma sõnaselge loata. Vaikimisi võidakse API-päringuid ja -vastuseid kuritarvitamise auditeerimiseks säilitada 30 päeva ning need on jõudeolekus krüpteeritud. Nõuetele vastavad meeskonnad saavad lubada Zero Data Retentioni, mis takistab viipade ja väljundite püsimälu, kuid keelab olekupõhised Responsesi, Filesi, Collections'i ja Batchi toimingud. Ettevõttekliendid võivad saada lisakontrolle, näiteks SSO, auditilogid, arveldamise, andmete asukoha määramise, kohandatud piirangud ja spetsiaalse toe.

Millal on xAI API hea või halb valik?

xAI API sobib hästi siis, kui rakendus vajab Groki mudeleid, veebiotsingu või X Searchi kaudu ajakohast teavet, tööriistapõhiseid töövooge, multimodaalseid teenuseid, failianalüüsi või OpenAI-ga ühilduvat integratsiooniteed. Selle Responses API on eriti asjakohane rakenduste puhul, mis ühendavad mudeli väljundi funktsioonide, otsingu, failide või muude agentsete etappidega.

See võib olla halb valik juhul, kui töökoormus eeldab muutuvast tööriistade ja meedia kasutusest hoolimata fikseeritud ning hõlpsasti prognoositavaid kulusid, iga funktsiooni ranget kättesaadavust Zero Data Retentioni korral või piiranguid ja mudelikäitumist, mis ei muutu kunagi. Otsingutulemused ja genereeritud sisu vajavad endiselt rakendusepõhist kontrolli. Enne tootmisse juurutamist kontrollige praegust mudelite kataloogi, hindu, päringupiiranguid, piirkondlikku saadavust, säilitamistingimusi ja kasutatava konkreetse mudeli võimalusi.

Allikad 18