Source: https://ailoot.ai/models/cs/openai-gpt-5-image-mini/ Canonical: https://ailoot.ai/models/cs/openai-gpt-5-image-mini/ Language: cs # OpenAI: GPT-5 Image Mini [Markdown](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/index.md) · [JSON](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/facts.json) ## [OpenAI: GPT-5 Image Mini](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/) GPT-5 Image Mini spojuje jazykové schopnosti GPT-5 Mini od OpenAI s GPT Image 1 Mini pro vizuální generování a úpravy vedené referencemi. Přijímá text, obrázky a dokumenty a vrací text a obrázky, což podporuje pracovní postupy potřebující písemnou odpověď i vizuální výstup. - [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/#method-0) - [**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/#method-1) - [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/openai-gpt-5-image-mini/#method-2) 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 Image Mini je kombinovaný jazykový a obrazový profil postavený na GPT-5 Mini a GPT Image 1 Mini od OpenAI. Jazyková složka interpretuje písemné zadání a zdrojové materiály, zatímco obrazová složka vytváří nebo upravuje vizuální obsah. Zveřejněný profil zdůrazňuje dodržování pokynů, vykreslování textu a podrobné úpravy obrázků. Je užitečný pro cílené vizuální zadání, které potřebuje také textovou interpretaci, vysvětlení nebo doprovodný text. #### Propojte písemné zadání a vizuální výsledek Připravte zadání se zamýšleným výstupem, námětem, kompozicí a požadovaným textem. Popište, jak se obrázek použije, například jako koncept produktu, ilustrace doprovázející krátké vysvětlení nebo vizuální návrh stránky. Písemné a vizuální výstupy požadujte výslovně, aby šlo vysvětlení konceptu snadno odlišit od samotného obrázku. Například dodejte popis opakovaně použitelné lahve na vodu a požádejte o jednoduchý koncept produktové scény s krátkým popiskem. Určete viditelný tvar lahve, pozadí, směr světla a přesná slova, která patří do vizuálu. Fakta použitá v popisku uchovávejte odděleně od dekorativních detailů scény. Prověřte vrácený obrázek a písemný text vůči těmto dvěma částem zadání. Dokumentovaný kombinovaný profil přijímá text, obrázky a soubory, například PDF. Dokument může poskytnout požadavky nebo fakta k interpretaci před vytvořením vizuálu. Obrázek může dodat vzhled, rozvržení nebo zdroj pro úpravu. Uveďte roli každého zdroje místo předpokladu, že každá příloha má ovlivnit každou část výsledku. Při více vstupech zachovávejte jasné názvy zdrojů a jejich pořadí. #### Generujte a upravujte s referencemi U nového obrázku určete, co má být viditelné a jak spolu části souvisejí. U úpravy vedené referencemi určete změnu a detaily k zachování. Produktová scéna může požadovat nové prostředí při zachování rozpoznatelného tvaru předmětu a viditelného popisku. Diagram může požadovat opravený vztah a zároveň pojmenovat text a prvky, které mají zůstat. Vlastní zveřejněná karta profilu povoluje nejvýše šestnáct referenčních obrázků pro úpravy. Zvolte reference přispívající k úkolu a vysvětlete jejich účel: produkt, postavu, pozadí nebo vizuální zpracování. Více referencí může obsahovat rozporné osvětlení či kompozici, proto zamýšlený výsledek pojmenujte jasně. V reálně vráceném obrázku prověřte detaily námětu, text a hranice požadované změny. Vykreslování textu je dokumentovanou schopností, ale vizuální návrh stále potřebuje kontrolu slovo po slově. Poskytněte přesné znění, interpunkci a umístění a potom porovnejte důležité popisky a čísla se zadáním v zamýšlené velikosti zobrazení. U opakované série uchovávejte reference a vizuální požadavky s každým výsledkem a dokončené obrázky porovnávejte společně. #### Pracovní kontext a nastavení Kombinovaný profil zveřejňuje kontextové okno o velikosti 400 000 tokenů a nejvýše 128 000 tokenů generované odpovědi. Jde o limity pracovního kontextu a generování, oddělené od pixelových rozměrů obrázku nebo počtu vrácených obrazových výstupů. Uspořádejte dlouhé zdrojové materiály kolem požadované interpretace a ponechte místo pro odpověď. Kompaktní zadání s relevantními referencemi je užitečnější než nesouvisející dokumenty s nevysvětlenou rolí. Zveřejněné požadavky na textový výstup podporují strukturované výsledky podle schématu JSON. Definujte pole a typy, pokud má písemný výsledek zpracovávat aplikace, a ověřte hodnoty vůči dodaným důkazům. Kombinovaný profil nezpřístupňuje volání funkcí aplikace. Použití jazykové složky s generováním obrázků je schopností tohoto pojmenovaného profilu; nepřenáší do tohoto pracovního postupu všechny funkce samostatného rozhraní GPT-5 Mini. Nastavení obrázků mají vycházet z přesného používaného profilu a rozhraní. Při porovnávání úprav uchovávejte vybranou konfiguraci s promptem. Přímá složka GPT Image 1 Mini a kombinovaný chatový profil mají odlišné uspořádání požadavků, proto nastavení velikosti, maskování nebo výstupu specifická pro složku potřebují výslovné mapování, než se považují za nastavení tohoto kombinovaného profilu. #### Uchovejte textové a obrazové výstupy Dokumentované schéma chatového požadavku může zvolit text a image jako výstupní modality. Zpracujte vrácený text a každý skutečný obrazový výstup doprovázející generovanou odpověď. Obrázky uložte ve formátu určeném výsledkem a písemnou odpověď uchovejte s promptem, zdrojovými referencemi a nastaveními. Odpověď obsahující pouze vysvětlující text se liší od dokončeného vizuálního výstupu, proto před použitím v rozvržení ověřte, co výsledek skutečně obsahuje. GPT-5 Image Mini se liší od plného profilu GPT-5 Image, který kombinuje GPT-5 s GPT Image 1. Používejte profil Mini pro ohraničené jazykové a vizuální úlohy s jasným zadáním a kritérii kontroly. Prověřte kompozici, identitu objektu, text obrázku a doprovodný text a potom požadujte konkrétní potřebnou opravu. V dalším zadání uchovejte úspěšné prvky a relevantní reference, aby úprava měla konkrétní cíl. Praktická úloha ### Praktická úloha Technický příklad v angličtině ``` Create a labelled refill-bottle scene Create a product-scene image of a plain cylindrical blue reusable water bottle with a silver screw cap, standing upright on pale stone. Soft daylight enters from the left. Place the exact word REFILL clearly on the bottle, with no other text, logos, accessories or unsupported product claims. Keep the full bottle visible. ``` #### Očekávaný výsledek ``` One image artifact showing the full specified bottle, left-side daylight and the exact single-word label. ``` #### Ověření výsledku ``` Inspect the actual image for bottle shape, cap, complete framing and letter-by-letter spelling of REFILL. ``` **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image-mini` [`openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image-mini&route=Ultra&caller=openai%2Fgpt-5-image-mini&fmt=chat) OpenAI /`openai/gpt-5-image-mini` ### Úvod GPT-5 Image Mini spojuje jazykové schopnosti GPT-5 Mini od OpenAI s GPT Image 1 Mini pro vizuální generování a úpravy vedené referencemi. Přijímá text, obrázky a dokumenty a vrací text a obrázky, což podporuje pracovní postupy potřebující písemnou odpověď i vizuální výstup. 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-image-mini | 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) #### 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.005** / 1K tokenů Výstup · Výstupní tokeny **$0.004** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0005** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů Výstup · Tokeny výstupního obrázku **$0.016** / 1K obrazových tokenů | | KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.005** / 1K tokenů Výstup · Výstupní tokeny **$0.004** / 1K tokenů Vstup · Čtení z mezipaměti **$0.0005** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů | #### 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. OpenAI: GPT-5 Image Mini #### Ceny podle konfigurace | Konfigurace | Podmínky účtování | Poplatek | | --- | --- | --- | | KonfiguraceOpenAI: GPT-5 Image Mini · Výchozí konfigurace | Podmínky účtováníVýchozí konfigurace | Poplatek Vstup · Vstupní tokeny **0,005 US$** / 1K tokenů Výstup · Výstupní tokeny **0,004 US$** / 1K tokenů Výstup · Výstupní obrázek **0,016 US$** / 1K tokenů Výstup · Vyhledávání na webu **0,02 US$** za vyhledání Vstup · Čtení z mezipaměti **0,0005 US$** / 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-image-mini", "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-image-mini',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-image-mini',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 Ultra** [`openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image-mini&route=Ultra&caller=openai%2Fgpt-5-image-mini&fmt=chat) #### Aliasy cest metod `/v1/images` #### Související ID modelů [`openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image-mini&route=Ultra&caller=openai%2Fgpt-5-image-mini&fmt=chat) **Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-5-image-mini` [`openai/gpt-5-image-mini`](https://ailoot.ai/models/cs/#m=openai%2Fgpt-5-image-mini&route=Ultra&caller=openai%2Fgpt-5-image-mini&fmt=images) OpenAI /`openai/gpt-5-image-mini` ### Úvod GPT-5 Image Mini spojuje jazykové schopnosti GPT-5 Mini od OpenAI s GPT Image 1 Mini pro vizuální generování a úpravy vedené referencemi. Přijímá text, obrázky a dokumenty a vrací text a obrázky, což podporuje pracovní postupy potřebující písemnou odpověď i vizuální výstup. Přijímané vstupy Text · Obrázky Výsledky Obrázky ### Dostupné v Ailoot · vstupy a metody **Ailoot Ultra · Obrázky** `POST /v1/images/generations` Vstup `text`, `image` Výstup `image` | Pole | Typ | Požadavek | Hodnoty a limity | Výchozí | | --- | --- | --- | --- | --- | | Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity openai/gpt-5-image-mini | Výchozí— | | Pole`prompt` | Typ`string` | PožadavekPovinné | Hodnoty a limity Minimální délka: 1 | Výchozí— | | Pole`aspect_ratio` | Typ`string` | PožadavekVolitelné | Hodnoty a limity 1:1, 3:2, 2:3, auto | Výchozí— | | Pole`quality` | Typ`string` | PožadavekVolitelné | Hodnoty a limity auto, low, medium, high | Výchozí— | | Pole`background` | Typ`string` | PožadavekVolitelné | Hodnoty a limity auto, transparent, opaque | Výchozí— | | Pole`n` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Maximum: 10 | Výchozí— | | Pole`input_references` | Typ`array` | PožadavekVolitelné | Hodnoty a limity Minimální počet položek: 0 Maximální počet položek: 16 | Výchozí— | | Pole`output_compression` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 0 Maximum: 100 | Výchozí— | | Pole`provider` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— | Parametry a životní cyklus metody | Parametr | Kontrakt | | --- | --- | | Parametr`content_type` | Kontraktapplication/json | | Parametr`required` | Kontraktmodel, prompt | | Parametr`material_types` | Kontrakttext, image | Životní cyklus: `synchronous_result_then_owned_library` `GET /v1/media/tasks/{task_id}` · skutečně vrácené task\_id nebo záznam v knihovně médií `GET /v1/media/assets/{asset_id}/content` `GET /v1/media/assets` `GET /v1/media/assets/{asset_id}` ### Tarify ##### Jak se vypočítá konečný poplatek Zobrazené sazby slouží k odhadu ceny před generováním. Konečný poplatek se vypočítá z nákladů zaznamenaných u původního generování. Naměřená délka výstupu ani odhadovaná množství nejsou konečným účtovaným množstvím. Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody. Rychlý režim Neuvedeno Při výběru rychlého režimu Režim flex Neuvedeno Při výběru režimu flex Maximální intenzita uvažování Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default) #### Odhadované sazby pro srovnání #### 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 | Předpokládané množství | Poplatek | | --- | --- | --- | --- | | KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Předpokládané množství— | Poplatek Vstup · Vstupní tokeny · Odhad pouze pro srovnání **—** / 1K tokenů Výstup · Výstupní tokeny · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Čtení z mezipaměti · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Zápis do mezipaměti · Odhad pouze pro srovnání **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina · Odhad pouze pro srovnání **—** / 1K tokenů | | KonfiguraceOdhadovaná cena generování | Tabulka sazeb— | Předpokládané množstvíodhad pro jedno generování | Poplatek Výstup · Odhadovaná cena generování · Odhad pouze pro srovnání **$0.065536** odhad před generováním Tento odhad není dodatečným poplatkem ani pevnou sazbou za dokončené generování. | 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 · Obrázky curl ```bash set -eu : "${AILOOT_API_KEY:?Set your Ailoot API key}" export AILOOT_API_KEY python3 - <<'PY_REQUEST' import json,os from pathlib import Path p={'model': 'openai/gpt-5-image-mini', 'prompt': 'a red panda astronaut floating in space, studio lighting'} 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/images/generations \ -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, os, subprocess from pathlib import Path from urllib.parse import urlsplit, urljoin def save_images(items): if not items: raise SystemExit("No completed images; retain the full response") for index, item in enumerate(items): encoded=item.get("b64_json") uri=item.get("url", "") if not encoded and uri.startswith("data:image/"): header, separator, encoded=uri.partition(",") if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI") if encoded: raw=base64.b64decode(encoded,validate=True) elif uri: uri=urljoin("https://api.ailoot.ai",uri) parsed=urlsplit(uri) if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password: raise SystemExit("Invalid returned image URL") owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content") args=["curl","--fail-with-body","--silent","--show-error",uri] if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]] temporary=Path(f"image-{index}.bin") subprocess.run(args+["-o",str(temporary)],check=True) raw=temporary.read_bytes() temporary.unlink() else: raise SystemExit("Image has neither bytes nor URL") if not raw: raise SystemExit("Empty image result") ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"