> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Bildgenerierung

> Bilder mit dem nativen AIHubMix-Protokoll synchron oder asynchron generieren, Aufgaben abfragen und Ergebnisse herunterladen.

<Note>
  [Modell-Schema-API](/de/api/async-tasks#model-schema)
</Note>

## Schnellstart

Der native Bildendpunkt arbeitet standardmäßig synchron. Setzen Sie den booleschen Wert `async` auf `true`, um eine Hintergrundaufgabe zu erstellen. Das Beispiel verwendet `qwen-image-2.0`.

<CodeGroup>
  ```bash Aufgabe erstellen theme={null}
  curl -X POST https://aihubmix.com/ai/v1/images/generations \
    -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "model": "qwen-image-2.0",
      "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
      "n": 1,
      "size": "1024x1024",
      "async": true
    }'
  ```

  ```json Erstellungsantwort theme={null}
  {
    "id": "task_01K0ABCDEF",
    "object": "image",
    "model": "qwen-image-2.0",
    "status": "in_progress",
    "output": [],
    "error": null,
    "created_at": 1784707200,
    "completed_at": null,
    "expires_at": null
  }
  ```

  ```bash Aufgabe abfragen theme={null}
  curl https://aihubmix.com/ai/v1/images/{id} \
    -H "Authorization: Bearer $AIHUBMIX_API_KEY"
  ```

  ```bash Ergebnis herunterladen theme={null}
  curl "{content_url}" \
    -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
    --output result.png
  ```
</CodeGroup>

<h2 id="model-schema">
  Wie findet man asynchrone Medienmodelle und ruft ihre Schemas ab?
</h2>

Die Ermittlung erfolgt in zwei Schritten. Rufen Sie zuerst Text-zu-Bild- oder Text-zu-Video-Modelle mit Unterstützung für die asynchronen APIs aus dem öffentlichen Modellkatalog ab. Verwenden Sie anschließend die `model_id`, um das Anfrageschema der Endpunkte des Modells abzurufen.

<h3 id="async-media-model-list">
  Modelle mit Unterstützung für die asynchronen APIs auflisten
</h3>

Der Modellkatalog verwendet dieselbe Datenquelle wie Playground. Nutzen Sie `type=image_generation` für Text-zu-Bild-Modelle und `type=video` für Text-zu-Video-Modelle. Mit `schema_checked=true` enthält die Liste nur Modelle mit veröffentlichtem und geprüftem Anfrageschema.

```bash theme={null}
# Text-zu-Bild-Modelle
curl "https://aihubmix.com/api/v1/models?type=image_generation&schema_checked=true&sort_by=order"

# Text-zu-Video-Modelle
curl "https://aihubmix.com/api/v1/models?type=video&schema_checked=true&sort_by=order"
```

Beide Anfragen verwenden denselben Endpunkt. Der Filter `type` akzeptiert derzeit einen Wert. Fragen Sie daher jeden Modelltyp separat ab.

Die Antwort hat die Form `{success, message, data}`. Für asynchrone Medienintegrationen sind die folgenden Felder in `data` relevant.

| Feld                      | Beschreibung                                                                |
| ------------------------- | --------------------------------------------------------------------------- |
| `data[].model_id`         | Modell-ID für Generierungsanfragen und nachfolgende Schema-Anfragen         |
| `data[].model_name`       | Anzeigename des Modells                                                     |
| `data[].types`            | Kommagetrennte Modelltypen, möglicherweise mit `image_generation` und `llm` |
| `data[].input_modalities` | Kommagetrennte Eingabemodalitäten                                           |
| `data[].schema_checked`   | `true`, wenn das Anfrageschema veröffentlicht und geprüft wurde             |

```json theme={null}
{
  "success": true,
  "message": "",
  "data": [
    {
      "model_id": "qwen-image-2.0",
      "model_name": "Qwen Image 2.0",
      "types": "image_generation",
      "input_modalities": "text,image",
      "schema_checked": true
    }
  ]
}
```

<h3 id="single-model-schema">
  Anfrageschema eines einzelnen Modells abrufen
</h3>

Unterstützte Felder, Aufzählungswerte und Wertebereiche können je nach Modell variieren. Rufen Sie vor einer Bild- oder Videoanfrage über den folgenden öffentlichen Endpunkt die verfügbaren Endpunkte und Anfrage-JSON-Schemas des gewählten Modells ab.

```bash theme={null}
# Text-zu-Bild-Modell
curl "https://aihubmix.com/call/schema/models/qwen-image-2.0/endpoints"

# Text-zu-Video-Modell
curl "https://aihubmix.com/call/schema/models/wan2.6-t2v/endpoints"
```

Die Antwort enthält für `modality` den Wert `image` oder `video`. Jeder Eintrag im Array `endpoints` beschreibt ein verfügbares Aufrufprotokoll.

| Feld                         | Beschreibung                                                                                                       |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| `default_endpoint`           | Kennung des Standardendpunkts für das Modell                                                                       |
| `endpoints[].endpoint`       | Endpunktkennung                                                                                                    |
| `endpoints[].method`         | HTTP-Methode, zum Beispiel `POST`                                                                                  |
| `endpoints[].path`           | Anfragepfad                                                                                                        |
| `endpoints[].content_types`  | Vom Endpunkt akzeptierte Inhaltstypen                                                                              |
| `endpoints[].lifecycle`      | Synchroner oder asynchroner Modus, Abfragepfad und Statuswerte                                                     |
| `endpoints[].request.schema` | Vollständiges Anfrage-JSON-Schema für dieses Modell und diesen Endpunkt mit Pflichtfeldern und Wertebeschränkungen |

Ein Modell kann sowohl `/ai/v1`-Endpunkte als auch OpenAI-kompatible `/v1`-Endpunkte zurückgeben. OpenAI-kompatible Endpunkte unterstützen die neuesten Modelle möglicherweise noch nicht. Verwenden Sie daher bevorzugt die `/ai/v1`-Endpunkte. Wählen Sie für die asynchronen Aufgaben-APIs den Eintrag mit dem `path` `/ai/v1/images/generations` oder `/ai/v1/videos` aus und verwenden Sie dessen `request.schema`. Verlassen Sie sich nicht auf die Position eines Eintrags im Array `endpoints`.

Die folgenden Befehle extrahieren das Anfrageschema für die beiden asynchronen Aufgabenendpunkte.

```bash theme={null}
# Text-zu-Bild
curl -s "https://aihubmix.com/call/schema/models/qwen-image-2.0/endpoints" \
  | jq '.endpoints[] | select(.path == "/ai/v1/images/generations") | .request.schema'

# Text-zu-Video
curl -s "https://aihubmix.com/call/schema/models/wan2.6-t2v/endpoints" \
  | jq '.endpoints[] | select(.path == "/ai/v1/videos") | .request.schema'
```

Der Endpunkt gibt `404 model_not_found` zurück, wenn das Modell nicht existiert oder keine auffindbaren Endpunkte besitzt. Wenn die Endpunktdaten vorübergehend nicht verfügbar sind, wird `500 endpoints_unavailable` zurückgegeben.

***

<h2 id="create-async-task">
  Wie erstellt man Bildaufgaben?
</h2>

<h3 id="create-sync-image">
  Synchrone Bilder
</h3>

Wenn Sie `async` weglassen oder auf `false` setzen, wartet der Endpunkt auf den Abschluss der Generierung und gibt anschließend das Aufgabenobjekt zurück:

```bash theme={null}
curl -X POST https://aihubmix.com/ai/v1/images/generations \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2.0",
    "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
    "n": 1,
    "size": "1024x1024",
    "response_format": "url"
  }'
```

Auch synchrone Bildaufgaben werden als Aufgabendatensatz gespeichert. Wird die Clientverbindung unterbrochen oder geht die Erstellungsantwort verloren, können Sie die entsprechende Aufgabe über `GET /ai/v1/images` suchen.

<h3 id="create-async-image">
  Asynchrone Bilder
</h3>

Wenn Sie `async` auf den booleschen Wert `true` setzen, gibt der Endpunkt sofort ein Aufgabenobjekt zurück und die Generierung wird im Hintergrund fortgesetzt:

```bash theme={null}
curl -X POST https://aihubmix.com/ai/v1/images/generations \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2.0",
    "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
    "n": 2,
    "size": "1024x1024",
    "async": true
  }'
```

Fragen Sie asynchrone Bildaufgaben mit `GET /ai/v1/images/{id}` ab. Nach dem Abschluss können Sie die `content_url` jedes `output`-Eintrags direkt anfordern. Diese URL enthält bereits die `result_id` des jeweiligen Bildes.

<Note>
  `async` muss in Bildanfragen ein boolescher Wert sein. `webhook_url` und
  `webhook_events_filter` können nur zusammen mit `async: true` verwendet
  werden.
</Note>

<h3 id="image-parameters">
  Standardfelder für Bilder
</h3>

| Feld                    | Typ           | Erforderlich | Beschreibung                                                        |
| ----------------------- | ------------- | ------------ | ------------------------------------------------------------------- |
| `model`                 | string        | Ja           | Modellname                                                          |
| `prompt`                | string        | Ja           | Bildbeschreibung; darf nicht leer sein                              |
| `n`                     | integer/null  | Nein         | Anzahl der Bilder, Mindestwert `1`, Standardwert `1`                |
| `size`                  | string/null   | Nein         | `{width}x{height}`, zum Beispiel `1024x1024`                        |
| `aspect_ratio`          | string/null   | Nein         | Seitenverhältnis; alternativ zu `size`                              |
| `seed`                  | integer/null  | Nein         | Zufallsstartwert                                                    |
| `negative_prompt`       | string/null   | Nein         | Negativer Prompt                                                    |
| `image`                 | string/object | Nein         | Einzelnes Eingabebild als URL, Data URI, Base64 oder `{url}`-Objekt |
| `images`                | array/null    | Nein         | Mehrere Eingabebilder                                               |
| `mask`                  | string/object | Nein         | Maske für die Bildbearbeitung                                       |
| `output_format`         | string/null   | Nein         | `png`, `jpeg` oder `webp`; Standardwert `png`                       |
| `response_format`       | string/null   | Nein         | `url` oder `b64_json`; Standardwert `url`                           |
| `async`                 | boolean       | Nein         | Führt die Aufgabe asynchron aus, wenn der Wert `true` ist           |
| `webhook_url`           | string        | Nein         | HTTPS-Callback-URL mit maximal 512 Zeichen                          |
| `webhook_events_filter` | string\[]     | Nein         | Nicht leere Teilmenge von `completed`, `failed` und `cancelled`     |
| `extra`                 | object/null   | Nein         | Modellspezifische Zusatzparameter                                   |

***

<h2 id="task-object">
  Objekt einer Medienaufgabe
</h2>

Die dedizierten Endpunkte für Bilder und Videos geben folgende Struktur zurück:

```json theme={null}
{
  "id": "task_01K0ABCDEF",
  "object": "image",
  "model": "qwen-image-2.0",
  "status": "completed",
  "output": [
    {
      "index": 0,
      "type": "file",
      "b64_json": null,
      "content_url": "https://aihubmix.com/ai/v1/images/task_01K0ABCDEF/content/result_01K0XYZ"
    }
  ],
  "error": null,
  "created_at": 1784707200,
  "completed_at": 1784707320,
  "expires_at": null
}
```

| Feld           | Typ          | Beschreibung                                                                |
| -------------- | ------------ | --------------------------------------------------------------------------- |
| `id`           | string       | Aufgaben-ID der Plattform                                                   |
| `object`       | string       | `image` oder `video`                                                        |
| `model`        | string       | Modellname                                                                  |
| `status`       | string       | Aktueller Aufgabenstatus                                                    |
| `output`       | array        | Bereits generierte Ergebnisse; leeres Array, solange kein Ergebnis vorliegt |
| `error`        | object/null  | Fehlerinformationen; kann `code`, `message` und `upstream_detail` enthalten |
| `created_at`   | integer      | Erstellungszeit als Unix-Zeit in Sekunden                                   |
| `completed_at` | integer/null | Zeitpunkt des endgültigen Status als Unix-Zeit in Sekunden                  |
| `expires_at`   | null         | Dedizierte Medienendpunkte geben derzeit `null` zurück                      |

Einträge in `output` für Medien:

| Feld          | Typ         | Beschreibung                                   |
| ------------- | ----------- | ---------------------------------------------- |
| `index`       | integer     | Reihenfolge des Ergebnisses, beginnend mit `0` |
| `type`        | string      | Derzeit `file`                                 |
| `content_url` | string/null | URL zum Herunterladen des Ergebnisses          |
| `b64_json`    | string/null | Base64-codiertes Bildergebnis                  |

<h3 id="task-status">
  Statusbeschreibung
</h3>

| Status        | Beendet | Beschreibung                                                            |
| ------------- | ------- | ----------------------------------------------------------------------- |
| `pending`     | Nein    | Die Plattform hat die Aufgabe angenommen; sie wartet auf die Ausführung |
| `in_progress` | Nein    | Die Aufgabe wird ausgeführt                                             |
| `completed`   | Ja      | Die Aufgabe ist abgeschlossen; `output` kann gelesen werden             |
| `failed`      | Ja      | Die Aufgabe ist fehlgeschlagen; die Ursache steht in `error`            |
| `cancelled`   | Ja      | Die Aufgabe wurde abgebrochen                                           |

Der Client kann alle 15 Sekunden abfragen, bis der Status `completed`, `failed` oder `cancelled` lautet. Die 15 Sekunden sind eine Empfehlung für das clientseitige Polling und keine Einschränkung des Serverprotokolls.

***

<h2 id="query-tasks">
  Wie fragt man Medienaufgaben ab?
</h2>

<h3 id="query-task-detail">
  Mediendetails abfragen
</h3>

```bash theme={null}
# Bild
curl https://aihubmix.com/ai/v1/images/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"

# Video
curl https://aihubmix.com/ai/v1/images/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"
```

Die Detailendpunkte für Medien können einen aktualisierten Aufgabenstatus zurückgeben. Verwenden Sie zum Polling von Medien daher den jeweiligen Detailendpunkt für Bilder oder Videos.

<h3 id="query-task-list">
  Medienliste abfragen
</h3>

Falls die Erstellungsantwort verloren geht, können Sie die Aufgaben-ID über die entsprechende Medienliste wiederfinden:

```bash theme={null}
curl "https://aihubmix.com/ai/v1/images?limit=20&order=desc" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"
```

| Parameter | Typ     | Standardwert | Beschreibung                                                                     |
| --------- | ------- | ------------ | -------------------------------------------------------------------------------- |
| `after`   | string  | -            | Cursor für die Seitennavigation; verwenden Sie `next_after` der vorherigen Seite |
| `limit`   | integer | `20`         | Anzahl pro Seite, maximal `100`                                                  |
| `order`   | string  | `desc`       | Mit `asc` aufsteigend; alle anderen Werte werden als `desc` behandelt            |

```json theme={null}
{
  "object": "list",
  "data": [
    {
      "id": "task_01K0ABCDEF",
      "object": "image",
      "model": "qwen-image-2.0",
      "status": "in_progress",
      "output": [],
      "error": null,
      "created_at": 1784707200,
      "completed_at": null,
      "expires_at": null
    }
  ],
  "has_more": true,
  "next_after": "task_01K0ABCDEF"
}
```

Medienlisten geben eine Momentaufnahme zum Abfragezeitpunkt zurück und aktualisieren den Aufgabenstatus nicht aktiv.

***

<h2 id="unified-tasks">
  Wie verwendet man einheitliche Aufgabenendpunkte?
</h2>

Die einheitlichen Aufgabenendpunkte unterstützen folgende Filter:

```bash theme={null}
curl "https://aihubmix.com/ai/v1/tasks?object=image&status=in_progress&limit=20&order=desc" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"
```

| Parameter | Typ     | Standardwert | Beschreibung                                                     |
| --------- | ------- | ------------ | ---------------------------------------------------------------- |
| `object`  | string  | -            | `llm`, `image` oder `video`                                      |
| `status`  | string  | -            | `pending`, `in_progress`, `completed`, `failed` oder `cancelled` |
| `model`   | string  | -            | Exakte Filterung nach Modellname                                 |
| `after`   | string  | -            | Cursor für die Seitennavigation                                  |
| `limit`   | integer | `20`         | Bereich von `1` bis `100`                                        |
| `order`   | string  | `desc`       | `asc` oder `desc`                                                |

Details einer einheitlichen Aufgabe:

```bash theme={null}
curl https://aihubmix.com/ai/v1/tasks/{task_id} \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY"
```

Einheitlicher `output`-Eintrag einer Medienaufgabe:

```json theme={null}
{
  "index": 0,
  "result_id": "result_01K0XYZ",
  "type": "file",
  "content_type": "image/png",
  "content_url": "https://aihubmix.com/ai/v1/tasks/task_01K0ABCDEF/content/result_01K0XYZ"
}
```

Fordern Sie bei einem einzelnen Artefakt direkt `/ai/v1/tasks/{id}/content` an. Bei Aufgaben mit mehreren Artefakten müssen Sie `/ai/v1/tasks/{id}/content/{result_id}` anfordern. Ohne Ergebnis-ID wird `400 result_id_required` zurückgegeben.

<Note>
  Die einheitlichen Endpunkte für Aufgabenlisten, Details und Inhalte sind nach
  dem Bearer Token isoliert, mit dem die Aufgabe erstellt wurde. Andere API Keys
  desselben Kontos können die Aufgabe nicht lesen.
</Note>

***

<h2 id="get-task-results">
  Medienergebnisse herunterladen
</h2>

<h3 id="multiple-artifacts">
  Bilder herunterladen
</h3>

Fordern Sie nach Abschluss der Bildaufgabe die `output[].content_url` jedes Eintrags im Medienaufgabenobjekt an:

```bash theme={null}
curl "{content_url}" \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  --output result.png
```

Der Medienpfad zum Herunterladen eines Bildes lautet `/ai/v1/images/{id}/content/{result_id}`. Das Medienaufgabenobjekt veröffentlicht `result_id` nicht separat. Der Client kann direkt `content_url` verwenden.

Wenn `b64_json` nicht leer ist, können Sie dieses Feld direkt Base64-decodieren.

<h2 id="webhooks">
  Webhooks verwenden
</h2>

Asynchrone Bilder und Videos unterstützen Webhooks auf Aufgabenebene:

```bash theme={null}
curl -X POST https://aihubmix.com/ai/v1/images/generations \
  -H "Authorization: Bearer $AIHUBMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen-image-2.0",
    "prompt": "A tranquil garden at sunrise",
    "n": 1,
    "async": true,
    "size": "1024x1024",
    "webhook_url": "https://example.com/webhooks/aihubmix",
    "webhook_events_filter": ["completed", "failed"]
  }'
```

`webhook_url` darf höchstens 512 Zeichen lang sein und nicht auf den lokalen Rechner, ein privates Netzwerk oder eine andere eingeschränkte Adresse verweisen. Wenn Sie `webhook_events_filter` weglassen, sendet die Plattform `completed`, `failed` und `cancelled`. Bei expliziter Angabe darf das Array weder leer sein noch Duplikate enthalten und muss zusammen mit `webhook_url` verwendet werden.

Wenn die Anfrage keine `webhook_url` enthält, versuchen asynchrone Bilder und Videos, die im Konto konfigurierte Standard-Callback-URL zu verwenden. Eine ungültige Standardadresse des Kontos wird ignoriert und verhindert die Erstellung der Aufgabe nicht.

<h3 id="webhook-payload">
  Callback-Anfrage
</h3>

```json theme={null}
{
  "event_id": "evt_01K0ABCDEF",
  "event_type": "completed",
  "created_at": "2026-08-12T12:00:00Z",
  "data": {
    "task_id": "task_01K0ABCDEF",
    "status": "completed",
    "model": "qwen-image-2.0",
    "results": [
      {
        "url": "https://aihubmix.com/ai/v1/tasks/task_01K0ABCDEF/content/result_01K0XYZ"
      }
    ]
  }
}
```

| Feld                 | Beschreibung                                                                  |
| -------------------- | ----------------------------------------------------------------------------- |
| `event_id`           | ID des Callback-Ereignisses zur Deduplizierung                                |
| `event_type`         | `completed`, `failed` oder `cancelled`                                        |
| `created_at`         | Ereigniszeit im Format RFC 3339                                               |
| `data.task_id`       | Aufgaben-ID der Plattform                                                     |
| `data.status`        | Aktueller endgültiger Status                                                  |
| `data.model`         | Modellname                                                                    |
| `data.results[].url` | URL zum Herunterladen des Ergebnisses, die nach Abschluss enthalten sein kann |
| `data.error`         | Fehlerinformationen, die bei einem Fehlschlag enthalten sein können           |

`results` ist nur vorhanden, wenn das Ergebnis archiviert wurde. Für den Download ist weiterhin ein Bearer Token erforderlich.

<h3 id="webhook-retry">
  Wiederholungsversuche und Deduplizierung
</h3>

Die Plattform stellt mindestens einmal zu. Dasselbe Ereignis kann daher mehrfach eintreffen:

* HTTP `2xx` kennzeichnet einen erfolgreichen Empfang.
* HTTP `5xx`, Netzwerkfehler oder Zeitüberschreitungen lösen einen erneuten Versuch aus.
* Bei HTTP `3xx` und `4xx` erfolgt kein erneuter Versuch.
* Es erfolgen höchstens 6 Zustellversuche mit Abständen von 1, 4, 16, 64 und 256 Sekunden.

Der Empfänger sollte `event_id` speichern und beim erneuten Empfang desselben Ereignisses direkt `2xx` zurückgeben.

<Warning>
  Webhooks auf Aufgabenebene besitzen keinen eigenen Signaturschlüssel. Wenn Sie
  eine Signaturprüfung benötigen, konfigurieren Sie ein Webhook-Abonnement auf
  Kontoebene und behalten Sie die Abfrage der Aufgabendetails als Bestätigung
  des Ergebnisses bei.
</Warning>

***

<h2 id="error-codes">
  Fehlerantworten und Fehlercodes
</h2>

```json theme={null}
{
  "error": {
    "message": "Task not found.",
    "type": "invalid_request_error",
    "code": "task_not_found",
    "tid": "req_01K0ABCDEF"
  }
}
```

| HTTP-Statuscode | Fehlercode                      | Beschreibung                                                                                                |
| --------------- | ------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| 400             | `invalid_request`               | Parametertyp oder Wert ist ungültig                                                                         |
| 400             | `result_id_required`            | Die einheitliche Aufgabe besitzt mehrere Ergebnisse, beim Download wurde jedoch keine `result_id` angegeben |
| 400             | `webhook_invalid`               | Die Webhook-URL ist ungültig oder für den Filter fehlt eine URL                                             |
| 400             | `webhook_events_filter_invalid` | Die Webhook-Ereignisliste ist ungültig                                                                      |
| 401             | `authentication_failed`         | API Key fehlt oder ist ungültig                                                                             |
| 403             | `async_not_enabled`             | Die Funktion für asynchrone Aufgaben ist für das Konto nicht aktiviert                                      |
| 404             | `task_not_found`                | Aufgabe oder Cursor für die Seitennavigation ist nicht vorhanden                                            |
| 404             | `result_not_found`              | Ergebnis ist nicht vorhanden oder kann derzeit nicht heruntergeladen werden                                 |
| 410             | `artifact_expired`              | Ergebnis ist abgelaufen                                                                                     |
| 413             | `request_too_large`             | Anfrageinhalt überschreitet 32 MiB                                                                          |
| 429             | `too_many_downloads`            | Begrenzung der Anzahl von Ergebnisdownloads wurde überschritten                                             |
| 503             | `async_unavailable`             | Dienst für asynchrone Bilder ist vorübergehend nicht verfügbar                                              |

`error.tid` ist die ID zur Anfrageverfolgung. Geben Sie sie bei einer Anfrage an den technischen Support mit an.

***

## Vollständiges Beispiel

Diese Beispiele erstellen eine asynchrone Aufgabe, fragen sie ab und speichern alle Bilder.

<CodeGroup>
  ```python Python theme={null}
  import base64
  import os
  import time

  import requests

  base_url = "https://aihubmix.com"
  headers = {
      "Authorization": f"Bearer {os.environ['AIHUBMIX_API_KEY']}",
      "Content-Type": "application/json",
  }

  response = requests.post(
      f"{base_url}/ai/v1/images/generations",
      headers=headers,
      json={
          "model": "qwen-image-2.0",
          "prompt": "A flower shop with delicate windows, warm sunlight streaming in",
          "n": 1,
          "size": "1024x1024",
          "async": True,
      },
      timeout=60,
  )
  response.raise_for_status()
  task = response.json()

  while task["status"] not in {"completed", "failed", "cancelled"}:
      time.sleep(15)
      response = requests.get(
          f"{base_url}/ai/v1/images/{task['id']}",
          headers=headers,
          timeout=30,
      )
      response.raise_for_status()
      task = response.json()

  if task["status"] != "completed":
      raise RuntimeError(task.get("error") or task["status"])

  for output in task["output"]:
      filename = f"result-{output['index']}.png"
      if output.get("b64_json"):
          content = base64.b64decode(output["b64_json"])
      else:
          result = requests.get(output["content_url"], headers=headers, timeout=120)
          result.raise_for_status()
          content = result.content
      with open(filename, "wb") as file:
          file.write(content)
  ```

  ```typescript TypeScript theme={null}
  import { writeFile } from "node:fs/promises";

  const baseUrl = "https://aihubmix.com";
  const headers = {
    Authorization: `Bearer ${process.env.AIHUBMIX_API_KEY}`,
    "Content-Type": "application/json",
  };

  const created = await fetch(`${baseUrl}/ai/v1/images/generations`, {
    method: "POST",
    headers,
    body: JSON.stringify({
      model: "qwen-image-2.0",
      prompt: "A flower shop with delicate windows, warm sunlight streaming in",
      n: 1,
      size: "1024x1024",
      async: true,
    }),
  });
  if (!created.ok) throw new Error(await created.text());
  let task = await created.json();

  const finished = new Set(["completed", "failed", "cancelled"]);
  while (!finished.has(task.status)) {
    await new Promise((resolve) => setTimeout(resolve, 15_000));
    const polled = await fetch(`${baseUrl}/ai/v1/images/${task.id}`, { headers });
    if (!polled.ok) throw new Error(await polled.text());
    task = await polled.json();
  }

  if (task.status !== "completed") {
    throw new Error(JSON.stringify(task.error ?? task.status));
  }

  for (const output of task.output) {
    let content;
    if (output.b64_json) {
      content = Buffer.from(output.b64_json, "base64");
    } else {
      const result = await fetch(output.content_url, { headers });
      if (!result.ok) throw new Error(await result.text());
      content = Buffer.from(await result.arrayBuffer());
    }
    await writeFile(`result-${output.index}.png`, content);
  }
  ```
</CodeGroup>