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

# ByteDance Seed: Seedream 5.0 Flash

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

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

Seedream 5.0 Flash erstellt und bearbeitet Bilder aus Text und visuellen Referenzen, mit räumlich gesteuerten Änderungen, mehrsprachigem Bildtext und Ebenenzerlegung. ByteDance Seed positioniert Flash für schnellere Generierung und trennt es dabei von der auf Qualität ausgerichteten Pro-Ausgabe.

- [**Ailoot Ultra · Bilder** `POST /v1/images/generations` `bytedance-seed/seedream-5-0-flash`](https://ailoot.ai/models/de/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 Ausgabe zur Bilderstellung

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

Die gemeinsamen kennzeichnenden Funktionen sind interaktive Bearbeitung, Ebenenzerlegung und native mehrsprachige Generierung. Normale Generierung gibt ein fertiges Bild zurück. Der Flash-Ablauf des Herstellers unterstützt weder die sequenzielle Generierung zusammengehöriger Bilder noch Websuche oder Streaming-Bildausgabe. Seine Prompt-Optimierung nutzt den Standardmodus; die separate schnelle Optimierungssteuerung gehört zu Pro und nicht zu Flash.

Aus einem Briefing und Referenzen erstellen

Benennen Sie gewünschtes Bild, Hauptmotiv, Komposition und visuelle Gestaltung und geben Sie anschließend an, was jede Referenz steuert. Trennen Sie bei einer Produktvisualisierung die Referenz für das Objekt von einer Referenz für Palette oder Oberflächenmaterial. „Bewahre Silhouette und Blickwinkel des Objekts aus dem ersten Bild; verwende das zweite Bild ausschließlich für die gedämpfte Hintergrundpalette“ weist den Referenzen unterschiedliche Rollen zu.

Der Hersteller empfiehlt knappe Prompts mit höchstens 300 chinesischen Zeichen oder 600 englischen Wörtern. Dies ist eine Vorbereitungsempfehlung und keine angegebene harte Texteingabegrenze. Führen Sie entscheidende Anforderungen zuerst auf, einschließlich genauem erforderlichem Wortlaut, gewünschtem Seitenverhältnis und unverändert zu bewahrenden Details. Prüfen Sie das fertige Bild anhand dieser Liste, statt sich nur auf den Gesamteindruck zu verlassen.

Räumlich gesteuerte Bearbeitung

Flash kann Punkte, Begrenzungsrahmen, Pfeile und Freiformmarkierungen nutzen, um den Ort einer Bearbeitung zu bestimmen. Stellen Sie das Quellbild zusammen mit Position und Änderung bereit. Markieren Sie bei einem Innenraumkonzept den Stuhl, verlangen Sie einen Stoffaustausch 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 Leitfaden des Herstellers zur Koordinatenbearbeitung verwendet \<point\>- und \<bbox\>-Tags mit Koordinaten, die relativ zum angegebenen Eingabebild auf 0–999 normiert sind. Ein Punkt enthält x und y, ein Rahmen die Koordinaten links oben und rechts unten. Benennen Sie Bildnummer und Zielobjekt, besonders wenn ein Rahmen mehrere Motive enthält. Unterscheiden Sie bei einer bildübergreifenden Bearbeitung das aus einer Referenz zu übernehmende Objekt von der Zielregion in einer anderen.

Verwenden Sie beim Ermitteln der proportionalen Position die eigenen Abmessungen des angezeigten Bilds; Canvas-Zoom, Verschiebung oder Browserkoordinaten sind nicht die normierten Bildkoordinaten. Beschreiben Sie geschützte Bereiche ebenso wie den bearbeiteten Bereich. Vergleichen Sie Perspektive, Beleuchtung und umgebende Details des Ergebnisses mit der Originalquelle.

Eine Komposition in bearbeitbare Ebenen aufteilen

Ebenenzerlegung ist ein eigener Modus, der genau ein Bild entgegennimmt und ein Basisbild sowie bis zu 16 unabhängige Ebenen zurückgibt. Jede Ebene ist ein PNG mit Alphakanal. Ein Prompt kann die zu trennenden Elemente benennen, 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 die übrigen Ebenen anschließend in aufsteigender Stapelreihenfolge. Absolute Rahmen beschreiben die Platzierung im ausgegebenen Basisbild; normierte Rahmen beschreiben die proportionale Platzierung auf einer anderen Arbeitsfläche. Bewahren Sie diese zurückgegebenen Platzierungsmetadaten mit den Bilddateien auf, damit sich die Originalkomposition vor einer Neuanordnung rekonstruieren lässt.

Trennen Sie für eine Posterüberarbeitung die Hauptgrafik von Titel und Dekoration und prüfen Sie anschließend Kanten sowie wiederhergestellte Hintergrundbereiche. Eine transparente Ebene kann als einzelne Eingabe mit Alphakanal bearbeitet werden, mit transparentem PNG als Ausgabe. Die Option für transparenten Hintergrund gilt für diesen Bildbearbeitungsablauf mit einer Eingabe; normale Text-to-Image-Generierung ist ein separater Vorgang.

Mehrsprachige Komposition

Zusätzlich zu Chinesisch und Englisch dokumentiert der Hersteller native Unterstützung für Prompts und Bildtext auf Russisch, Arabisch, Filipino, Thai, Türkisch, Koreanisch, Malaiisch, Spanisch, Portugiesisch, Indonesisch, Französisch, Deutsch, Vietnamesisch und Japanisch. Stellen Sie den genauen freigegebenen Wortlaut und die Leserichtung bereit und geben Sie an, welcher Bereich welchen Textblock enthält. Prüfen Sie Akzente, verbundene Zeichen, Zeilenumbrüche und kleine Beschriftungen im fertigen Bild.

Referenzdateien und Ausgabespezifikationen

Bildgenerierung akzeptiert bis zu 10 Referenzen als JPEG, PNG, WebP, BMP, TIFF, GIF, HEIC oder HEIF. Jede darf bis zu 30 MB groß sein, mit beiden Seiten über 14 Pixeln, insgesamt 196–36.000.000 Pixeln und einem Seitenverhältnis von 1:16 bis 16:1. Ebenenzerlegung erfordert stattdessen ein JPEG oder PNG mit 262.144–36.000.000 Pixeln, bis zu 30 MB und innerhalb desselben Seitenverhältnisbereichs.

Generierung bietet die Ausgabestufen 1K, 1.5K und 2K, standardmäßig 2K, oder ausdrückliche Abmessungen mit insgesamt 921.600–4.624.220 Pixeln und Seitenverhältnissen von 1:16 bis 16:1. Beide Vorgaben gelten für eigene Abmessungen. Ebenenausgabe verwendet 1K, 1.5K, 2K oder auto, standardmäßig auto; Basisbild und jede Ebene behalten ihre jeweiligen Quellseitenverhältnisse.

Fertige Bilder sind JPEG oder PNG. Das Format des Basisbilds lässt sich separat wählen, während zerlegte Ebenen PNG mit Alphakanal bleiben. Die Auslieferung kann kodierte Bilddaten oder Download-Links mit 24 Stunden Aufbewahrung 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 Größe, in der das Bildmaterial eingesetzt wird.

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

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

### Start

Erstelle ein fertiges Bild aus einer Textbeschreibung.

- Erstelle ein statisches Produktbild
- Erkunde ein visuelles Konzept
- Illustriere eine Szene

Zulässige Eingaben

Text

Ergebnisse

Bilder

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

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

Eingabetypen

`text`

Ausgabetypen

`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 leerer UTF8-Prompt. Es wird keine herstellerweit geltende 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` | VertragAbgelehnt, außer bei der exakt festgelegten internen Anbieterrouting-Konfiguration |

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

Ein Bild aus dem Prompt erzeugen.

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

### 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 |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Prognostizierte Menge— | Abrechnungseinheit— | Gebühr Eingabe · Eingabetoken · Schätzung nur zum Vergleich **—** / 1K Token Ausgabe · Ausgabetoken · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Lesen · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Schreiben · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde · Schätzung nur zum Vergleich **—** / 1K Token |
| 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 Generierungskosten | 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 abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/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 Abrechnung; sie fügen keine zweite Gebühr hinzu.

### 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/#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/#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/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/)

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

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