Source: https://ailoot.ai/models/sk/gpt-image-2/
Canonical: https://ailoot.ai/models/sk/gpt-image-2/
Language: sk

# OpenAI: GPT Image 2

[Markdown](https://ailoot.ai/models/sk/gpt-image-2/index.md) · [JSON](https://ailoot.ai/models/sk/gpt-image-2/facts.json)

## [OpenAI: GPT Image 2](https://ailoot.ai/models/sk/gpt-image-2/)

GPT Image 2 vytvára a upravuje obrázky z textu a vizuálnych referencií. Podporuje flexibilné rozmery rámca a automaticky spracúva obrazové vstupy s vysokou vernosťou, pričom hotový podklad má samostatné ovládanie kvality, formátu a pozadia.

- [**Ailoot · Obrázky** `POST /v1/images/generations` `gpt-image-2`](https://ailoot.ai/models/sk/gpt-image-2/#method-0)
- [**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `gpt-image-2`](https://ailoot.ai/models/sk/gpt-image-2/#method-1)
- [**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-image-2`](https://ailoot.ai/models/sk/gpt-image-2/#method-2)

O modeli

Tento opis pokrýva možnosti modelu. Dostupné vstupy, výstupy a voľby v Ailoot sú uvedené nižšie pre vybranú metódu.

GPT Image 2 je model spoločnosti OpenAI na tvorbu a úpravu obrázkov z textových a vizuálnych vstupov. Vytvára nový obrázok z písomného zadania a môže použiť zdrojové obrázky na úpravy alebo prácu vedenú referenciami. Praktické úlohy zahŕňajú ilustrácie, produktové koncepty, vizuálne kompozície a zmeny existujúceho podkladu. Je to samostatná edícia odlišná od modelov GPT Image 2.5 Sunburst a Flare s vlastným rozsahom kvality a správaním vernosti vstupu.

Pri generovaní opíšte objekt, scénu, kompozíciu, svetlo a zamýšľaný štýl. Pri úprave pomenujte, čo sa má zmeniť a čo má zachovať svoj vzhľad. Produktové zadanie môže žiadať keramickú lampu na svetlom povrchu s vycentrovanou siluetou a miestom na popis; nadväzujúca úprava môže zmeniť pozadie a zachovať tvar lampy aj uhol pohľadu. Dokumentované priame postupy generovania a úpravy prijímajú zadania s najviac 32 000 znakmi a môžu vrátiť jeden až desať obrázkov.

Úprava podľa referencií prijíma až šestnásť vstupných obrázkov. Určte účel každej referencie, aby sa nezamieňal objekt, pozadie a vizuálne spracovanie. GPT Image 2 automaticky spracúva každý obrazový vstup s vysokou vernosťou; input\_fidelity treba vynechať, pretože sa v tejto edícii nedá nastaviť. Tým sa líši od voľby high alebo low v GPT Image 1 a od režimu vernosti vstupu obmedzeného na low v GPT Image 1 Mini. Spracovanie vstupu s vysokou vernosťou podporuje zdrojové detaily bez záruky, že sa každý detail reprodukuje bez zmeny.

Maska môže označiť oblasť na úpravu. Zdrojový obrázok a maska musia mať rovnaký formát a rozmery a podľa požiadaviek prípravy v príručke menej než 50 MB; maska potrebuje aj alfa kanál. Ak dodáte viac vstupných obrázkov, maskovanie sa vzťahuje na prvý. Model zaobchádza s maskou ako s usmernením založeným na zadaní, nie ako s prísnou geometrickou hranicou. Opíšte miestnu zmenu a požiadavky na zachovanie prvkov a potom skontrolujte okolie, či v ňom nevznikli nechcené rozdiely.

GPT Image 2 podporuje kvalitu low, medium, high a auto, pričom auto je predvolené. Nastavenia xhigh a max z rodiny 2.5 nepatria do rozsahu kvality tejto edície. Veľkosť môže byť štvorcová, na šírku, na výšku, automatická alebo platná vlastná šírka a výška. Príklady výrobcu zahŕňajú 1 024 × 1 024, 1 536 × 1 024, 1 024 × 1 536, 2 048 × 2 048, 2 048 × 1 152, 3 840 × 2 160 a 2 160 × 3 840 pixelov. Orientáciu a úroveň detailov vyberajte pre skutočné rozloženie a nepovažujte kvalitu a rozmery za rovnaký ovládací prvok.

Vlastné rozmery musia byť násobkami šestnástich pixelov s maximálnou hranou 3 840 pixelov, pomerom dlhšej ku kratšej hrane najviac 3:1 a plochou od 655 360 do 8 294 400 pixelov. Tieto podmienky platia súčasne. Rozlíšenia nad 2 560 × 1 440 sú označené ako experimentálne. Rámec, ktorý spĺňa jedno pravidlo, môže porušiť iné, preto vyberte podporovanú dvojicu rozmerov a v zadaní opíšte prvky citlivé na orez.

Výstup je predvolene PNG; dostupné sú aj JPEG alebo WebP. Pre JPEG a WebP je podporovaná kompresia od 0 do 100. Pozadie môže byť nepriehľadné alebo automatické; konkrétna aktuálna referenčná dokumentácia opisuje priehľadnosť v GPT Image 2 ako schopnosť v režime preview. Pri požiadavke na priehľadnosť použite PNG alebo WebP, aby bolo možné zachovať alfa kanál. Dokumentovaný postup streamovania povoľuje až tri čiastočné obrázky pred hotovým obrázkom; uložte konečný podklad, nie priebežný náhľad. Rozhranie výrobcu podporuje aj dávkové spracovanie.

V skutočnom výsledku vyhodnoťte jasnosť textu, polohu predmetov a zachovanie zdrojových detailov. GPT Image môže mať ťažkosti s presnými nápismi, kompozíciami citlivými na rozloženie a opakujúcou sa vizuálnou identitou naprieč samostatnými generovaniami. Pri sérii úprav použite vybraný výsledok ako ďalší zdroj a dajte konkrétnu zmenu viazanú na viditeľný problém. Užitočným výstupom GPT Image 2 je obrázok prepojený s jasným zadaním na generovanie alebo úpravu, ktorého vstupy s vysokou vernosťou, rozmery a kvalita sú zvolené pre danú úlohu.

**Ailoot · Obrázky** `POST /v1/images/generations` `gpt-image-2`

[`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images)

OpenAI /`gpt-image-2`

### Úvod

GPT Image 2 vytvára a upravuje obrázky z textu a vizuálnych referencií. Podporuje flexibilné rozmery rámca a automaticky spracúva obrazové vstupy s vysokou vernosťou, pričom hotový podklad má samostatné ovládanie kvality, formátu a pozadia.

Povolené vstupy

Text

Výsledky

Obrázky

### Dostupné v Ailoot · vstupy a metódy

**Ailoot · Obrázky** `POST /v1/images/generations`

Vstup

`text`

Výstup

`image`

Výstupný formát

Súbor obrázka

| Pole | Typ | Požiadavka | Hodnoty a limity | Predvolené |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity gpt-image-2 | Predvolené— |
| Pole`prompt` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity Minimálna dĺžka: 1 | Predvolené— |
| Pole`n` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 | Predvolené1 |
| Pole`response_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity url, b64\_json | Predvolené— |
| Pole`stream` | Typ`boolean` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolenéfalse |
| Pole`size` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`quality` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`background` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`output_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`output_compression` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`moderation` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`input_fidelity` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`style` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`partial_images` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |

Kombinácie vstupných podkladov

**Z textu na obrázok** · Povinné: prompt

Parametre a životný cyklus metódy

| Parameter | Špecifikácia |
| --- | --- |
| Parameter`material_types` | Špecifikáciatext |
| Parameter`required` | Špecifikáciamodel, prompt |
| Parameter`optional_controls` | Špecifikácianull |
| Parameter`content_type` | Špecifikáciaapplication/json |

Životný cyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · skutočne vrátené task\_id alebo záznam v knižnici médií

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

Štruktúry metód a ID sú presné; možnosti dodávateľa sa posudzujú oddelene od prijatia požiadavky.

### Cenník

#### Sadzby metód Ailoot

Textový vstup

0,0025 USD */ 1K*

Vstup, obrázok

0,004 USD */ 1K tokens*

Výstup, obrázok

0,015 USD */ 1K tokens*

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. [Ako funguje rezervácia a vyúčtovanie →](https://ailoot.ai/docs/sk/billing/reserve/)

### Príklady požiadaviek

#### Ailoot · Obrázky

curlPython SDKNode.js SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
export AILOOT_API_KEY
: "${AILOOT_PROMPT_FILE:?Set your actual UTF-8 image brief}"
export AILOOT_PROMPT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gpt-image-2", "prompt": ""}')
f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 brief")
p['prompt']=f.read_text(encoding="utf-8")
if not p['prompt'].strip():raise SystemExit("Brief must contain 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/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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

```python
from openai import OpenAI
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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")

f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Set your actual UTF-8 image brief file")
request={'model': 'gpt-image-2', 'prompt': ''}
request["prompt"]=f.read_text(encoding="utf-8")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.images.generate(**request)
Path("sdk-result.txt").write_text(str(result),encoding="utf-8")
save_images([{"b64_json":getattr(item,"b64_json",None),"url":getattr(item,"url",None)} for item in result.data])
```

```js
import OpenAI from "openai";
import { readFileSync, writeFileSync } from "node:fs";
const key=process.env.AILOOT_API_KEY;
if(!key) throw new Error("Set your actual Ailoot API key");
const client=new OpenAI({baseURL:"https://api.ailoot.ai/v1",apiKey:key,maxRetries:0});
const request={"model": "gpt-image-2", "prompt": ""};
if(!process.env.AILOOT_PROMPT_FILE)throw new Error("Set your actual UTF-8 image brief file");
request.prompt=readFileSync(process.env.AILOOT_PROMPT_FILE,"utf8");
const result=await client.images.generate(request);
writeFileSync("sdk-result.json",JSON.stringify(result,null,2));
if(!result.data?.length) throw new Error("No completed images");
for(let index=0;index<result.data.length;index++) {
  const item=result.data[index];let encoded=item.b64_json,uri=item.url||"",raw;
  if(!encoded && uri.startsWith("data:image/")) {
    const comma=uri.indexOf(",");if(comma<0 || !uri.slice(0,comma).includes(";base64")) throw new Error("Unsupported image data URI");
    encoded=uri.slice(comma+1);
  }
  if(encoded) {
    if(encoded.length%4!==0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw new Error("Invalid Base64");
    raw=Buffer.from(encoded,"base64");
  } else if(uri) {
    const u=new URL(uri,"https://api.ailoot.ai");
    if(u.protocol!=="https:" || u.username || u.password) throw new Error("Invalid returned URL");
    const owned=u.origin==="https://api.ailoot.ai" && u.pathname.startsWith("/v1/media/assets/") && u.pathname.endsWith("/content");
    const response=await fetch(u,{headers:owned?{Authorization:"Bearer "+key}:{},redirect:"manual"});
    if(!response.ok) throw new Error("Image content download failed: "+response.status);
    raw=Buffer.from(await response.arrayBuffer());
  } else throw new Error("Image has neither bytes nor URL");
  if(!raw.length) throw new Error("Empty image result");
  const ext=raw.subarray(0,4).equals(Buffer.from([137,80,78,71]))?"png":raw[0]===255&&raw[1]===216?"jpg":raw.toString("ascii",0,4)==="RIFF"&&raw.toString("ascii",8,12)==="WEBP"?"webp":raw.toString("utf8").trimStart().startsWith("<svg")||raw.toString("utf8").trimStart().startsWith("<?xml")?"svg":"bin";
  writeFileSync(`image-${index}.${ext}`,raw);
}
console.log("Every returned image saved; sdk-result.json retains complete metadata");
```

### Prijať a uložiť výsledky

#### Ailoot · Obrázky

Stiahnite každý vrátený obrázok alebo uložte jeho obsah Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

##### Uchovať všetky dokončené výsledky

Uložte každý dokončený obrázok; stiahnite obsah z každej vrátenej URL alebo dekódujte jeho obsah Base64.

Uložte každú dátovú položku. Dekódujte každé b64\_json alebo stiahnite obsah z každej vrátenej podpísanej URL. Príponu názvu súboru vyberte podľa skutočného typu MIME/bajtov.

##### Ak treba overiť pôvodnú odpoveď

Ak je potrebné skontrolovať výsledok generovania alebo úpravy obrázka, uchovajte pôvodné operation\_id/X-Client-Request-ID a vrátené informácie o výsledku. Existujúce vlastné výsledky obnovte cez knižnicu médií pomocou skutočných hodnôt task\_id alebo asset\_id. Požiadavku na generovanie/úpravu znova neodosielajte ani nevytvárajte URL na priebežné zisťovanie stavu z operation\_id.

Polia odpovede

| Pole | Typ |
| --- | --- |
| Pole`created` | Typinteger |
| Pole`data[].url` | Typstring |
| Pole`data[].b64_json` | Typbase64 string |
| Pole`usage` | Typobject |

Chyby a ďalšie kroky

| Odpoveď | Podmienka | Ďalší krok |
| --- | --- | --- |
| Odpoveď400 · `invalid_request_error` | PodmienkaNeplatné povinné polia, reprezentácia materiálu alebo hodnota parametra | Ďalší krokPred novou požiadavkou na vytvorenie opravte uvedené polia. |
| Odpoveď`server_error` | PodmienkaVrátená odpoveď uvádza, že operáciu alebo výsledok je potrebné skontrolovať | Ďalší krokUchovajte pôvodné vrátené ID operácie/úlohy, hlavičky požiadavky a odpoveď; naďalej čítajte údaje o tejto pôvodnej operácii podporovaným spôsobom. Požiadavku na vytvorenie znova neodosielajte. |

### Aliasy

#### Aliasy modelov

<strong>Ailoot</strong> [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images)
**Ailoot Ultra** [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images), [`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images)

#### Aliasy ciest metód

`/v1/images`

#### Súvisiace ID na volanie

[`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images)

**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `gpt-image-2`

[`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images)

OpenAI /`gpt-image-2`

ID modelu

- `gpt-image-2`
- `openai/gpt-image-2`

### Úvod

GPT Image 2 vytvára a upravuje obrázky z textu a vizuálnych referencií. Podporuje flexibilné rozmery rámca a automaticky spracúva obrazové vstupy s vysokou vernosťou, pričom hotový podklad má samostatné ovládanie kvality, formátu a pozadia.

Povolené vstupy

Text

Výsledky

Obrázky

### Dostupné v Ailoot · vstupy a metódy

**Ailoot Ultra · Obrázky** `POST /v1/images/generations`

Vstup

`text`

Výstup

`image`

| Pole | Typ | Požiadavka | Hodnoty a limity | Predvolené |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity gpt-image-2 | Predvolené— |
| Pole`prompt` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity Maximálna dĺžka: 32 000 | Predvolené— |
| Pole`size` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity Podmienky: Použite auto alebo WIDTHxHEIGHT, pričom oba rozmery musia byť deliteľné 16. Najdlhšia strana má najviac 3,840 pixelov a celková veľkosť najviac 8,300,000 pixelov. | Predvolenéauto |
| Pole`background` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity transparent, opaque, auto | Predvolenéauto |
| Pole`moderation` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity low, auto Podmienky: Na štandardnú moderáciu obsahu použite auto. | Predvolené— |
| Pole`n` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Maximum: 10 | Predvolené1 |
| Pole`quality` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity auto, high, medium, low | Predvolenéauto |
| Pole`output_compression` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 0 Maximum: 100 Podmienky: Platí pre výstup JPEG a WebP; odošlite zdokumentovanú celočíselnú hodnotu. | Predvolené100 |
| Pole`output_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity webp, png, jpeg | Predvolenépng |
| Pole`stream` | Typ`boolean` | PožiadavkaVoliteľné | Hodnoty a limity false Podmienky: Táto trasa vracia jednu úplnú odpoveď JSON. | Predvolenéfalse |

Parametre a životný cyklus metódy

| Parameter | Špecifikácia |
| --- | --- |
| Parameter`content_type` | Špecifikáciaapplication/json |
| Parameter`required` | Špecifikáciaprompt, model |
| Parameter`material_types` | Špecifikáciatext |
| Parameter`optional` | Špecifikáciasize, background, moderation, n, quality, output\_compression, output\_format, stream |
| Parameter`conditions` | ŠpecifikáciaPriehľadné pozadie vyžaduje PNG alebo WebP., Kompresia výstupu platí pre JPEG alebo WebP., Vybraná metóda generuje z textu. Úpravy a streamovanie opísané pre výrobcu sú samostatné funkcie. |

Životný cyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · skutočne vrátené task\_id alebo záznam v knižnici médií

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

### Cenník

##### Ako sa vypočíta konečný poplatok

Zobrazené sadzby slúžia na odhad nákladov pred generovaním. Konečný poplatok sa vypočíta z nákladov zaznamenaných pri pôvodnom generovaní. Namerané trvanie výstupu a predpokladané množstvá nepredstavujú konečné účtované množstvo.

Tarifné údaje nepridávajú možnosti požiadavky. Podporované parametre sú uvedené pri vybranej metóde.

Rýchly režim

Neuvedené Keď je zvolený rýchly režim

Režim Flex

Neuvedené Keď je zvolený režim flex

Maximálna úroveň uvažovania

Neuvedené Keď sa pri maximálnej úrovni uvažovania používa predvolená úprava (default)

#### Odhadované sadzby na porovnanie

#### Ceny podľa konfigurácie

Každý poplatok priraďte k zobrazeným podmienkam. Pre každú skupinu alternatívnych konfigurácií použite jednu sadzbu.

| Konfigurácia | Sadzobník | Odhadované množstvo | Poplatok |
| --- | --- | --- | --- |
| KonfiguráciaZákladné sadzby za tokeny | SadzobníkZákladná sadzba | Odhadované množstvo— | Poplatok Vstup · Vstupné tokeny · Odhad iba na porovnanie **—** / 1K tokenov Výstup · Výstupné tokeny · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Čítanie cache · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Zápis do cache · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Zápis do cache, 1 hod · Odhad iba na porovnanie **—** / 1K tokenov |
| KonfiguráciaOdhadované náklady na generovanie | Sadzobník— | Odhadované množstvoodhad pre jedno generovanie | Poplatok Výstup · Odhadované náklady na generovanie · Odhad iba na porovnanie **$0.24576** odhad pred generovaním Tento odhad nepredstavuje dodatočný poplatok ani pevnú sadzbu za dokončené generovanie. |

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. [Ako funguje rezervácia a vyúčtovanie →](https://ailoot.ai/docs/sk/billing/reserve/)

### Príklady požiadaviek

#### 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={'prompt': 'A cute baby sea otter', 'model': 'gpt-image-2', 'size': '1024x1024', 'n': 1, 'background': 'auto', 'moderation': 'auto', 'output_format': 'png'}

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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

### Prijať a uložiť výsledky

#### Ailoot Ultra · Obrázky

Stiahnite každý vrátený obrázok alebo uložte jeho obsah Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

Čítanie ďalšieho obsahu

Čítať existujúce podklady, ktoré vám patria

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/media/assets \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o owned-assets.json
# Preserve every returned asset and follow its exact signed content URL. Do not construct a signed token.
```

##### Uchovať všetky dokončené výsledky

Uložte každý dokončený obrázok; stiahnite obsah z každej vrátenej URL alebo dekódujte jeho obsah Base64.

Uchovajte úplnú odpoveď a hlavičky, všetky skutočné výstupy, pôvodné vrátené identifikátory a všetky polia s údajmi o spotrebe. Obnovte pôvodnú operáciu bez opätovného odoslania požiadavky na vytvorenie.

##### Ak treba overiť pôvodnú odpoveď

Uchovajte vrátené X-Client-Request-ID na zosúladenie záznamov. Čítajte iba skutočne vrátené hodnoty task\_id/asset\_id alebo vlastnú knižnicu médií; nikdy nevytvárajte URL úlohy z ID operácie a nikdy znova neodosielajte požiadavku na vytvorenie.

Polia odpovede

| Pole | Typ |
| --- | --- |
| Pole`created` | Typ |
| Pole`data[].url` | Typ |
| Pole`data[].b64_json` | Typ |
| Pole`usage` | Typ |

### Aliasy

#### Aliasy modelov

<strong>Ailoot</strong> [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images)
**Ailoot Ultra** [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images), [`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images)

#### Aliasy ciest metód

`/v1/images`

#### Súvisiace ID na volanie

[`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images)

**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `openai/gpt-image-2`

[`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images)

OpenAI /`openai/gpt-image-2`

ID modelu

- `gpt-image-2`
- `openai/gpt-image-2`

### Úvod

GPT Image 2 vytvára a upravuje obrázky z textu a vizuálnych referencií. Podporuje flexibilné rozmery rámca a automaticky spracúva obrazové vstupy s vysokou vernosťou, pričom hotový podklad má samostatné ovládanie kvality, formátu a pozadia.

Povolené vstupy

Text · Obrázky

Výsledky

Obrázky

### Dostupné v Ailoot · vstupy a metódy

**Ailoot Ultra · Obrázky** `POST /v1/images/generations`

Vstup

`text`, `image`

Výstup

`image`

| Pole | Typ | Požiadavka | Hodnoty a limity | Predvolené |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity openai/gpt-image-2 | Predvolené— |
| Pole`prompt` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity Minimálna dĺžka: 1 | Predvolené— |
| Pole`aspect_ratio` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity 1:1, 3:2, 2:3, 4:3, 3:4, 16:9, 9:16, 21:9, auto | Predvolené— |
| Pole`quality` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity auto, low, medium, high | Predvolené— |
| Pole`background` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity auto, opaque | Predvolené— |
| Pole`n` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Maximum: 10 | Predvolené— |
| Pole`input_references` | Typ`array` | PožiadavkaVoliteľné | Hodnoty a limity Minimálny počet položiek: 0 Maximálny počet položiek: 16 | Predvolené— |
| Pole`output_compression` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 0 Maximum: 100 | Predvolené— |
| Pole`provider` | Typ`object` | PožiadavkaVoliteľné | Hodnoty a limity | Predvolené— |

Parametre a životný cyklus metódy

| Parameter | Špecifikácia |
| --- | --- |
| Parameter`content_type` | Špecifikáciaapplication/json |
| Parameter`required` | Špecifikáciamodel, prompt |
| Parameter`material_types` | Špecifikáciatext, image |

Životný cyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · skutočne vrátené task\_id alebo záznam v knižnici médií

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

### Cenník

##### Ako sa vypočíta konečný poplatok

Zobrazené sadzby slúžia na odhad nákladov pred generovaním. Konečný poplatok sa vypočíta z nákladov zaznamenaných pri pôvodnom generovaní. Namerané trvanie výstupu a predpokladané množstvá nepredstavujú konečné účtované množstvo.

Tarifné údaje nepridávajú možnosti požiadavky. Podporované parametre sú uvedené pri vybranej metóde.

Rýchly režim

Neuvedené Keď je zvolený rýchly režim

Režim Flex

Neuvedené Keď je zvolený režim flex

Maximálna úroveň uvažovania

Neuvedené Keď sa pri maximálnej úrovni uvažovania používa predvolená úprava (default)

#### Odhadované sadzby na porovnanie

#### Ceny podľa konfigurácie

Každý poplatok priraďte k zobrazeným podmienkam. Pre každú skupinu alternatívnych konfigurácií použite jednu sadzbu.

| Konfigurácia | Sadzobník | Odhadované množstvo | Poplatok |
| --- | --- | --- | --- |
| KonfiguráciaZákladné sadzby za tokeny | SadzobníkZákladná sadzba | Odhadované množstvo— | Poplatok Vstup · Vstupné tokeny · Odhad iba na porovnanie **—** / 1K tokenov Výstup · Výstupné tokeny · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Čítanie cache · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Zápis do cache · Odhad iba na porovnanie **—** / 1K tokenov Vstup · Zápis do cache, 1 hod · Odhad iba na porovnanie **—** / 1K tokenov |
| KonfiguráciaOdhadované náklady na generovanie | Sadzobník— | Odhadované množstvoodhad pre jedno generovanie | Poplatok Výstup · Odhadované náklady na generovanie · Odhad iba na porovnanie **$0.24576** odhad pred generovaním Tento odhad nepredstavuje dodatočný poplatok ani pevnú sadzbu za dokončené generovanie. |

Ailoot pred požiadavkou rezervuje odhadovanú sumu. Po získaní výsledku vyúčtuje konečný poplatok podľa nameraného využitia. Pri streamovaní sa vyúčtovanie riadi konečným záznamom využitia. [Ako funguje rezervácia a vyúčtovanie →](https://ailoot.ai/docs/sk/billing/reserve/)

### Príklady požiadaviek

#### 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-image-2', '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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

### Prijať a uložiť výsledky

#### Ailoot Ultra · Obrázky

Stiahnite každý vrátený obrázok alebo uložte jeho obsah Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

Čítanie ďalšieho obsahu

Čítať existujúce podklady, ktoré vám patria

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/media/assets \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o owned-assets.json
# Preserve every returned asset and follow its exact signed content URL. Do not construct a signed token.
```

##### Uchovať všetky dokončené výsledky

Uložte každý dokončený obrázok; stiahnite obsah z každej vrátenej URL alebo dekódujte jeho obsah Base64.

Uchovajte úplnú odpoveď a hlavičky, všetky skutočné výstupy, pôvodné vrátené identifikátory a všetky polia s údajmi o spotrebe. Obnovte pôvodnú operáciu bez opätovného odoslania požiadavky na vytvorenie.

##### Ak treba overiť pôvodnú odpoveď

Uchovajte vrátené X-Client-Request-ID na zosúladenie záznamov. Čítajte iba skutočne vrátené hodnoty task\_id/asset\_id alebo vlastnú knižnicu médií; nikdy nevytvárajte URL úlohy z ID operácie a nikdy znova neodosielajte požiadavku na vytvorenie.

Polia odpovede

| Pole | Typ |
| --- | --- |
| Pole`created` | Typ |
| Pole`data[].url` | Typ |
| Pole`data[].b64_json` | Typ |
| Pole`usage` | Typ |

### Aliasy

#### Aliasy modelov

<strong>Ailoot</strong> [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images)
**Ailoot Ultra** [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images), [`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images)

#### Aliasy ciest metód

`/v1/images`

#### Súvisiace ID na volanie

[`openai/gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=openai%2Fgpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Core&caller=gpt-image-2&fmt=images), [`gpt-image-2`](https://ailoot.ai/models/sk/#m=openai%2Fgpt-image-2&route=Ultra&caller=gpt-image-2&fmt=images)

FAQ · OpenAI: GPT Image 2

Aké vstupy a výsledky sú dostupné?

`POST /v1/images/generations` · `gpt-image-2`: `text` → `image` `POST /v1/images/generations` · `gpt-image-2`: `text` → `image` `POST /v1/images/generations` · `openai/gpt-image-2`: `text`, `image` → `image`

Aké polia používa požiadavka?

`POST /v1/images/generations` · `gpt-image-2`: `model`, `prompt`, `n`, `response_format`, `stream` `POST /v1/images/generations` · `gpt-image-2`: `model`, `prompt`, `size`, `background`, `moderation`, `n`, `quality`, `output_compression`, `output_format`, `stream` `POST /v1/images/generations` · `openai/gpt-image-2`: `model`, `prompt`, `aspect_ratio`, `quality`, `background`, `n`, `input_references`, `output_compression`, `provider`

Aké limity platia?

`POST /v1/images/generations` · `gpt-image-2`: `n.minimum`: `1` `POST /v1/images/generations` · `gpt-image-2`: `prompt.maximum_length`: `32000`; `n.minimum`: `1`; `n.maximum`: `10`; `output_compression.minimum`: `0`; `output_compression.maximum`: `100` `POST /v1/images/generations` · `openai/gpt-image-2`: `n.minimum`: `1`; `n.maximum`: `10`; `output_compression.minimum`: `0`; `output_compression.maximum`: `100`

Pripojte Ailoot k Claude Code, OpenCode, Hermes alebo vlastnej aplikácii.

## Spoločnosť a jej portfólio projektov

Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.

## Nakupujte tokeny so zľavou.

Zľava predplatného na pravidelnú prácu. Promo kódy až 50% na nákup tokenov.

Predplatné

Na pravidelné požiadavky vyberte tarifu so zľavou.

Promo kód až 50%

Pri nákupe zadajte kód. Cena sa prepočíta podľa prebiehajúcej akcie.

Výdavky v histórii

Pri každej požiadavke sa uloží model, tokeny a suma.

[Vybrať predplatné](https://ailoot.ai/docs/sk/billing/subscriptions/) · [Zobraziť ceny modelov](https://ailoot.ai/models/sk/)

## Pripojte API k produktu, ktorý predávate.

SaaS, aplikácie a boti podľa ponuky a licenčnej zmluvy Ailoot. Na ďalší predaj požiadajte o licenciu predajcu.

Komerčná aplikácia

Začleňte generovanie textu, obrázkov, videa a zvuku do platených funkcií svojej služby.

Licencia pre predajcu

Pošlite popis projektu a spôsob poskytovania prístupu. Vyžiadajte písomné podmienky použitia a ďalšieho predaja.

Dokumenty na webe

Ponuka, licenčná zmluva a zásady spracovania dát sú dostupné pred pripojením.

[Požiadať o licenciu predajcu](mailto:support@ailoot.ai) · [Ponuka a licenčná zmluva](https://ailoot.ai/legal/offer?lang=sk)

## Ailoot · Spoločnosť a jej portfólio projektov





Ailoot stavia na dlhodobých prevádzkových skúsenostiach, širokej klientskej základni, stabilných službách a priebežnom sledovaní KPI.





Spoločnosť a jej portfólio projektov: milióny zákazníkov; mesačné tržby v miliardách.





Ailoot využíva tieto prevádzkové skúsenosti na poskytovanie prístupu cez API k funkciám AI v produktoch zákazníkov, agentoch, aplikáciách a automatizáciách.