Source: https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/
Canonical: https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/
Language: lt

# GPT Image 2.5 Flare 2026-09-08

[Markdown](https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/index.md) · [JSON](https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/facts.json)

## [GPT Image 2.5 Flare 2026-09-08](https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/)

GPT Image 2.5 Flare skirta kasdieniam vaizdų generavimui pagal aprašymą. Numatyti pasirinktiniai dydžiai, išplėstas kokybės lygių rinkinys ir skaidrus fonas.

- [**Ailoot · Vaizdai** `POST /v1/images/generations` `gpt-image-2.5-flare-2026-09-08`](https://ailoot.ai/models/lt/gpt-image-2-5-flare-2026-09-08/#method-0)

Apie modelį

Šis aprašas apima modelio galimybes. Pasirinktam metodui Ailoot prieinamos įvestys, išvestys ir parinktys nurodytos toliau.

#### Kasdienis generavimas pagal tekstinį aprašymą

GPT Image 2.5 Flare — OpenAI modelis vaizdams kurti. Gamintojo duomenimis, jo paskirtis — greitas kasdienis kokybiškos vaizdinės medžiagos generavimas. Užduotyje galima aprašyti siužetą, stilių, detalių išdėstymą ir norimą kadro formatą; rezultatas yra vaizdas.

Ailoot ši kortelė pateikta generavimui su tekstine įvestimi. OpenAI taip pat aprašo darbą su pradiniais vaizdais, pavyzdiniais vaizdais ir redagavimą. Šiems būdams reikia įvesties vaizdų palaikymo; jie nereiškia, kad tekstinis metodas jau priima tokią medžiagą.

#### Kokybė nuo juodraščio iki detalaus vaizdo

Palaikomi lygiai `low`, `medium`, `high`, `xhigh`, `max` ir automatinis pasirinkimas `auto`. Kokybės nustatymas veikia darbo apimtį formuojant rezultatą. Jis nustatomas atskirai nuo kadro dydžio ir paruošto failo suspaudimo.

Dydžiui numatyti kvadratinis, horizontalus ir vertikalus variantai, automatinis pasirinkimas ir pasirinktiniai dydžiai. Galima parinkti kompozicijai tinkamas proporcijas laikantis visų gamintojo ribojimų.

#### Pasirinktiniai dydžiai

Kiekviena kraštinė turi būti 16 pikselių kartotinis ir ne ilgesnė kaip 3840 pikselių. Ilgosios ir trumposios kraštinių santykis — ne didesnis kaip 3:1. Leidžiamas plotas yra nuo 655 360 iki 8 294 400 pikselių. Ribojimai galioja kartu: leidžiamas kraštinių santykis nepanaikina ploto ribos.

Didesnės nei `2560x1440` raiškos pažymėtos kaip eksperimentinės. Renkantis didelį kadrą svarbu atsižvelgti į pačią kompoziciją: didesnis pikselių skaičius negarantuoja nepriekaištingo visų jos elementų išdėstymo.

#### Rezultato failas ir skaidrumas

Modelis numato PNG, JPEG ir WebP; standartinis formatas — PNG. JPEG ir WebP galima valdyti suspaudimą. Skaidriam fonui reikia PNG arba WebP. Gamintojas taip pat palaiko neskaidrų foną ir automatinį pasirinkimą. Skaidrumas leidžia naudoti vaizdą tolesnėje kompozicijoje be nustatyto pagrindo.

Gamintojo nustatymai apibūdina modelio galimybes; jų vykdymas priklauso nuo to, ar pasirinktas metodas palaiko parametrus. Atskiras generavimas sukuria naują rezultatą, todėl toks pats aprašymas negarantuoja visiško vaizdų sutapimo.

#### Ką tikrinti paruoštame vaizde

OpenAI duomenimis, sudėtingos užduoties apdorojimas gali trukti iki dviejų minučių. Tai generavimo gamintojo sistemoje aprašymas, o ne viso rezultato gavimo laiko konkrečioje programoje garantija.

Užrašus, tikslią objektų padėtį ir tos pačios išvaizdos išlaikymą tarp vaizdų reikia tikrinti. Atskirai palaikomoje redagavimo operacijoje kaukė nustato keitimo kryptį, o ne griežtą ribą. Tekstiniam generavimui naudinga tiksliai aprašyti kompoziciją ir patikrinti patį failą: matomas detales, įskaitomumą ir atitiktį nurodytam siužetui.

**Ailoot · Vaizdai** `POST /v1/images/generations` `gpt-image-2.5-flare-2026-09-08`

[`gpt-image-2.5-flare-2026-09-08`](https://ailoot.ai/models/lt/#m=gpt-image-2.5-flare-2026-09-08&route=Core&caller=gpt-image-2.5-flare-2026-09-08&fmt=images)

OpenAI /`gpt-image-2.5-flare-2026-09-08`

### Pradžia

GPT Image 2.5 Flare skirta kasdieniam vaizdų generavimui pagal aprašymą. Numatyti pasirinktiniai dydžiai, išplėstas kokybės lygių rinkinys ir skaidrus fonas.

Leidžiamos įvestys

Tekstas

Rezultatai

Vaizdai

### Prieinama Ailoot · įvestys ir metodai

**Ailoot · Vaizdai** `POST /v1/images/generations`

Įvestis

`text`

Išvestis

`image`

Išvesties formatas

Vaizdo failas

| Laukas | Tipas | Reikalavimas | Reikšmės ir ribos | Numatyta |
| --- | --- | --- | --- | --- |
| Laukas`model` | Tipas`string` | ReikalavimasPrivaloma | Reikšmės ir ribos gpt-image-2.5-flare-2026-09-08 | Numatyta— |
| Laukas`prompt` | Tipas`string` | ReikalavimasPrivaloma | Reikšmės ir ribos Mažiausias ilgis: 1 | Numatyta— |
| Laukas`n` | Tipas`integer` | ReikalavimasNeprivaloma | Reikšmės ir ribos Mažiausia reikšmė: 1 | Numatyta1 |
| Laukas`response_format` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos url, b64\_json | Numatyta— |
| Laukas`stream` | Tipas`boolean` | ReikalavimasNeprivaloma | Reikšmės ir ribos | Numatytafalse |
| Laukas`size` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`quality` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`background` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`output_format` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`output_compression` | Tipas`integer` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`moderation` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`input_fidelity` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`style` | Tipas`string` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |
| Laukas`partial_images` | Tipas`integer` | ReikalavimasNeprivaloma | Reikšmės ir ribos Priklauso nuo modelio | Numatyta— |

Įvesties medžiagos deriniai

**Iš teksto į vaizdą** · Privaloma: prompt

Metodo parametrai ir gyvavimo ciklas

| Parametras | Specifikacija |
| --- | --- |
| Parametras`material_types` | Specifikacijatext |
| Parametras`required` | Specifikacijamodel, prompt |
| Parametras`optional_controls` | Specifikacijanull |
| Parametras`content_type` | Specifikacijaapplication/json |

Gyvavimo ciklas: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · faktiškai grąžinta task\_id reikšmė arba medijos bibliotekos įrašas

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

`GET /v1/media/assets`

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

Metodų struktūros ir ID yra tikslūs; tiekėjo galimybės yra atskirtos nuo užklausos priėmimo.

### Planai

#### Ailoot metodų įkainiai

Tekstinė įvestis

0,005 USD */ 1K*

Įvestis, vaizdas

0,008 USD */ 1K tokens*

Išvestis, vaizdas

0,03 USD */ 1K tokens*

Ailoot prieš užklausą rezervuoja numatomą sumą. Gavus rezultatą, galutinis mokestis nuskaitomas pagal išmatuotą naudojimą. Srautinio atsakymo atsiskaitymui naudojamas galutinis naudojimo įrašas. [Kaip veikia rezervavimas ir atsiskaitymas →](https://ailoot.ai/docs/lt/billing/reserve/)

### Užklausų pavyzdžiai

#### Ailoot · Vaizdai

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.5-flare-2026-09-08", "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.5-flare-2026-09-08', '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.5-flare-2026-09-08", "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");
```

### Gauti ir išsaugoti rezultatus

#### Ailoot · Vaizdai

Atsisiųskite kiekvieną grąžintą vaizdą arba išsaugokite jo Base64 turinį

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

##### Išsaugoti visus baigtus rezultatus

Išsaugokite kiekvieną baigtą vaizdą; gaukite turinį iš kiekvieno grąžinto URL arba dekoduokite jo Base64 turinį.

Išsaugokite kiekvieną duomenų elementą. Iškoduokite kiekvieną b64\_json arba atsisiųskite turinį pagal kiekvieną grąžintą pasirašytą URL. Failo plėtinį pasirinkite pagal faktinį MIME tipą ir baitus.

##### Jei reikia patikrinti pradinį atsakymą

Jei vaizdo generavimo ar redagavimo rezultatą reikia patikrinti, išsaugokite pradinį operation\_id/X-Client-Request-ID ir grąžintą informaciją apie rezultatą. Atkurkite prieigą prie esamų jums priklausančių rezultatų per medijos biblioteką, naudodami faktines task\_id arba asset\_id reikšmes. Pakartotinai neteikite generavimo ar redagavimo užklausos ir nekurkite būsenos tikrinimo URL iš operation\_id.

Atsakymo laukai

| Laukas | Tipas |
| --- | --- |
| Laukas`created` | Tipasinteger |
| Laukas`data[].url` | Tipasstring |
| Laukas`data[].b64_json` | Tipasbase64 string |
| Laukas`usage` | Tipasobject |

Klaidos ir tolesni veiksmai

| Atsakymas | Sąlyga | Kitas žingsnis |
| --- | --- | --- |
| Atsakymas400 · `invalid_request_error` | SąlygaNetinkami privalomi laukai, medžiagos pateikimo forma arba parametro reikšmė | Kitas žingsnisPrieš naują kūrimo užklausą pataisykite nurodytus laukus. |
| Atsakymas`server_error` | SąlygaGrąžintame atsakyme nurodoma, kad operaciją arba rezultatą reikia patikrinti | Kitas žingsnisIšsaugokite pradinį grąžintą operacijos ar užduoties ID, užklausos antraštes ir atsakymą; toliau tikrinkite tos pačios pradinės operacijos duomenis palaikomais būdais. Kūrimo užklausos pakartotinai neteikite. |

### Pseudonimai

#### Modelių pseudonimai

**Ailoot** [`gpt-image-2.5-flare-2026-09-08`](https://ailoot.ai/models/lt/#m=gpt-image-2.5-flare-2026-09-08&route=Core&caller=gpt-image-2.5-flare-2026-09-08&fmt=images)

#### Metodų kelių pseudonimai

Naudokite aukščiau nurodytus metodų kelius.

#### Susiję ID iškvietimui

[`gpt-image-2.5-flare-2026-09-08`](https://ailoot.ai/models/lt/#m=gpt-image-2.5-flare-2026-09-08&route=Core&caller=gpt-image-2.5-flare-2026-09-08&fmt=images)

FAQ · GPT Image 2.5 Flare 2026-09-08

Kokios įvestys ir rezultatai prieinami?

`POST /v1/images/generations` · `gpt-image-2.5-flare-2026-09-08`: `text` → `image`

Kokius laukus naudoja užklausa?

`POST /v1/images/generations` · `gpt-image-2.5-flare-2026-09-08`: `model`, `prompt`, `n`, `response_format`, `stream`

Kokie apribojimai taikomi?

`POST /v1/images/generations` · `gpt-image-2.5-flare-2026-09-08`: `n.minimum`: `1`

Prijunkite Ailoot prie Claude Code, OpenCode, Hermes arba savo programos.

## Įmonė ir jos projektų portfelis

Įmonė ir jos projektų portfelis: milijonai klientų; mėnesio pardavimai siekia milijardus.

## Pirkite žetonus su nuolaida.

Prenumeratos nuolaida reguliariam darbui. Kodai — iki 50% žetonų pirkimui.

Prenumerata

Pasirinkite planą su nuolaida reguliarioms užklausoms.

Nuolaidos kodas iki 50%

Įveskite kodą perkant. Kaina perskaičiuojama pagal galiojančios akcijos sąlygas.

Išlaidos istorijoje

Kiekvienai užklausai išsaugomi modelis, žetonai ir suma.

[Pasirinkti prenumeratą](https://ailoot.ai/docs/lt/billing/subscriptions/) · [Peržiūrėti modelių kainas](https://ailoot.ai/models/lt/)

## Prijunkite API prie produkto, kurį parduodate.

SaaS, programos ir botai pagal Ailoot ofertą bei licencijos sutartį. Perpardavimui paprašykite perpardavėjo licencijos.

Komercinė programa

Teksto, vaizdų, video ir garso kūrimą integruokite į mokamas paslaugos funkcijas.

Perpardavėjo licencija

Atsiųskite projekto aprašymą ir prieigos schemą. Paprašykite rašytinių naudojimo ir perpardavimo sąlygų.

Dokumentai svetainėje

Oferta, licencijos sutartis ir duomenų tvarkymo politika prieinamos prieš prisijungiant.

[Paprašyti perpardavėjo licencijos](mailto:support@ailoot.ai) · [Oferta ir licencijos sutartis](https://ailoot.ai/legal/offer?lang=lt)

## Ailoot · Įmonė ir jos projektų portfelis





Ailoot remiasi sukaupta veiklos patirtimi, plačia klientų baze, stabiliomis paslaugomis ir nuolatine KPI kontrole.





Įmonė ir jos projektų portfelis: milijonai klientų; mėnesio pardavimai siekia milijardus.





Ailoot šią veiklos patirtį pritaiko teikdama API prieigą prie DI funkcijų klientų produktuose, agentuose, programose ir automatizavimo sprendimuose.