Source: https://ailoot.ai/models/sk/wan2-7-image/
Canonical: https://ailoot.ai/models/sk/wan2-7-image/
Language: sk

# wan2.7-image

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

## [wan2.7-image](https://ailoot.ai/models/sk/wan2-7-image/)

Model na generovanie obrázkov z textu pre prípravu variantov návrhov a ilustrácií. Podľa Alibaba je táto verzia zameraná na rýchlejšiu tvorbu obrázkov.

- [**Ailoot · Obrázky** `POST /v1/images/generations` `wan2.7-image`](https://ailoot.ai/models/sk/wan2-7-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.

Wan2.7-Image vytvára obrázky z textového zadania. Aktuálna karta Ailoot obsahuje práve textový vstup a výsledok vo forme obrázka. Podľa Alibaba je táto verzia zameraná na rýchlejšie získavanie variantov. Špecifikácia výrobcu ponúka aj úpravy, kombinovanie referencií a miestne zmeny; vyžadujú samostatnú podporu vstupných obrázkov, ktorú aktuálna metóda karty neobsahuje.

#### Režimy opísané spoločnosťou Alibaba

Pre režim s referenciami Alibaba umožňuje najviac deväť vstupných obrázkov v zadaní. Slúžia ako oporné body pre vzhľad objektu, kompozíciu a detaily. Model môže spojiť viacero materiálov do novej scény alebo zmeniť vstupný obrázok pri zachovaní hlavného predmetu. Pre cielené úpravy sú k dispozícii výslovne označené oblasti: na jednom obrázku možno určiť najviac dve obdĺžnikové oblasti.

Podľa špecifikácie Alibaba bežný režim vytvára jeden až štyri výsledky. Postupná séria umožňuje požiadať o najviac 12 obrázkov spojených príbehom alebo spoločnými vlastnosťami postáv. Pre sériu je to horná hranica: model sám určuje potrebný počet snímok a môže ich vrátiť menej. Zadanie a vstupné materiály pomáhajú zachovať spoločnú dejovú líniu.

Pre bežné generovanie z textu bez referencií a postupnej série je k dispozícii režim uvažovania. V ňom model podrobnejšie analyzuje zložitý opis pred vytvorením obrázka. Pri úpravách podľa obrázkov a v postupnej sérii sa tento režim nepoužíva. Zadaná paleta 3–10 farieb je dostupná mimo postupných sérií.

#### Vstup a výsledok

V režimoch so vstupnými obrázkami výrobca podporuje JPEG, JPG, PNG bez priehľadnosti, BMP a WEBP. Každá strana môže mať od 240 do 8000 pixelov, veľkosť súboru je najviac 20 MB a pomer strán od 1:8 do 8:1.

Textové zadanie podporuje čínštinu a angličtinu a je obmedzené na 5000 znakov; nadbytočná časť sa odstráni. Pri tejto verzii nie je k dispozícii negatívny opis ani dodatočné rozšírenie zadania.

Výstupný formát je PNG a rozlíšenie dosahuje úroveň 2K. Označenie sa týka celkovej plochy pixelov, nie pevnej maximálnej dĺžky strany; tvar možno vyberať v rozsahu od 1:8 do 8:1. Pri úpravách s prednastaveným rozlíšením si výsledok zachováva pomer strán poslednej referencie. Rovnaká počiatočná hodnota generátora náhodnosti pomáha získať podobné varianty, nezaručuje však úplnú zhodu.

**Ailoot · Obrázky** `POST /v1/images/generations` `wan2.7-image`

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

Alibaba /`wan2.7-image`

### Úvod

Model na generovanie obrázkov z textu pre prípravu variantov návrhov a ilustrácií. Podľa Alibaba je táto verzia zameraná na rýchlejšiu tvorbu obrázkov.

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 wan2.7-image | 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`partial_images` | Typ`integer` | PožiadavkaVoliteľné | Hodnoty a limity Závisí od modelu | Predvolené— |
| Pole`images[].image_url` | Typ`string` | PožiadavkaNepodporované | Hodnoty a limity Maximálny počet dekódovaných bajtov: 20 971 520 Typy MIME: image/png, image/jpeg Maximálny počet obrázkov v poli: 9 Podmienky: Jedna skutočná URL na každý objekt images\[\]. Počet prvkov poľa je odlišný od tohto koncového reťazca. Platí, keď: Iba JSON images/edits; JSON images/generations neparsuje referencie images. | Predvolené— |
| Pole`image` | Typ`file` | PožiadavkaVoliteľné | Hodnoty a limity Maximálny počet dekódovaných bajtov: 20 971 520 Typy MIME: image/png, image/jpeg Platí, keď: generovanie cez multipart/form-data | Predvolené— |
| Pole`image[]` | Typ`file[]` | PožiadavkaVoliteľné | Hodnoty a limity Maximálny počet položiek: 9 Maximálny počet dekódovaných bajtov: 20 971 520 Typy MIME: image/png, image/jpeg Platí, keď: generovanie cez multipart/form-data | Predvolené— |

Kombinácie vstupných podkladov

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

**reference\_images\_generation** · 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

Výstup

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

Výstup

0,03 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/)

#### Podrobnosti referenčnej tarify

Referenčné sadzobníky modelu nemenia výber metódy, cenové odhady ani poplatky. Aktívne poplatky používajú sadzby vybranej metódy Ailoot.

wan2.7-image

#### Ceny podľa konfigurácie

| Konfigurácia | Podmienky účtovania | Poplatok |
| --- | --- | --- |
| Konfiguráciawan2.7-image · Predvolená konfigurácia | Podmienky účtovaniaPredvolená konfigurácia | Poplatok Vstup · Vstup **0,00 USD** za volanie Výstup · Výstup **0,06 USD** za volanie |

### 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": "wan2.7-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': 'wan2.7-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": "wan2.7-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** [`wan2.7-image`](https://ailoot.ai/models/sk/#m=wan2.7-image&route=Core&caller=wan2.7-image&fmt=images)

#### Aliasy ciest metód

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

#### Súvisiace ID na volanie

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

FAQ · wan2.7-image

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

`POST /v1/images/generations` · `wan2.7-image`: `text` → `image`

Aké polia používa požiadavka?

`POST /v1/images/generations` · `wan2.7-image`: `model`, `prompt`, `n`, `response_format`, `stream`, `image`, `image[]`

Aké limity platia?

`POST /v1/images/generations` · `wan2.7-image`: `n.minimum`: `1`

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.