Source: https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/
Canonical: https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/
Language: cs

# Recraft: Recraft V4.1 Flash

[Markdown](https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/index.md) · [JSON](https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/facts.json)

## [Recraft: Recraft V4.1 Flash](https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/)

Recraft V4.1 Flash generuje rastrové obrázky 1K z textu pro rychlé vizuální iterace. Podporuje fotografii, portréty, složité scény a koncepty log s výstupem PNG nebo bezztrátovým WebP a explicitními barevnými preferencemi.

- [**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `recraft/recraft-v4.1-flash`](https://ailoot.ai/models/cs/recraft-recraft-v4-1-flash/#method-0)

O modelu

Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu.

Recraft V4.1 Flash je model Recraft pro generování obrázků z textu určený k rychlým iteracím a velkoobjemové vizuální práci. Výrobce označuje fotografii, portréty, atmosféru, složité scény, kombinovaná média a koncepty log za silná použití. Písemné zadání se stává rastrovým obrázkem, který lze porovnat s dalšími tvůrčími směry před vytvořením finálního materiálu. Flash je konkrétní člen rodiny V4.1 s vlastní velikostí výstupu a podporovaným ovládáním.

Nativní výstup patří do rastrové obrazové třídy Recraft 1K. Plátno zvolte podle zamýšleného umístění: vodorovnou ilustraci pro záhlaví stránky, svislý portrét nebo čtvercový vizuál pro kompaktní kartu. Výstupní formáty jsou bezztrátové WebP a PNG.

Zadání začněte hlavním objektem a vizuálním účelem a poté popište rámování, prostředí, osvětlení a médium. U produktového konceptu je užitečným pokynem: „Kompaktní krémové rádio na ořechovém stole, čelní tříčtvrteční pohled, měkké okenní světlo, klidná redakční fotografie, velkorysý prázdný prostor vlevo.“ U ilustrace určete tvarový jazyk, paletu a vztah prvků. Detaily určující nápad ponechte explicitní místo přidávání nesouvisejících přídavných jmen. Dokumentovaný limit promptu Flash je až 10 000 znaků, takže lze podrobně popsat scénu, pokud to úloha potřebuje.

Ovládání výrobce zahrnuje preferované barvy a požadovanou barvu pozadí. Pro reprodukovatelné výsledky lze dodat seed a rozhraní generování dokumentuje jeden až šest obrázků v požadavku. Tato ovládání podporují užitečnou srovnávací úlohu: ponechte objekt a kompozici stabilní, měňte jeden vizuální směr a výsledné obrázky kontrolujte vůči zamýšlenému rozvržení. Barevné preference popisují požadovaný výsledek; před spojením s existujícím designovým systémem porovnejte důležité barvy značky s hotovým materiálem.

Flash vytváří rastrovou grafiku. Koncept loga může pomoci vybrat siluetu, náladu či uspořádání, zatímco editovatelné cesty patří samostatně pojmenovaným modelům Vector. Flash také nemá variantu Pro. Úplná řada V4.1 nabízí tyto samostatné volby, když je pro výstup zásadní vektorová editace nebo detail vyššího rozlišení. Výrobce popisuje pozdější krok zdokonalení zvoleného návrhu směrem k detailnějšímu obrázku; jde o samostatnou operaci místo jiné nativní velikosti výstupu Flash.

Tato edice nepodporuje vstup image-to-image, vlastní styly, identifikátory stylů, přiřazování stylu ani stylové referenční obrázky. Její dokumentované rozhraní vylučuje také negativní prompty a explicitní ovládání rozvržení textu. Požadovaný vzhled a kompozici vložte do pozitivního zadání. Je-li písmo součástí konceptu, zamýšlené znění uveďte v uvozovkách a vykreslené znaky prohlédněte; je-li zásadní přesná typografie a umístění, použijte samostatnou fázi rozvržení.

Praktickým výsledkem Flash je zvolený vizuální směr s jasným zadáním, vhodným poměrem stran a použitelným rastrovým souborem. Objekt, rámování, pozadí a důležité detaily porovnejte ve velikosti zobrazení obrázku. Úspěšný prompt a vybraný soubor uchovejte společně, aby další tvůrčí krok sledoval zvolený směr. Rychlé iterace pomáhají zkoumat design; nativní vektorový výstup, shoda s referenčním stylem a rozlišení jiné edice V4.1 zůstávají samostatnými volbami modelu.

**Ailoot Ultra · Obrázky** `POST /v1/images/generations` `recraft/recraft-v4.1-flash`

[`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/cs/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

Recraft /`recraft/recraft-v4.1-flash`

### Úvod

Recraft V4.1 Flash generuje rastrové obrázky 1K z textu pro rychlé vizuální iterace. Podporuje fotografii, portréty, složité scény a koncepty log s výstupem PNG nebo bezztrátovým WebP a explicitními barevnými preferencemi.

Přijímané vstupy

Text

Výsledky

Obrázky

### Dostupné v Ailoot · vstupy a metody

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

Vstup

`text`

Výstup

`image`

Výstupní formát

Soubor obrázku

Počet výstupů

1 výstup

| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity recraft/recraft-v4.1-flash | Výchozí— |
| Pole`prompt` | Typ`string` | PožadavekPovinné | Hodnoty a limity Minimální délka: 1 Podmínky: Neprázdné zadání v UTF8. Žádný limit počtu znaků pro všechny modely výrobce se zde nedoplňuje. | Výchozí— |
| Pole`n` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity 1 | Výchozí1 |
| Pole`response_format` | Typ`string` | PožadavekVolitelné | Hodnoty a limity url, b64\_json | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity false | Výchozífalse |

Kombinace vstupních materiálů

**Text na obrázek** · Povinné: prompt

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, prompt |
| Parametr`material_types` | Kontrakttext |
| Parametr`optional` | Kontraktn, response\_format, stream |
| Parametr`n` | Kontrakt1 |
| Parametr`stream` | Kontraktfalse |
| Parametr`response_format` | Kontrakturl, b64\_json |
| Parametr`reference_images` | Kontraktfalse |
| Parametr`edit` | Kontraktfalse |
| Parametr`output_format_optional` | Kontrakt |
| Parametr`resolution_control` | Kontraktnull |
| Parametr`aspect_ratio_control` | Kontraktnull |
| Parametr`other_fields` | Kontraktodmítnuto s výjimkou přesně určeného interního směrování poskytovatele |

Ž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}`

Vygenerujte jeden obrázek z textového zadání.

Uložte každou položku data; url/b64\_json jsou způsoby kódování výsledku.

### 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í | Účtovací jednotka | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Předpokládané množství— | Účtovací jednotka— | 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ů |
| KonfiguraceUltra | Tabulka sazeb— | Předpokládané množství— | Účtovací jednotkaza výstupní obrázek | Poplatek Výstup · výstup obrázku · Odhad pouze pro srovnání **$0.014** za výstupní obrázek |
| KonfiguraceOdhadovaná cena generování | Tabulka sazeb— | Předpokládané množstvíodhad pro jedno generování | Účtovací jednotka— | Poplatek Výstup · Odhadovaná cena generování · Odhad pouze pro srovnání **$0.014** 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/)

#### 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.

Cenové konfigurace obrázků

#### Ceny podle konfigurace

| Konfigurace | Podmínky účtování | Poplatek |
| --- | --- | --- |
| KonfiguraceVýstupní obrázek | Podmínky účtováníNení deklarována žádná cenová varianta. | Poplatek Výstup · Výstupní obrázek **$0.014** za obrázek Ekvivalentní položky popisují tutéž účtovanou částku; nepřidávají druhý poplatek. |

### Příklady požadavků

#### Ailoot Ultra · Obrázky

curlPython SDKNode.js SDK

```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=json.loads('{"model": "recraft/recraft-v4.1-flash", "prompt": "A lighthouse on a cliff, watercolor", "n": 1, "response_format": "b64_json"}')

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")

request={'model': 'recraft/recraft-v4.1-flash', 'prompt': 'A lighthouse on a cliff, watercolor', 'n': 1, 'response_format': 'b64_json'}
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": "recraft/recraft-v4.1-flash", "prompt": "A lighthouse on a cliff, watercolor", "n": 1, "response_format": "b64_json"};
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");
```

### Přijímání a ukládání výsledků

#### Ailoot Ultra · Obrázky

Stáhněte každý vrácený obrázek nebo 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}`

##### Uchovejte všechny dokončené výsledky

Uložte každý dokončený obrázek; stáhněte obsah každé vrácené URL nebo dekódujte obsah Base64.

Uložte všechny datové položky. Dekódujte každé b64\_json nebo stáhněte soubor z každé vrácené podepsané URL. Příponu souboru zvolte podle skutečného typu MIME a bajtů.

##### Pokud je nutné ověřit původní odpověď

Pokud výsledek generování nebo úpravy obrázku vyžaduje kontrolu, uchovejte původní operation\_id/X-Client-Request-ID a vrácené informace o výsledku. Existující vlastní výsledky obnovte prostřednictvím knihovny médií pomocí skutečných hodnot task\_id nebo asset\_id. Požadavek na generování či úpravu znovu neodesílejte a nevytvářejte URL pro dotazování na stav z operation\_id.

Pole odpovědi

| Pole | Typ |
| --- | --- |
| Pole`created` | Typinteger |
| Pole`data[].url` | Typstring |
| Pole`data[].b64_json` | Typbase64 string |
| 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. |
| Odpověď`server_error` | PodmínkaVrácená odpověď uvádí, že operaci nebo výsledek je třeba zkontrolovat | Další krokUchovejte původní vrácené ID operace nebo úlohy, hlavičky požadavku a odpověď; pokračujte v podporovaném načítání údajů o této původní operaci. Požadavek na vytvoření znovu neodesílejte. |

### Aliasy

#### Aliasy modelu

**Ailoot Ultra** [`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/cs/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

#### Aliasy cest metod

Použijte cesty metod uvedené výše.

#### Související ID modelů

[`recraft/recraft-v4.1-flash`](https://ailoot.ai/models/cs/#m=recraft%2Frecraft-v4.1-flash&route=Ultra&caller=recraft%2Frecraft-v4.1-flash&fmt=images)

FAQ · Recraft: Recraft V4.1 Flash

Jaké vstupy a výsledky jsou dostupné?

`POST /v1/images/generations` · `recraft/recraft-v4.1-flash`: `text` → `image`

Jaká pole požadavek používá?

`POST /v1/images/generations` · `recraft/recraft-v4.1-flash`: `model`, `prompt`, `n`, `response_format`, `stream`

Připojte Ailoot k Claude Code, OpenCode, Hermes nebo vlastní aplikaci.

## Společnost a její portfolio projektů

Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.

## Nakupujte tokeny se slevou.

Sleva předplatného pro pravidelnou práci. Promo kódy až 50% na nákup tokenů.

Předplatné

Pro pravidelné požadavky vyberte tarif se slevou.

Promo kód až 50%

Při nákupu zadejte kód. Cena se přepočítá podle probíhající akce.

Výdaje v historii

U každého požadavku se uloží model, tokeny a částka.

[Vybrat předplatné](https://ailoot.ai/docs/cs/billing/subscriptions/) · [Zobrazit ceny modelů](https://ailoot.ai/models/cs/)

## Připojte API k produktu, který prodáváte.

SaaS, aplikace a boti podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o licenci přeprodejce.

Komerční aplikace

Začleňte generování textu, obrázků, videa a zvuku do placených funkcí své služby.

Licence pro přeprodejce

Pošlete popis projektu a způsob poskytování přístupu. Vyžádejte písemné podmínky použití a přeprodeje.

Dokumenty na webu

Nabídka, licenční smlouva a zásady zpracování dat jsou dostupné před připojením.

[Požádat o licenci přeprodejce](mailto:support@ailoot.ai) · [Nabídka a licenční smlouva](https://ailoot.ai/legal/offer?lang=cs)

## Ailoot · Společnost a její portfolio projektů





Ailoot staví na dlouhodobých provozních zkušenostech, široké klientské základně, stabilních službách a průběžném sledování KPI.





Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.





Ailoot využívá tyto provozní zkušenosti k poskytování přístupu přes API k funkcím AI v produktech zákazníků, agentech, aplikacích a automatizacích.