Source: https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/
Canonical: https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/
Language: nl-be

# ByteDance Seed: Seedream 5.0 Flash

[Markdown](https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/index.md) · [JSON](https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/facts.json)

## [ByteDance Seed: Seedream 5.0 Flash](https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/)

Seedream 5.0 Flash maakt en bewerkt afbeeldingen vanuit tekst en visuele referenties, met ruimtelijk gestuurde wijzigingen, meertalige beeldtekst en laagontleding. ByteDance Seed positioneert Flash voor snellere generatie en houdt het onderscheiden van de op kwaliteit gerichte Pro-editie.

- [**Ailoot Ultra · Afbeeldingen** `POST /v1/images/generations` `bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/nl-be/bytedance-seed-seedream-5-0-flash/#method-0)

Over het model

Deze beschrijving gaat over de mogelijkheden van het model. De via Ailoot beschikbare invoer, uitvoer en opties staan hieronder voor de geselecteerde methode.

Een snellere editie voor beeldcreatie

Seedream 5.0 Flash is het beeldgeneratie- en bewerkingsmodel van ByteDance Seed voor workflows die generatiesnelheid vooropstellen. De Pro/Flash-gids van de maker beschrijft zowel tekst-naar-beeld als afbeelding-naar-afbeeldingcreatie met één of meerdere referenties. Hij onderscheidt de snellere generatie van Flash van de hogere beeldkwaliteitsprioriteit van Pro, zonder een vaste antwoordtijd voor elke briefing vast te leggen.

De kenmerkende gedeelde functies zijn interactieve bewerking, laagontleding en native meertalige generatie. Gewone generatie geeft één afgewerkte afbeelding terug. De Flash-workflow van de fabrikant ondersteunt geen opeenvolgende generatie van verwante beelden, webzoeken of streaming van beelduitvoer. De promptoptimalisatie gebruikt standaardmodus; de afzonderlijke snelle optimalisatie-instelling hoort bij Pro, niet bij Flash.

Creëren vanuit een briefing en referenties

Vermeld het bedoelde beeld, hoofdonderwerp, compositie en visuele uitwerking en benoem daarna wat elke referentie stuurt. Scheid bij een productbeeld de referentie die het object bepaalt van een referentie die een palet of oppervlaktemateriaal levert. “Behoud silhouet en kijkhoek van het object uit de eerste afbeelding; gebruik de tweede alleen voor het ingetogen achtergrondpalet” geeft de referenties verschillende rollen.

De maker beveelt beknopte prompts aan, maximaal 300 Chinese tekens of 600 Engelse woorden. Dat is voorbereidingsadvies, geen opgegeven harde afkapgrens voor tekstinvoer. Zet de doorslaggevende vereisten eerst, inclusief exacte tekst die moet verschijnen, de gewenste beeldverhouding en details die ongewijzigd moeten blijven. Vergelijk het afgewerkte beeld met die lijst in plaats van alleen op het algemene uiterlijk te vertrouwen.

Ruimtelijk gestuurde bewerking

Flash kan punten, begrenzingsvakken, pijlen en vrije markeringen gebruiken om aan te geven waar een bewerking moet plaatsvinden. Lever het bronbeeld aan samen met een locatie en de wijziging. Markeer voor een interieurconcept de stoel, vraag een vervanging van de stof en benoem vloer, muur, camerahoek en nabije objecten die moeten blijven. Vraag expliciet om de markeringen uit het eindbeeld te verwijderen als ze alleen aanwijzingen zijn.

De coördinatenbewerkingsgids van de maker gebruikt \<point\>- en \<bbox\>-tags met coördinaten genormaliseerd naar 0–999 ten opzichte van de opgegeven invoerafbeelding. Een punt bevat x en y; een vak bevat de coördinaten linksboven en rechtsonder. Benoem afbeeldingsnummer en doelobject, vooral als een vak meerdere onderwerpen omvat. Onderscheid bij een bewerking tussen afbeeldingen het object uit de ene referentie en het bestemmingsgebied in een andere.

Gebruik de eigen afmetingen van de getoonde afbeelding om de relatieve locatie te bepalen; canvaszoom, verschuiving of browsercoördinaten zijn geen genormaliseerde afbeeldingscoördinaten. Beschrijf beschermde gebieden naast het bewerkte gebied. Vergelijk perspectief, verlichting en omliggende details van het resultaat met de oorspronkelijke bron.

Splits een compositie op in bewerkbare lagen

Laagontleding is een afzonderlijke modus die precies één afbeelding gebruikt en een basisafbeelding plus maximaal 16 onafhankelijke lagen teruggeeft. Elke laag is een PNG met alfa. Een prompt kan de te scheiden elementen benoemen, zoals titel, hoofdonderwerp en decoraties; zonder ontledingsprompt bepaalt het model de hoofdelementen automatisch.

De resultaten bevatten laagnamen, beschrijvingen, stapelvolgorde en plaatsingsvakken. Gebruik de basisafbeelding met stapelindex nul en plaats de andere lagen daarna in oplopende stapelvolgorde. Absolute vakken beschrijven de plaatsing in de uitvoerbasisafbeelding; genormaliseerde vakken beschrijven relatieve plaatsing op een ander canvas. Bewaar die teruggestuurde plaatsingsmetadata bij de afbeeldingsbestanden, zodat je de oorspronkelijke compositie kan reconstrueren voordat je ze herschikt.

Scheid voor een posterherziening het hoofdbeeld van titel en decoraties en controleer daarna randen en eventueel herstelde achtergrondzones. Een transparante laag kan worden bewerkt als één invoer met alfakanaal, met transparante PNG-uitvoer. De optie voor transparante achtergrond geldt voor die workflow voor beeldbewerking met één invoer; gewone tekst-naar-beeldgeneratie is een afzonderlijke bewerking.

Meertalige compositie

Naast Chinees en Engels documenteert de maker native ondersteuning voor prompts en beeldtekst in Russisch, Arabisch, Filipijns, Thai, Turks, Koreaans, Maleis, Spaans, Portugees, Indonesisch, Frans, Duits, Vietnamees en Japans. Geef de exacte goedgekeurde formulering en leesrichting op en benoem in welke zone elk tekstblok staat. Controleer accenten, verbonden tekens, regelafbrekingen en kleine labels in het eindbeeld.

Referentiebestanden en uitvoerspecificaties

Beeldgeneratie accepteert maximaal 10 referenties in JPEG, PNG, WebP, BMP, TIFF, GIF, HEIC of HEIF. Elke afbeelding mag maximaal 30 MB zijn, met beide zijden groter dan 14 pixels, 196–36.000.000 pixels in totaal en een beeldverhouding van 1:16 tot 16:1. Laagontleding vereist daarentegen één JPEG of PNG van 262.144–36.000.000 pixels, maximaal 30 MB, binnen hetzelfde verhoudingsbereik.

Generatie biedt uitvoerniveaus 1K, 1.5K en 2K, standaard 2K, of expliciete afmetingen met 921.600–4.624.220 pixels in totaal en verhoudingen van 1:16 tot 16:1. Beide voorwaarden gelden voor aangepaste afmetingen. Laaguitvoer gebruikt 1K, 1.5K, 2K of auto, met auto als standaard; de basis en elke laag behouden hun respectieve bronverhoudingen.

Afgewerkte afbeeldingen zijn JPEG of PNG. Het formaat van de basisafbeelding kan afzonderlijk worden gekozen, terwijl ontlede lagen PNG met alfa blijven. Levering kan gecodeerde afbeeldingsdata of downloadlinks met een bewaartijd van 24 uur gebruiken. Bewaar elke teruggestuurde afbeelding en haar metadata voor de bedoelde ontwerpworkflow. Controleer tekst, bewerkte details en laaguitlijning op de grootte waarop het beeld zal worden gebruikt.

**Ailoot Ultra · Afbeeldingen** `POST /v1/images/generations` `bytedance-seed/seedream-5-0-flash`

[`bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/nl-be/#m=bytedance-seed%2Fseedream-5-0-flash&route=Ultra&caller=bytedance-seed%2Fseedream-5-0-flash&fmt=images)

ByteDance Seed /`bytedance-seed/seedream-5-0-flash`

### Aan de slag

Maak één afgewerkte afbeelding op basis van een tekstuele briefing.

- Maak een stilstaand productbeeld
- Verken een visueel concept
- Illustreer een scène

Toegestane invoer

Tekst

Resultaten

Afbeeldingen

### Beschikbaar in Ailoot · invoer en methoden

**Ailoot Ultra · Afbeeldingen** `POST /v1/images/generations`

Invoer

`text`

Uitvoer

`image`

Uitvoerformaat

Afbeeldingsbestand

Aantal uitvoerresultaten

1 uitvoer

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten bytedance-seed/seedream-5-0-flash | Standaard— |
| Veld`prompt` | Type`string` | VereisteVereist | Waarden en limieten Minimumlengte: 1 Voorwaarden: Niet-lege UTF8-prompt. Er wordt geen tekenlimiet voor alle modellen van de fabrikant verzonnen. | Standaard— |
| Veld`n` | Type`integer` | VereisteOptioneel | Waarden en limieten 1 | Standaard1 |
| Veld`response_format` | Type`string` | VereisteOptioneel | Waarden en limieten url, b64\_json | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten false | Standaardfalse |

Combinaties van invoermaterialen

**Tekst naar afbeelding** · Vereist: prompt

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, prompt |
| Parameter`material_types` | Contracttext |
| Parameter`optional` | Contractn, response\_format, stream |
| Parameter`n` | Contract1 |
| Parameter`stream` | Contractfalse |
| Parameter`response_format` | Contracturl, b64\_json |
| Parameter`reference_images` | Contractfalse |
| Parameter`edit` | Contractfalse |
| Parameter`output_format_optional` | Contract |
| Parameter`resolution_control` | Contractnull |
| Parameter`aspect_ratio_control` | Contractnull |
| Parameter`other_fields` | Contractgeweigerd, behalve voor de exacte vastgezette interne routering naar de aanbieder |

Levenscyclus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · daadwerkelijk teruggegeven task\_id of record in de mediabibliotheek

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

`GET /v1/media/assets`

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

Genereer één afbeelding op basis van een prompt.

Sla elk gegevensitem op; url/b64\_json zijn coderingen van het resultaat.

### Tarieven

##### Zo worden de uiteindelijke kosten berekend

De getoonde tarieven ramen de kosten vóór de generatie. De definitieve kosten worden berekend op basis van de kosten die voor de oorspronkelijke generatie zijn geregistreerd. De gemeten duur van het gegenereerde resultaat en de geraamde hoeveelheden vormen niet de definitieve factureerbare hoeveelheid.

Tariefverwijzingen voegen geen verzoekopties toe. Ondersteunde parameters staan bij de geselecteerde methode.

Snelle modus

Niet opgegeven Wanneer de snelle modus geselecteerd is

Flex-modus

Niet opgegeven Wanneer de flex-modus geselecteerd is

Maximale redeneerinspanning

Niet opgegeven Wanneer voor maximale redeneerinspanning de default-aanpassing wordt gebruikt

#### Geschatte tarieven ter vergelijking

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Verwachte hoeveelheid | Rekeneenheid | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieBasistarieven voor tokens | TariefstaffelBasistarief | Verwachte hoeveelheid— | Rekeneenheid— | Kosten Invoer · Invoertokens · Schatting uitsluitend ter vergelijking **—** / 1K tokens Uitvoer · Uitvoertokens · Schatting uitsluitend ter vergelijking **—** / 1K tokens Invoer · Cache lezen · Schatting uitsluitend ter vergelijking **—** / 1K tokens Invoer · Cache schrijven · Schatting uitsluitend ter vergelijking **—** / 1K tokens Invoer · Cache schrijven, 1 uur · Schatting uitsluitend ter vergelijking **—** / 1K tokens |
| Configuratieinvoerafbeelding | Tariefstaffel— | Verwachte hoeveelheid— | Rekeneenheidper invoerafbeelding | Kosten Invoer · invoerafbeelding · Schatting uitsluitend ter vergelijking **$0** per invoerafbeelding |
| ConfiguratieUltra | Tariefstaffel— | Verwachte hoeveelheid— | Rekeneenheidper uitvoerafbeelding | Kosten Uitvoer · afbeeldingsuitvoer · Schatting uitsluitend ter vergelijking **$0.036** per uitvoerafbeelding |
| ConfiguratieGeschatte generatiekosten | Tariefstaffel— | Verwachte hoeveelheidschatting voor één generatie | Rekeneenheid— | Kosten Uitvoer · Geschatte generatiekosten · Schatting uitsluitend ter vergelijking **$0.036** schatting vóór generatie Deze raming is geen extra kost of vast tarief voor de voltooide generatie. |

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl-be/billing/reserve/)

#### Details van het referentietarief

Referentiestaffels op modelniveau veranderen de methodeselectie, kostenramingen of afschrijvingen niet. Voor de actieve kostenberekening gelden de tarieven van de geselecteerde Ailoot-methode.

Prijsconfiguraties voor afbeeldingen

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Factureringsvoorwaarden | Kosten |
| --- | --- | --- |
| ConfiguratieUitvoerafbeelding | FactureringsvoorwaardenEr is geen prijsvariant gedeclareerd. | Kosten Uitvoer · Uitvoerafbeelding **$0.036** per afbeelding |
| ConfiguratieInvoerafbeelding | FactureringsvoorwaardenEr is geen prijsvariant gedeclareerd. | Kosten Invoer · Invoerafbeelding **$0** per afbeelding |

Gelijkwaardige vermeldingen beschrijven dezelfde aanrekening; ze voegen geen tweede kost toe.

### Voorbeeldverzoeken

#### Ailoot Ultra · Afbeeldingen

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": "bytedance-seed/seedream-5-0-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': 'bytedance-seed/seedream-5-0-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": "bytedance-seed/seedream-5-0-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");
```

### Resultaten ophalen en opslaan

#### Ailoot Ultra · Afbeeldingen

Download elke teruggegeven afbeelding of sla de Base64-inhoud ervan op

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

##### Alle voltooide resultaten bewaren

Sla elke voltooide afbeelding op; haal elke teruggegeven URL op of decodeer de bijbehorende Base64-inhoud.

Sla elk gegevensitem op. Decodeer elke b64\_json of haal elke teruggegeven ondertekende URL op. Kies een bestandsextensie op basis van de daadwerkelijke MIME/bytes.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Als het resultaat van een afbeeldingsgeneratie of -bewerking gecontroleerd moet worden, bewaar dan de oorspronkelijke operation\_id/X-Client-Request-ID en de teruggegeven resultaatinformatie. Haal bestaande eigen resultaten terug via de mediabibliotheek met daadwerkelijk teruggegeven task\_id- of asset\_id-waarden. Dien de generatie- of bewerkingsaanvraag niet opnieuw in en stel geen polling-URL samen op basis van operation\_id.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`created` | Typeinteger |
| Veld`data[].url` | Typestring |
| Veld`data[].b64_json` | Typebase64 string |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |
| Antwoord`server_error` | VoorwaardeDe teruggegeven respons geeft aan dat de bewerking of het resultaat gecontroleerd moet worden | Volgende stapBewaar de oorspronkelijk teruggegeven bewerkings-/taak-ID, aanvraagheaders en respons; blijf de oorspronkelijke bewerking uitlezen via de ondersteunde leesaanvragen. Dien de aanmaakaanvraag niet opnieuw in. |

### Aliasnamen

#### Modelaliasnamen

**Ailoot Ultra** [`bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/nl-be/#m=bytedance-seed%2Fseedream-5-0-flash&route=Ultra&caller=bytedance-seed%2Fseedream-5-0-flash&fmt=images)

#### Aliasnamen voor methodepaden

Gebruik de hierboven getoonde methodepaden.

#### Gerelateerde aanroeper-ID’s

[`bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/nl-be/#m=bytedance-seed%2Fseedream-5-0-flash&route=Ultra&caller=bytedance-seed%2Fseedream-5-0-flash&fmt=images)

FAQ · ByteDance Seed: Seedream 5.0 Flash

Welke invoer en resultaten zijn beschikbaar?

`POST /v1/images/generations` · `bytedance-seed/seedream-5-0-flash`: `text` → `image`

Welke velden gebruikt het verzoek?

`POST /v1/images/generations` · `bytedance-seed/seedream-5-0-flash`: `model`, `prompt`, `n`, `response_format`, `stream`

Verbind Ailoot met Claude Code, OpenCode, Hermes of je eigen applicatie.

## Het bedrijf en zijn projectenportefeuille

Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.

## Koop tokens met korting.

Abonnementsvoordeel voor regelmatig gebruik. Promotiecodes geven tot 50% korting op tokens.

Abonnement

Kies een abonnement met korting voor je terugkerende verzoeken.

Promotiecode tot 50%

Vul de code bij aankoop in. De prijs wordt volgens de lopende actie herberekend.

Kosten in de geschiedenis

Model, tokens en bedrag worden per verzoek bewaard.

[Kies een abonnement](https://ailoot.ai/docs/nl-be/billing/subscriptions/) · [Bekijk modelprijzen](https://ailoot.ai/models/nl-be/)

## Verbind de API met het product dat je verkoopt.

SaaS, apps en bots volgens de openbare aanbodvoorwaarden en licentieovereenkomst van Ailoot. Vraag voor doorverkoop een resellerlicentie aan.

Commerciële applicatie

Voeg tekst-, beeld-, video- en geluidsgeneratie aan betaalde functies van je service toe.

Resellerlicentie

Stuur een projectbeschrijving en toegangsschema. Vraag schriftelijke voorwaarden voor gebruik en doorverkoop.

Documenten op de site

Aanbodvoorwaarden, licentieovereenkomst en gegevensbeleid zijn vóór het verbinden beschikbaar.

[Vraag een resellerlicentie aan](mailto:support@ailoot.ai) · [Aanbodvoorwaarden en licentieovereenkomst](https://ailoot.ai/legal/offer?lang=nl-be)

## Ailoot · Het bedrijf en zijn projectenportefeuille





Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.





Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.





Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.
