Source: https://ailoot.ai/models/cs/gpt-5-5/
Canonical: https://ailoot.ai/models/cs/gpt-5-5/
Language: cs
# OpenAI: GPT-5.5
[Markdown](https://ailoot.ai/models/cs/gpt-5-5/index.md) · [JSON](https://ailoot.ai/models/cs/gpt-5-5/facts.json)
## [OpenAI: GPT-5.5](https://ailoot.ai/models/cs/gpt-5-5/)
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-0)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-1)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-3)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-4)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-5)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-5.5`](https://ailoot.ai/models/cs/gpt-5-5/#method-6)
O modelu
Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu.
GPT-5.5 je model OpenAI pro složitou odbornou pracovní zátěž. Jeho zveřejněná role zahrnuje uvažování a rozsáhlou technickou práci. Textové, obrazové a souborové vstupy podporují textový výstup, s nastavením uvažování, volání funkcí jako nástrojů a strukturovaných výstupů v profilu hostujícího prostředí. Uvedené kontextové okno má 1 050 000 tokenů a limit generované odpovědi dosahuje 128 000 tokenů.
#### Definujte výsledek a podmínky jeho přijetí
U vývojového úkolu určete chování, které se má dodat, relevantní zdrojový kód a pozorování ukazující současný problém. U analýzy pojmenujte rozhodnutí, které má podpořit, a kritéria určující doporučení. Omezení a požadované výstupy uveďte výslovně, aby šlo navržený výsledek posoudit vůči skutečnému úkolu.
Rozsáhlé zadání může rozlišovat prokázaná fakta, současné předpoklady a otevřené otázky. Označte dodané dokumenty, obrázky a kód, aby závěry zůstaly propojené se svými zdroji. Pokud výsledek závisí na snímku obrazovky nebo souboru, určete podstatnou část místo spoléhání na to, že model odvodí úkol jen z přílohy.
#### Uvažování, nástroje a strukturované výstupy
Zveřejněný profil uvádí nastavení uvažování, volání nástrojů a strukturované výstupy. Definujte operace, které aplikace může provádět, a zachovávejte vrácená pozorování. Navržený příkaz, získání dat nebo změna souboru a jejich skutečný výsledek mají v pracovním postupu odlišné role; uchovejte výsledek jako důkaz pro další krok.
U strukturovaného výstupu určete názvy polí, typy, jednotky a zacházení s chybějícími hodnotami. Před použitím záznamu v jiném systému ověřte jeho podobu i věcný obsah. U zprávy oddělujte zjištění ze zdrojů od interpretace a ukažte důkazy podporující závěr.
#### Pokračujte z prokázaného stavu
Využijte dlouhý kontext k uchování souvisejících materiálů a již učiněných rozhodnutí pohromadě a ponechte místo pro odpověď. Uchovejte poslední relevantní pozorování a odstraňte opakování, která již úkol nemění. Užitečný konečný výstup spojuje závěr nebo změnu kódu s důkazy potřebnými k jejich prověření, aby další práce mohla pokračovat z již prokázaného výsledku.
Praktická úloha
### Praktická úloha
Technický příklad v angličtině
```
Choose a scheduling policy from evidence
Choose a dispatch policy using these facts: A sends every hour and costs 40 units per day; B sends twice daily and costs 18 units. The team requires delivery within three hours during business hours. Write a decision memo with a recommendation, the decisive constraint and one missing operational detail. Use only these facts.
```
#### Očekávaný výsledek
```
A recommendation tied to the stated service requirement, cost comparison and one unresolved detail.
```
#### Ověření výsledku
```
A cheaper policy must not be recommended as meeting a three-hour requirement without supporting timing evidence.
```
**Ailoot · Anthropic Messages** `POST /v1/messages` `gpt-5.5`
[`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages)
OpenAI /`gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 050 000 tokens
Maximální výstup
128 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,005 US$ */ 1K*
Výstup
0,03 US$ */ 1K*
Čtení z mezipaměti
0,0005 US$ */ 1K*
Zápis do mezipaměti
0,005 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,005 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 272 000\] | Vstup0,005 US$ | Výstup0,03 US$ | Čtení z mezipaměti0,0005 US$ | Zápis do mezipaměti0,005 US$ | Mezipaměť 5 min0,005 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(272 000; ∞) | Vstup0,01 US$ | Výstup0,045 US$ | Čtení z mezipaměti0,001 US$ | Zápis do mezipaměti0,01 US$ | Mezipaměť 5 min0,01 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="gpt-5.5",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "gpt-5.5",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.messages.stream(model='gpt-5.5',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `gpt-5.5`
[`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=responses)
OpenAI /`gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 050 000 tokens
Maximální výstup
128 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity gpt-5.5 | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,005 US$ */ 1K*
Výstup
0,03 US$ */ 1K*
Čtení z mezipaměti
0,0005 US$ */ 1K*
Zápis do mezipaměti
0,005 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,005 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 272 000\] | Vstup0,005 US$ | Výstup0,03 US$ | Čtení z mezipaměti0,0005 US$ | Zápis do mezipaměti0,005 US$ | Mezipaměť 5 min0,005 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(272 000; ∞) | Vstup0,01 US$ | Výstup0,045 US$ | Čtení z mezipaměti0,001 US$ | Zápis do mezipaměti0,01 US$ | Mezipaměť 5 min0,01 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/responses \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.responses.create(model="gpt-5.5", input="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "gpt-5.5", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
with client.responses.stream(model="gpt-5.5", input="Explain the difference between an observation and a hypothesis in three sentences.") as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=responses)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=responses), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `gpt-5.5`
[`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat)
OpenAI /`gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 050 000 tokens
Maximální výstup
128 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,005 US$ */ 1K*
Výstup
0,03 US$ */ 1K*
Čtení z mezipaměti
0,0005 US$ */ 1K*
Zápis do mezipaměti
0,005 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,005 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 272 000\] | Vstup0,005 US$ | Výstup0,03 US$ | Čtení z mezipaměti0,0005 US$ | Zápis do mezipaměti0,005 US$ | Mezipaměť 5 min0,005 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(272 000; ∞) | Vstup0,01 US$ | Výstup0,045 US$ | Čtení z mezipaměti0,001 US$ | Zápis do mezipaměti0,01 US$ | Mezipaměť 5 min0,01 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 2 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-5.5", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = OpenAI(base_url="https://api.ailoot.ai/v1", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
resp = client.chat.completions.create(
model="gpt-5.5",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "gpt-5.5",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='gpt-5.5',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gpt-5.5`
[`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat)
OpenAI /`gpt-5.5`
ID modelu
- `gpt-5.5`
- `openai/gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`
Výstup
`text`
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Textová konverzace | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`material_types` | Kontrakttext |
| Parametr`messages` | Kontraktpole zpráv se strukturou role/content |
| Parametr`file_material` | Kontraktskutečný dokument UTF-8 vložený jako doslovný text; ID souboru se neodvozuje |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`control_scope` | KontraktTextová konverzace; stream je booleovská hodnota a ve výchozím nastavení je false. |
| Parametr`output_modalities` | Kontrakttext |
| Parametr`hosted_operations` | Kontraktfalse |
| Parametr`multimodal_input_binding` | Kontraktnull |
Aliasy metody: `/chat/completions`
Životní cyklus: `synchronous_or_streamed`
Odešlete přesné ID modelu spolu s messages.
Délka kontextu není limitem výstupu.
Textový soubor může dodat doslovný text; obrazové/zvukové vstupy a vstupy v podobě souborových objektů vyžadují přesnou vazbu.
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · none
Standardní sazba Při intenzitě uvažování none
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · OpenAI Chat
curlPython SDK
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"gpt-5.5","messages":[{"role":"user","content":"hello"}],"stream":false}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="gpt-5.5", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gpt-5.5`
[`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages)
OpenAI /`gpt-5.5`
ID modelu
- `gpt-5.5`
- `openai/gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
Výstupní formát
JSON nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · none
Standardní sazba Při intenzitě uvažování none
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "gpt-5.5",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'gpt-5.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'gpt-5.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5.5`
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat)
OpenAI /`openai/gpt-5.5`
ID modelu
- `gpt-5.5`
- `openai/gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`
Výstup
`text`
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity openai/gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity function Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`modalities` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity text | Výchozí— |
| Pole`provider` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Podmínky: provider.options je na této textové trase Ultra odmítáno | Výchozí— |
| Pole`cache_control.ttl` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Podmínky: Hodnota 1h je ve skutečných umístěních mezipaměti promptů odmítána | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`material_types` | Kontrakttext |
| Parametr`messages` | Kontraktpole zpráv se strukturou role/content |
| Parametr`file_material` | Kontraktskutečný dokument UTF-8 vložený jako doslovný text; ID souboru se neodvozuje |
| Parametr`optional_controls` | Kontraktstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parametr`control_scope` | Kontraktspecifické pro model; nástroje uživatelských funkcí se liší od hostovaných nástrojů |
| Parametr`output_modalities` | Kontrakttext |
| Parametr`hosted_operations` | Kontraktfalse |
| Parametr`multimodal_input_binding` | Kontraktnull |
Životní cyklus: `synchronous_or_streamed`
Odešlete přesné ID modelu spolu s messages.
Délka kontextu není limitem výstupu.
Textový soubor může dodat doslovný text; obrazové/zvukové vstupy a vstupy v podobě souborových objektů vyžadují přesnou vazbu.
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · none
Standardní sazba Při intenzitě uvažování none
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · OpenAI Chat
curlPython SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "openai/gpt-5.5", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
-H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```
```python
from openai import OpenAI
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='openai/gpt-5.5',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
save_result(result.to_dict(mode="json"))
```
```python
from openai import OpenAI
import os
from pathlib import Path
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path
def save_result(data, stem="result"):
# Keep every field, including usage, IDs, reasoning and tool requests.
Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
print(json.dumps(data, ensure_ascii=False, indent=2))
def save_blob(encoded, suffix, label):
raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
file = Path(stem + "-" + label + "." + ext)
file.write_bytes(raw)
print("Saved", file)
for index, block in enumerate(data.get("content") or []):
print("Content", index, json.dumps(block, ensure_ascii=False))
for choice in data.get("choices") or []:
print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
for index, item in enumerate(data.get("output") or []):
print("Output", index, json.dumps(item, ensure_ascii=False))
if item.get("type") == "image_generation_call" and item.get("result"):
save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
for ci, candidate in enumerate(data.get("candidates") or []):
for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
blob = part.get("inlineData") or part.get("inline_data")
if blob and blob.get("data"):
mime = blob.get("mimeType") or blob.get("mime_type")
suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))
with client.chat.completions.stream(model='openai/gpt-5.5',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
for event in stream:
payload=event.to_dict(mode="json")
log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
print(json.dumps(payload,ensure_ascii=False))
final=stream.get_final_completion()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=chat), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-5.5`
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages)
OpenAI /`openai/gpt-5.5`
ID modelu
- `gpt-5.5`
- `openai/gpt-5.5`
### Úvod
GPT-5.5 je model OpenAI pro složitou odbornou práci, uvažování a softwarové úlohy. Jeho zveřejněný profil přijímá text, obrázky a soubory pro textové odpovědi, s použitím nástrojů, strukturovanými výstupy a kontextovým oknem o velikosti 1 050 000 tokenů.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
Výstupní formát
JSON nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity openai/gpt-5.5 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
Intenzita uvažování · vysoká
Standardní sazba Při vysoké intenzitě uvažování
Intenzita uvažování · nízká
Standardní sazba Při nízké intenzitě uvažování
Intenzita uvažování · střední
Standardní sazba Při střední intenzitě uvažování
Intenzita uvažování · none
Standardní sazba Při intenzitě uvažování none
Intenzita uvažování · xhigh
Standardní sazba Při intenzitě uvažování xhigh
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetně272 000 | Poplatek Vstup · Vstupní tokeny **$0.01** / 1K tokenů Výstup · Výstupní tokeny **$0.06** / 1K tokenů Vstup · Čtení z mezipaměti **$0.001** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 2 | Tabulka sazeb— | Tokeny kontextu, více než272 000 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.02** / 1K tokenů Výstup · Výstupní tokeny **$0.09** / 1K tokenů Vstup · Čtení z mezipaměti **$0.002** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "openai/gpt-5.5",
"max_tokens": 128,
"messages": [
{
"role": "user",
"content": "Summarize the incident report."
}
],
"stream": false
}
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'openai/gpt-5.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
-H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
--data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```
```python
import json, os
from pathlib import Path
source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
raise SystemExit('Choose a document containing text')
payload = {'model': 'openai/gpt-5.5', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError
api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
with urlopen(request, timeout=120) as response:
raw = response.read()
Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
Path('result.json').write_bytes(error.read())
Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path
result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages)
**Ailoot Ultra** [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages), [`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`openai/gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=openai%2Fgpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Core&caller=gpt-5.5&fmt=messages), [`gpt-5.5`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5.5&route=Ultra&caller=gpt-5.5&fmt=messages)
FAQ · OpenAI: GPT-5.5
Jaké vstupy a výsledky jsou dostupné?
`POST /v1/messages` · `gpt-5.5`: `text`, `image` → `text` `POST /v1/responses` · `gpt-5.5`: `text`, `image` → `text` `POST /v1/chat/completions` · `gpt-5.5`: `text`, `image` → `text` `POST /v1/chat/completions` · `gpt-5.5`: `text` → `text` `POST /v1/messages` · `gpt-5.5`: `text` → `json`, `sse` `POST /v1/chat/completions` · `openai/gpt-5.5`: `text` → `text` `POST /v1/messages` · `openai/gpt-5.5`: `text` → `json`, `sse`
Jaká pole požadavek používá?
`POST /v1/messages` · `gpt-5.5`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `gpt-5.5`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `gpt-5.5`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `gpt-5.5`: `model`, `messages`, `stream` `POST /v1/messages` · `gpt-5.5`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `openai/gpt-5.5`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `openai/gpt-5.5`: `model`, `messages`, `max_tokens`, `stream`
Jaké limity platí?
`POST /v1/messages` · `gpt-5.5`: `ctx`: `1050000`; `max_out`: `128000`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `gpt-5.5`: `ctx`: `1050000`; `max_out`: `128000` `POST /v1/chat/completions` · `gpt-5.5`: `ctx`: `1050000`; `max_out`: `128000`; `messages.min_items`: `1` `POST /v1/chat/completions` · `gpt-5.5`: `messages.min_items`: `1` `POST /v1/chat/completions` · `openai/gpt-5.5`: `messages.min_items`: `1`
Připojte Ailoot k Claude Code, OpenCode, Hermes nebo vlastní aplikaci.
## Společnost a její portfolio projektů
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
## Nakupujte tokeny se slevou.
Sleva předplatného pro pravidelnou práci. Promo kódy až 50% na nákup tokenů.
Předplatné
Pro pravidelné požadavky vyberte tarif se slevou.
Promo kód až 50%
Při nákupu zadejte kód. Cena se přepočítá podle probíhající akce.
Výdaje v historii
U každého požadavku se uloží model, tokeny a částka.
[Vybrat předplatné](https://ailoot.ai/docs/cs/billing/subscriptions/) · [Zobrazit ceny modelů](https://ailoot.ai/models/cs/)
## Připojte API k produktu, který prodáváte.
SaaS, aplikace a boti podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o licenci přeprodejce.
Komerční aplikace
Začleňte generování textu, obrázků, videa a zvuku do placených funkcí své služby.
Licence pro přeprodejce
Pošlete popis projektu a způsob poskytování přístupu. Vyžádejte písemné podmínky použití a přeprodeje.
Dokumenty na webu
Nabídka, licenční smlouva a zásady zpracování dat jsou dostupné před připojením.
[Požádat o licenci přeprodejce](mailto:support@ailoot.ai) · [Nabídka a licenční smlouva](https://ailoot.ai/legal/offer?lang=cs)
## Ailoot · Společnost a její portfolio projektů
Ailoot staví na dlouhodobých provozních zkušenostech, široké klientské základně, stabilních službách a průběžném sledování KPI.
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
Ailoot využívá tyto provozní zkušenosti k poskytování přístupu přes API k funkcím AI v produktech zákazníků, agentech, aplikacích a automatizacích.