Source: https://ailoot.ai/models/sk/grok-imagine-image/
Canonical: https://ailoot.ai/models/sk/grok-imagine-image/
Language: sk

# grok-imagine-image

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

## [grok-imagine-image](https://ailoot.ai/models/sk/grok-imagine-image/)

Grok Imagine Image vytvára obrázky podľa textového opisu s výberom pomeru strán a rozlíšenia 1K alebo 2K. Je vhodný na štvorcové, zvislé a širokouhlé vizuálne výstupy.

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

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.

Grok Imagine Image je model spoločnosti xAI na vizuálne generovanie. Premieňa textový opis scény na obrázok. Samotný model má aj vizuálny vstup na prácu so zdrojovým obrázkom; vo zverejnenej metóde generovania Ailoot slúži ako vstup textová požiadavka.

#### Varianty jednej predstavy

Jedna požiadavka môže prostredníctvom parametra `n` určiť **1 až 10 obrázkov**. Ak počet nie je nastavený, vytvorí sa jeden obrázok. To je praktické, keď je potrebných viacero variantov jedného opisu; rôzne samostatné scény sa zadávajú osobitnými opismi.

#### Pomer strán a rozlíšenie

Možno vybrať štvorcový obraz `1:1`, vodorovný `16:9`, zvislý `9:16`, formáty `4:3` a `3:4` či fotografické `3:2` a `2:3`. Režim `auto` umožňuje modelu vybrať proporcie podľa opisu a používa sa predvolene.

Na generovanie sú k dispozícii **1K a 2K**; bez výslovného výberu sa používa 1K. Rozlíšenie a pomer strán sa nastavujú oddelene: prvé určuje veľkosť obrázka, druhý tvar obrazu.

#### Práca s vizuálnymi podkladmi

Vo vizuálnom režime xAI sa zdrojový obrázok dopĺňa textovým pokynom: ten určuje zmenu obsahu alebo vzhľadu scény. Výsledok jednej úpravy možno použiť pri ďalšej a postupne spresňovať detaily. Tento režim samotného modelu sa líši od zverejneného generovania z textu.

Model vracia obrázok; výsledok možno odovzdať ako súbor dostupný cez odkaz alebo ako údaje obrázka v base64. Možnosť výberu `quality` s hodnotami `low`, `medium` a `auto` patrí k Image 2.0 a neprenáša sa na Grok Imagine Image.

**Ailoot · Obrázky** `POST /v1/images/generations` `grok-imagine-image`

[`grok-imagine-image`](https://ailoot.ai/models/sk/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

xAI /`grok-imagine-image`

### Úvod

Grok Imagine Image vytvára obrázky podľa textového opisu s výberom pomeru strán a rozlíšenia 1K alebo 2K. Je vhodný na štvorcové, zvislé a širokouhlé vizuálne výstupy.

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 grok-imagine-image | Predvolené— |
| Pole`prompt` | Typ`string` | PožiadavkaPovinné | Hodnoty a limity | Predvolené— |
| Pole`n` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Minimum: 1 Maximum: 10 | Predvolené1 |
| Pole`response_format` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity url, b64\_json | Predvolenéurl |
| Pole`resolution` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity 1k, 2k | Predvolené1k |
| Pole`aspect_ratio` | Typ`string` | PožiadavkaVoliteľné | Hodnoty a limity auto, 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 2:1, 1:2, 19.5:9, 9:19.5, 20:9, 9:20, 21:9, 5:2 | Predvolenéauto |
| Pole`quality` | Typ`string` | PožiadavkaNepodporované | Hodnoty a limity | 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

Vstup

0,002 USD *za vstupný obrázok*

Výstup

0,02 USD *za obrázok 1K*

Výstup

0,02 USD *za obrázok 2K*

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": "grok-imagine-image", "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': 'grok-imagine-image', '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": "grok-imagine-image", "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

**Ailoot** [`grok-imagine-image`](https://ailoot.ai/models/sk/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

#### Aliasy ciest metód

Použite cesty metód uvedené vyššie.

#### Súvisiace ID na volanie

[`grok-imagine-image`](https://ailoot.ai/models/sk/#m=grok-imagine-image&route=Core&caller=grok-imagine-image&fmt=images)

FAQ · grok-imagine-image

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

`POST /v1/images/generations` · `grok-imagine-image`: `text` → `image`

Aké polia používa požiadavka?

`POST /v1/images/generations` · `grok-imagine-image`: `model`, `prompt`, `n`, `response_format`, `resolution`, `aspect_ratio`

Aké limity platia?

`POST /v1/images/generations` · `grok-imagine-image`: `n.minimum`: `1`; `n.maximum`: `10`

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.