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

# ByteDance Seed: Seedream 5.0 Flash

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

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

Seedream 5.0 Flash erstellt und bearbeitet Bilder aus Text und visuellen Referenzen mit räumlich geführten Änderungen, mehrsprachigem Bildtext und Ebenenzerlegung. ByteDance Seed positioniert Flash für schnellere Generierung und unterscheidet es dabei von der qualitätsorientierten Pro-Edition.

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

Über das Modell

Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.

Eine schnellere Bilderstellungsedition

Seedream 5.0 Flash ist ByteDance Seeds Modell für Bildgenerierung und -bearbeitung in Abläufen mit Schwerpunkt auf Generierungsgeschwindigkeit. Der Pro-/Flash-Leitfaden des Herstellers beschreibt sowohl Text-to-Image als auch Image-to-Image mit einer oder mehreren Referenzen. Er unterscheidet Flashs schnellere Generierung von Pros höherem Bildqualitätsanspruch, ohne für jedes Briefing eine feste Antwortzeit festzulegen.

Die kennzeichnenden gemeinsamen Funktionen sind interaktive Bearbeitung, Ebenenzerlegung und native mehrsprachige Generierung. Gewöhnliche Generierung liefert ein fertiges Bild. Der Flash-Ablauf des Herstellers unterstützt weder sequenzielle Generierung zusammengehöriger Bilder noch Websuche oder gestreamte Bildausgabe. Seine Prompt-Optimierung verwendet den Standardmodus; die separate schnelle Optimierungssteuerung gehört zu Pro statt Flash.

Aus Briefing und Referenzen erstellen

Benennen Sie gewünschtes Bild, Hauptmotiv, Komposition und Bildgestaltung und bestimmen Sie danach, was jede Referenz steuert. Trennen Sie bei einem Produktvisual die objektbestimmende Referenz von einer für Palette oder Oberflächenmaterial. «Erhalte Silhouette und Blickwinkel des Objekts aus dem ersten Bild; nutze das zweite nur für die gedämpfte Hintergrundpalette» gibt den Referenzen eigene Rollen.

Der Hersteller empfiehlt knappe Prompts mit höchstens 300 chinesischen Zeichen oder 600 englischen Wörtern. Dies ist Vorbereitungshilfe und keine erklärte harte Texteingabegrenze. Listen Sie entscheidende Anforderungen zuerst auf, darunter exakten sichtbaren Wortlaut, gewünschtes Seitenverhältnis und unverändert zu erhaltende Details. Prüfen Sie das fertige Bild anhand dieser Liste, statt sich nur auf den Gesamteindruck zu verlassen.

Räumlich geführte Bearbeitung

Flash kann Punkte, Begrenzungsrahmen, Pfeile und freie Markierungen verwenden, um den Bearbeitungsort zu bestimmen. Liefern Sie das Quellbild zusammen mit Ort und Änderung. Markieren Sie bei einem Einrichtungskonzept den Stuhl, verlangen Sie den Austausch des Bezugsstoffs und benennen Sie Boden, Wand, Kamerawinkel und nahe Objekte, die erhalten bleiben sollen. Dienen Markierungen nur als Vorgabe, verlangen Sie ausdrücklich ihre Entfernung aus dem fertigen Bild.

Der Koordinatenbearbeitungsleitfaden des Herstellers verwendet \<point\>- und \<bbox\>-Tags mit auf 0–999 normalisierten Koordinaten relativ zum angegebenen Eingabebild. Ein Punkt enthält x und y; ein Rahmen die Koordinaten oben links und unten rechts. Benennen Sie Bildnummer und Zielobjekt, besonders wenn ein Rahmen mehrere Motive einschliesst. Unterscheiden Sie bei bildübergreifender Bearbeitung das aus einer Referenz zu übernehmende Objekt und die Zielregion in einer anderen.

Verwenden Sie zur Ermittlung der proportionalen Position die eigenen Abmessungen des angezeigten Bildes; Leinwandzoom, Verschiebung oder Browserkoordinaten sind nicht die normalisierten Bildkoordinaten. Beschreiben Sie geschützte und bearbeitete Bereiche. Vergleichen Sie Perspektive, Beleuchtung und Umgebungsdetails des Ergebnisses mit der Originalquelle.

Eine Komposition in bearbeitbare Ebenen zerlegen

Ebenenzerlegung ist ein eigener Modus mit genau einem Eingabebild und einem Basisbild plus bis zu 16 unabhängigen Ebenen als Ausgabe. Jede Ebene ist ein PNG mit Alpha. Ein Prompt kann die zu trennenden Elemente nennen, etwa Titel, Hauptmotiv und Dekoration; ohne Zerlegungsprompt erkennt das Modell die Hauptelemente automatisch.

Die Ergebnisse enthalten Ebenennamen, Beschreibungen, Stapelreihenfolge und Platzierungsrahmen. Verwenden Sie das Basisbild mit Stapelindex null und platzieren Sie danach andere Ebenen in aufsteigender Stapelreihenfolge. Absolute Rahmen beschreiben Platzierung im ausgegebenen Basisbild; normalisierte Rahmen die proportionale Platzierung auf einer anderen Leinwand. Bewahren Sie diese zurückgegebenen Platzierungsmetadaten mit den Bilddateien auf, damit sich die ursprüngliche Komposition vor der Neuanordnung rekonstruieren lässt.

Trennen Sie bei einer Plakatüberarbeitung Hauptbild, Titel und Dekoration und prüfen Sie dann Kanten sowie wiederhergestellte Hintergrundbereiche. Eine transparente Ebene lässt sich als einzelne Alpha-Kanal-Eingabe mit transparenter PNG-Ausgabe bearbeiten. Die Option für transparenten Hintergrund gilt für diesen Bildbearbeitungsablauf mit einer Eingabe; gewöhnliche Text-to-Image-Generierung ist eine separate Operation.

Mehrsprachige Komposition

Neben Chinesisch und Englisch dokumentiert der Hersteller native Unterstützung für Prompts und Bildtext in Russisch, Arabisch, Filipino, Thai, Türkisch, Koreanisch, Malaiisch, Spanisch, Portugiesisch, Indonesisch, Französisch, Deutsch, Vietnamesisch und Japanisch. Liefern Sie den exakten freigegebenen Wortlaut und die Leserichtung und bestimmen Sie den Bereich jedes Textblocks. Prüfen Sie Akzente, verbundene Zeichen, Zeilenumbrüche und kleine Beschriftungen im fertigen Bild.

Referenzdateien und Ausgabespezifikationen

Bildgenerierung akzeptiert bis zu 10 Referenzen in JPEG, PNG, WebP, BMP, TIFF, GIF, HEIC oder HEIF. Jede darf bis 30 MB gross sein, mit beiden Seiten über 14 Pixeln, insgesamt 196–36’000’000 Pixeln und einem Seitenverhältnis von 1:16 bis 16:1. Ebenenzerlegung verlangt dagegen ein JPEG oder PNG mit 262’144–36’000’000 Pixeln bis 30 MB innerhalb desselben Verhältnisbereichs.

Generierung bietet die Ausgabestufen 1K, 1.5K und 2K, standardmässig 2K, oder ausdrückliche Abmessungen mit insgesamt 921’600–4’624’220 Pixeln und Verhältnissen von 1:16 bis 16:1. Beide Bedingungen gelten für individuelle Abmessungen. Ebenenausgabe verwendet 1K, 1.5K, 2K oder auto, standardmässig auto; Basis und jede Ebene erhalten ihre jeweiligen Quellseitenverhältnisse.

Fertige Bilder sind JPEG oder PNG. Das Format des Basisbildes lässt sich separat wählen; zerlegte Ebenen bleiben PNG mit Alpha. Die Lieferung kann codierte Bilddaten oder für 24 Stunden aufbewahrte Downloadlinks verwenden. Speichern Sie jedes zurückgegebene Bild und seine Metadaten für den vorgesehenen Designablauf. Prüfen Sie Text, bearbeitete Details und Ebenenausrichtung in der späteren Verwendungsgrösse.

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

[`bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/de-ch/#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`

### Einstieg

Aus einer Textbeschreibung ein fertiges Bild erstellen.

- Ein Standbild eines Produkts erstellen
- Ein visuelles Konzept erkunden
- Eine Szene illustrieren

Zulässige Eingaben

Text

Ergebnisse

Bilder

### In Ailoot verfügbar · Eingaben und Methoden

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

Eingabe

`text`

Ausgabe

`image`

Ausgabeformat

Bilddatei

Ausgabeanzahl

1 Ausgabe

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits bytedance-seed/seedream-5-0-flash | Standard— |
| Feld`prompt` | Typ`string` | AnforderungErforderlich | Werte und Limits Mindestlänge: 1 Bedingungen: Nicht leere UTF8-Textbeschreibung. Es wird keine herstellerweite Zeichengrenze erfunden. | Standard— |
| Feld`n` | Typ`integer` | AnforderungOptional | Werte und Limits 1 | Standard1 |
| Feld`response_format` | Typ`string` | AnforderungOptional | Werte und Limits url, b64\_json | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits false | Standardfalse |

Kombinationen von Eingabematerialien

**Text zu Bild** · Erforderlich: prompt

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, prompt |
| Parameter`material_types` | Vertragtext |
| Parameter`optional` | Vertragn, response\_format, stream |
| Parameter`n` | Vertrag1 |
| Parameter`stream` | Vertragfalse |
| Parameter`response_format` | Vertragurl, b64\_json |
| Parameter`reference_images` | Vertragfalse |
| Parameter`edit` | Vertragfalse |
| Parameter`output_format_optional` | Vertrag |
| Parameter`resolution_control` | Vertragnull |
| Parameter`aspect_ratio_control` | Vertragnull |
| Parameter`other_fields` | VertragAbgewiesen, ausser bei exakt festgelegtem internem Anbieterrouting |

Lebenszyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · die tatsächlich zurückgegebene task\_id oder ein Eintrag in der Medienbibliothek

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

`GET /v1/media/assets`

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

Erzeugen Sie ein Bild aus einer Textbeschreibung.

Speichern Sie jedes Datenelement; url/b64\_json sind Ergebnisdarstellungen.

### Tarife

##### So wird die endgültige Gebühr berechnet

Die angezeigten Tarife dienen zur Kostenschätzung vor der Generierung. Der endgültige Betrag wird aus den für die ursprüngliche Generierung erfassten Kosten berechnet. Die gemessene Ausgabedauer und prognostizierte Mengen sind nicht die endgültige abrechenbare Menge.

Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.

Schnellmodus

Nicht angegeben Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Nicht angegeben Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Nicht angegeben Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

#### Geschätzte Tarife zum Vergleich

#### Preise nach Konfiguration

Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.

| Konfiguration | Tarifstaffel | Prognostizierte Menge | Abrechnungseinheit | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationToken-Basistarife | TarifstaffelGrundtarif | Prognostizierte Menge— | Abrechnungseinheit— | Gebühr Eingabe · Eingabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Ausgabe · Ausgabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache lesen · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache schreiben · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache schreiben, 1 Stunde · Schätzung nur zum Vergleich **—** / 1K Tokens |
| KonfigurationEingabebild | Tarifstaffel— | Prognostizierte Menge— | Abrechnungseinheitpro Eingabebild | Gebühr Eingabe · Eingabebild · Schätzung nur zum Vergleich **$0** pro Eingabebild |
| KonfigurationUltra | Tarifstaffel— | Prognostizierte Menge— | Abrechnungseinheitpro Ausgabebild | Gebühr Ausgabe · Bildausgabe · Schätzung nur zum Vergleich **$0.036** pro Ausgabebild |
| KonfigurationGeschätzte Erzeugungskosten | Tarifstaffel— | Prognostizierte MengeSchätzung für eine Generierung | Abrechnungseinheit— | Gebühr Ausgabe · Geschätzte Generierungskosten · Schätzung nur zum Vergleich **$0.036** Schätzung vor der Generierung Diese Schätzung ist weder eine zusätzliche Gebühr noch ein fester Tarif für die abgeschlossene Generierung. |

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschliessenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de-ch/billing/reserve/)

#### Details zum Referenztarif

Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.

Preiskonfigurationen für Bilder

#### Preise nach Konfiguration

Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.

| Konfiguration | Abrechnungsbedingungen | Gebühr |
| --- | --- | --- |
| KonfigurationAusgabebild | AbrechnungsbedingungenEs ist keine Preisvariante deklariert. | Gebühr Ausgabe · Ausgabebild **$0.036** pro Bild |
| KonfigurationEingabebild | AbrechnungsbedingungenEs ist keine Preisvariante deklariert. | Gebühr Eingabe · Eingabebild **$0** pro Bild |

Gleichwertige Einträge beschreiben dieselbe Abbuchung; sie verursachen keine zweite Gebühr.

### Beispielanfragen

#### Ailoot Ultra · Bilder

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

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · Bilder

Laden Sie jedes zurückgegebene Bild herunter oder speichern Sie seinen Base64-Inhalt

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

##### Alle fertiggestellten Ergebnisse aufbewahren

Speichern Sie jedes fertiggestellte Bild; rufen Sie jede zurückgegebene URL ab oder dekodieren Sie seinen Base64-Inhalt.

Jedes Datenelement speichern. Jedes b64\_json dekodieren oder jede zurückgegebene signierte URL abrufen. Die Dateiendung anhand des tatsächlichen MIME-Typs bzw. der Bytes wählen.

##### Wenn die ursprüngliche Antwort geprüft werden muss

Wenn das Ergebnis einer Bildgenerierung oder -bearbeitung geprüft werden muss, die ursprüngliche operation\_id/X-Client-Request-ID und die zurückgegebenen Ergebnisinformationen aufbewahren. Bereits vorhandene eigene Ergebnisse über die Medienbibliothek anhand tatsächlicher task\_id- oder asset\_id-Werte wiederherstellen. Die Generierungs-/Bearbeitungsanfrage nicht erneut senden und keine Abfrage-URL aus operation\_id bilden.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`created` | Typinteger |
| Feld`data[].url` | Typstring |
| Feld`data[].b64_json` | Typbase64 string |
| Feld`usage` | Typobject |

Fehler und nächste Schritte

| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
| Antwort`server_error` | BedingungDie zurückgegebene Antwort gibt an, dass der Vorgang oder das Ergebnis eine Prüfung erfordert | Nächster SchrittDie ursprünglich zurückgegebene Vorgangs-/Aufgaben-ID, die Anfrageheader und die Antwort aufbewahren; mit unterstützten Leseaufrufen für diesen ursprünglichen Vorgang fortfahren. Die Erstellungsanfrage nicht erneut senden. |

### Aliasnamen

#### Modellaliasnamen

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

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/de-ch/#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

Welche Eingaben und Ergebnisse sind verfügbar?

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

Welche Felder verwendet die Anfrage?

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

Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung.

## Das Unternehmen und sein Projektportfolio

Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.

## Tokens mit Rabatt kaufen.

Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf.

Abo

Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen.

Aktionscode bis 50%

Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet.

Ausgaben in der Historie

Modell, Tokens und Betrag werden für jede Anfrage gespeichert.

[Abo wählen](https://ailoot.ai/docs/de-ch/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de-ch/)

## Verbinden Sie die API mit dem Produkt, das Sie verkaufen.

SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an.

Kommerzielle Anwendung

Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes.

Reseller-Lizenz

Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an.

Dokumente auf der Website

Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich.

[Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de-ch)

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.
