> ## Documentation Index > Fetch the complete documentation index at: https://germeytechnology-docs-remove-4o-image-nav.mintlify.site/llms.txt > Use this file to discover all available pages before exploring further. # OpenAI Images Generations API Beantragung und Nutzung > OpenAI generation 集成指南 - Ace Data Cloud Die OpenAI Images Generations API unterstützt derzeit verschiedene Bildgenerierungsmodelle, darunter das klassische `dall-e-3`, das textlich stärkere `gpt-image-1`, die neueste Generation **`gpt-image-2`** sowie die über dieselbe Schnittstelle angebundenen Modelle der **`nano-banana` / `nano-banana-2` / `nano-banana-pro`** Serie. Alle können hochwertige Bilder basierend auf Textbeschreibungen erzeugen. Dieses Dokument beschreibt hauptsächlich den Nutzungsprozess der OpenAI Images Generations API, mit der wir die Bildgenerierungsfunktionen der OpenAI-Serie einfach verwenden können. ## Beantragungsprozess Um die OpenAI Images Generations API zu nutzen, können Sie zunächst auf der Seite [OpenAI Images Generations API](https://platform.acedata.cloud/documents/openai-images-generations) den Button „Acquire“ anklicken, um die für Anfragen benötigten Zugangsdaten zu erhalten: ![](https://cdn.acedata.cloud/nyq0xz.png) Falls Sie noch nicht eingeloggt oder registriert sind, werden Sie automatisch zur Login-Seite weitergeleitet, um sich zu registrieren und anzumelden. Nach der Anmeldung kehren Sie automatisch zur aktuellen Seite zurück. Bei der ersten Beantragung erhalten Sie ein kostenloses Kontingent, mit dem Sie die API kostenlos nutzen können. ## GPT-Image-2 Modell `gpt-image-2` ist das von OpenAI eingeführte neue Bildgenerierungsmodell, das im Vergleich zu `dall-e-3` und `gpt-image-1` folgende deutliche Verbesserungen bietet: * **Stärkere Befehlsbefolgung**: Kann komplexe Kompositionen, Zählungen, Positionsbeziehungen und andere strukturierte Anweisungen präzise verstehen. * **Klarere Textrendering**: In Szenarien wie Poster, Menüs, Infografiken und Logos werden englische Texte und Zahlen nahezu fehlerfrei dargestellt. * **Vielfältigere Stilwiedergabe**: Unterstützt nativ verschiedene Stile wie kinoreife Porträts, Retro-Poster, Kinderillustrationen, Produktfotografie, Infografiken usw. * **Native Unterstützung mehrerer Seitenverhältnisse + hohe Auflösung**: Deckt 5 Seitenverhältnisse (1:1, 4:3, 3:4, 16:9, 9:16) mit je 3 Auflösungsstufen (1K / 2K / 4K) ab. Die Aufrufweise ist identisch zu anderen Modellen, es muss lediglich das Feld `model` auf `gpt-image-2` gesetzt werden. Die im Ergebnis zurückgegebene `url` ist ein dauerhaft auf `platform.cdn.acedata.cloud` gehosteter Bildlink, der direkt im Browser geöffnet oder in Webseiten eingebettet werden kann. ### Unterstützte `size` Werte `gpt-image-2` prüft nur das Format von `size`. Solange es nicht `auto` oder leer ist, muss es dem Muster `WIDTHxHEIGHT` entsprechen (z.B. `1024x1024`, `2048x1152`, `800x600`); jede andere Form führt zu einem 400-Fehler. **Alle Größen (1K / 2K / 4K / benutzerdefiniert) werden pro Bild einheitlich abgerechnet, es gibt keine Aufpreisstaffelung nach Größe.** Obere Einschränkungen für benutzerdefinierte Größen: Breite und Höhe müssen Vielfache von 16 sein, die längste Seite ≤ 3840, Gesamtpixel ≤ 8.294.400. Überschreitungen werden vom Backend abgelehnt und mit 4xx zurückgegeben. | Seitenverhältnis | 1K Empfehlung | 2K Empfehlung | 4K Empfehlung | | ---------------- | ------------- | ------------- | ------------- | | 1:1 | `1024x1024` | `2048x2048` | `2880x2880` | | 4:3 | `1536x1024` | `2048x1536` | `3264x2448` | | 3:4 | `1024x1536` | `1536x2048` | `2448x3264` | | 16:9 | `1792x1024` | `2048x1152` | `3840x2160` | | 9:16 | `1024x1792` | `1152x2048` | `2160x3840` | > Sie können auch `size: "auto"` übergeben oder das `size`-Feld **weglassen**, dann wählt das Modell die Standardgröße selbst. > > Bei 1K-Ausgabe garantiert das Backend keine exakte Pixelgenauigkeit – Sie senden z.B. `1024x1024`, erhalten aber evtl. `1254x1254`, das Seitenverhältnis bleibt erhalten. Wenn Sie diesen Wert erneut als `size` übergeben, bleibt die Abrechnung unverändert. > > Ein 4K-Aufruf dauert in der Regel 4–8 Minuten, daher empfiehlt sich die Verwendung der weiter unten beschriebenen asynchronen `callback_url`. > **Zum Parameter `n`** > > `gpt-image-2` unterstützt derzeit **kein `n > 1`**: Dieser Parameter wird stillschweigend ignoriert. Egal ob `n=1` oder `n=10` gesendet wird, es wird immer nur 1 Bild pro Anfrage zurückgegeben und auch nur 1 Bild berechnet. Wenn Sie mehrere Kandidatenbilder benötigen, starten Sie bitte **mehrere parallele Anfragen** (empfohlen wird, unterschiedliche `prompt` oder `seed` zu verwenden, da sonst die Bilder sehr ähnlich sein können). Diese Einschränkung gilt auch für `gpt-image-1` / `gpt-image-1.5` sowie die `nano-banana` / `nano-banana-2` / `nano-banana-pro` Serie. `dall-e-2` ist aktuell das einzige Modell mit nativer Unterstützung für `n > 1`; `dall-e-3` unterstützt nur `n = 1`. Im Folgenden einige reale Beispiele, um die Fähigkeiten von `gpt-image-2` anschaulich zu demonstrieren. ### Szenario 1: Kinoreifes Porträt Im Prompt können Filmbegriffe (35mm Film, geringe Schärfentiefe, Neonlicht etc.) verwendet werden, um Atmosphäre und Textur präzise zu steuern. Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "gpt-image-2", "prompt": "A cinematic portrait of a young woman standing in a convenience store at night, illuminated by soft pink and cyan neon signs through the window. Shot on 35mm film, shallow depth of field, slight grain, melancholic mood.", "size": "1024x1536" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Rückgabe: ```json theme={null} { "success": true, "task_id": "ab58a5df-6f46-4874-bff6-93169e2849a3", "created": 1777048800, "data": [ { "revised_prompt": "A cinematic portrait of a young woman standing in a convenience store at night, illuminated by soft pink and cyan neon signs through the window. Shot on 35mm film, shallow depth of field, slight grain, melancholic mood.", "url": "https://platform.cdn.acedata.cloud/gpt-image/ab58a5df-6f46-4874-bff6-93169e2849a3_0.png" } ] } ``` Generiertes Bild:

### Szenario 2: Retro-Reiseposter (mit Textrendering) `gpt-image-2` zeigt stabile Leistung bei Layout und Schrift, ideal für Poster, Menüs, Grußkarten mit Text. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "A vintage travel poster of the Amalfi Coast, Italy. Stylized art-deco illustration of cliffside lemon-yellow houses cascading down to a turquoise sea, with a small white sailboat in the harbor. Bold typography at the top reads AMALFI and at the bottom ITALIA 1958. Limited color palette: cream, sea-blue, lemon yellow, terracotta. Slight paper-grain texture.", "size": "1024x1536" } ``` Bild zum `url`-Feld:

Das Modell reproduziert den Art-Deco-Stil präzise, die Titeltexte `AMALFI` und `ITALIA 1958` sind klar und korrekt gerendert. ### Szenario 3: Komplexe Komposition und Zählung Dieser Prompt testet die Befolgung strukturierter Anweisungen zu „Anzahl“ und „Position“. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "A wooden bookshelf consisting of three shelves: On the top shelf, there should be one book. On the second shelf, there should be three books. On the bottom shelf, there should be seven books. Soft warm lighting, photorealistic, cozy library atmosphere.", "size": "1024x1024" } ``` Generiertes Bild:

Die Anzahl der Bücher auf den drei Regalbrettern (1 / 3 / 7) stimmt exakt mit dem Prompt überein – eine Leistung, die in der `dall-e-3`-Ära schwer stabil zu erreichen war. ### Szenario 4: Illustrationsstil (Querformat) Durch Angabe von künstlerischen Medien und Stimmungswörtern kann das Modell zu stilisierten Illustrationen geführt werden. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "A soft, poetic children's book illustration of a small fox reading a book under a glowing mushroom in a moonlit forest. Watercolor and pencil texture, gentle pastel colors, dreamy atmosphere, hand-drawn feel.", "size": "1536x1024" } ``` Generierte Querformat-Illustration: ![](https://platform.cdn.acedata.cloud/gpt-image/6cd57e69-d237-4cc1-a666-759a93964a08_0.png) ### Asynchron und Callback Ein einzelner `gpt-image-2` Aufruf dauert typischerweise 60–90 Sekunden. Wenn Sie keine lange Verbindung offen halten möchten, können Sie die weiter unten beschriebene asynchrone `callback_url`-Methode verwenden. Der Aufrufprozess ist identisch zu anderen Modellen. ## Nano Banana Serie Modelle Die `nano-banana` Serie basiert auf dem Gemini-Bildgenerierungsmodell und ist über denselben `/openai/images/generations` Endpunkt angebunden. Sie müssen nur das Feld `model` auf eines der folgenden Modelle ändern. | Modell | Abrechnung (Credits / Anfrage) | Anwendungsbereich | | ----------------- | ------------------------------ | ---------------------------------------------------------------------------- | | `nano-banana` | 0.14 | Normale Bildgenerierung, schnellste und günstigste Option | | `nano-banana-2` | 0.28 | Deutlich verbesserte Qualität und Details | | `nano-banana-pro` | 0.35 | Flaggschiff-Modell der Serie, beste Komposition, Details und Textdarstellung | > **Wichtige Hinweise zu unterstützten Parametern** > > Nano Banana nutzt eine Adaptionsschicht für das OpenAI-Protokoll und unterstützt im Vergleich zu `gpt-image-*` nur folgende Parameter: `model`, `prompt`, `size`. > > * `size` wird intern gemäß folgender Tabelle auf `aspect_ratio` abgebildet, nicht gelistete Größen fallen auf `1:1` zurück: > * `1024x1024` / `512x512` / `256x256` → `1:1` > * `1792x1024` → `16:9` > * `1024x1792` → `9:16` > * Parameter wie `n`, `quality`, `style`, `response_format`, `background`, `output_format` werden nicht unterstützt und ignoriert. > * Die Rückgabe folgt dem OpenAI-Format (`data[].url`), `created` ist immer `0`, `b64_json` wird nicht zurückgegeben, `revised_prompt` entspricht immer dem Original-Prompt. ### Grundlegender Aufruf ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "nano-banana", "prompt": "a small red apple on a white table, photoreal", "size": "1024x1024" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Beispielantwort: ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6870b330-65c4-436c-bb80-819fdae7a7a4.png", "revised_prompt": "a small red apple on a white table, photoreal" } ] } ``` Das generierte Bild kann direkt über die zurückgegebene `url` aufgerufen werden:

### Upgrade zum Flaggschiff-Modell `nano-banana-pro` Ändern Sie einfach `model` auf `nano-banana-pro`, die übrigen Parameter bleiben gleich: ```python theme={null} payload = { "model": "nano-banana-pro", "prompt": "abstract painting", "size": "1024x1024" } ``` Beispielantwort: ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6227fcc9-3442-4aa3-a76c-4a4441a99649.png", "revised_prompt": "abstract painting" } ] } ```

### Asynchroner Callback Die `callback_url`-Methode für asynchrone Rückrufe funktioniert auch mit nano-banana, der Ablauf ist identisch zu anderen Modellen, siehe Abschnitt [Asynchroner Callback](#asynchroner-callback). ## Grundlegende Nutzung Sie können nun im Interface die entsprechenden Inhalte eingeben, wie im Bild gezeigt:

Beim ersten Gebrauch dieser Schnittstelle müssen mindestens drei Inhalte ausgefüllt werden: `authorization`, das Sie direkt aus der Dropdown-Liste auswählen können; `model`, das die OpenAI DALL-E Modellkategorie bestimmt (hier steht vor allem ein Modell zur Verfügung, Details siehe unsere Modellübersicht); und `prompt`, der Eingabetext für die Bildgenerierung. Auf der rechten Seite sehen Sie den generierten Beispielcode, den Sie direkt kopieren und ausführen können, oder Sie klicken auf den Button „Try“, um die Anfrage zu testen.

Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Nach dem Aufruf erhalten Sie folgende Antwort: ```json theme={null} { "created": 1721626477, "data": [ { "revised_prompt": "A delightful image showcasing a young sea otter, who is born brown, with wide charming eyes. It is delightfully lying on its back, paddling in the calm sea waters. Its dense, velvety fur appears wet and shimmering, capturing the essence of its habitat. The small creature curiously plays with a sea shell with its small paws, looking absolutely innocent and charming in its natural environment.", "url": "https://dalleprodsec.blob.core.windows.net/private/images/5d98aa7c-80c6-4523-b571-fc606ad455b9/generated_00.png?se=2024-07-23T05%3A34%3A48Z&sig=GAz%2Bi3%2BkHOQwAMhxcv22tBM%2FaexrxPgT9V0DbNrL4ik%3D&ske=2024-07-23T08%3A41%3A10Z&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96&sks=b&skt=2024-07-16T08%3A41%3A10Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02" } ] } ``` Die Antwort enthält mehrere Felder: * `created`: ID der Bildgenerierung, eindeutig für diese Aufgabe. * `data`: Enthält die Ergebnisse der Bildgenerierung. Im Feld `data` finden Sie die Details zum generierten Bild, insbesondere das `url`-Feld mit dem Bildlink, wie im Bild dargestellt.

## Bildqualitätsparameter `quality` Als nächstes wird erklärt, wie man detaillierte Parameter für die Bildgenerierung einstellt. Der Bildqualitätsparameter `quality` hat zwei Werte: `standard` für Standardbilder und `hd` für Bilder mit feineren Details und höherer Konsistenz. Hier wird `quality` auf `standard` gesetzt, wie im Bild gezeigt:

Auf der rechten Seite sehen Sie den generierten Beispielcode, den Sie direkt kopieren und ausführen oder mit „Try“ testen können.

Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter", "quality": "standard" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Antwort: ```json theme={null} { "created": 1721636023, "data": [ { "revised_prompt": "A cute baby sea otter is lying playfully on its back in the water, with its fur looking glossy and soft. One of its tiny paws is reaching out curiously, and it has an expression of pure joy and warmth on its face as it looks up to the sky. Its body is surrounded by bubbles from its playful twirling in the water. A gentle breeze is playing with its fur making it look more charming. The scene portrays the tranquility and charm of marine life.", "url": "https://dalleprodsec.blob.core.windows.net/private/images/a93ee5e7-3abd-4923-8d79-dc9ef126da46/generated_00.png?se=2024-07-23T08%3A13%3A55Z&sig=wTXGYvUOwUIkaB2CxjK9ww%2FHjS8OwYUWcYInXYKwcAM%3D&ske=2024-07-23T11%3A32%3A05Z&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96&sks=b&skt=2024-07-16T11%3A32%3A05Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02" } ] } ``` Das Ergebnis entspricht der Grundnutzung. Das Bild mit `quality` = `standard` sieht wie folgt aus:

Bei gleicher Vorgehensweise, aber mit `quality` = `hd`, erhalten Sie folgendes Bild:

`hd` erzeugt Bilder mit feineren Details und höherer Konsistenz als `standard`. ## Bildgrößenparameter `size` Sie können auch die Bildgröße einstellen. Hier wird die Größe auf `1024 * 1024` gesetzt, wie im Bild dargestellt:

Der rechts angezeigte Beispielcode kann kopiert oder mit „Try“ getestet werden.

Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter", "size": "1024x1024" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Antwort: ```json theme={null} { "created": 1721636652, "data": [ { "revised_prompt": "A delightful depiction of a baby sea otter. The small mammal is captured in its natural habitat in the ocean, floating on its back. It has thick brown fur that is sleek and wet from the sea water. Its eyes are closed as if it is enjoying a moment of deep relaxation. The water around it is calm, reflecting the peacefulness of the scene. The background should hint at a diverse marine ecosystem, with visible strands of kelp floating on the surface, suggesting the baby otter's preferred environment.", "url": "https://dalleprodsec.blob.core.windows.net/private/images/9d625ac6-fd2b-42a9-84a6-8c99eb357ccf/generated_00.png?se=2024-07-23T08%3A24%3A24Z&sig=AXtYXowEakGxfRp8LhC2DwqL%2F07LhEDW40oCP%2BdTO8s%3D&ske=2024-07-23T18%3A00%3A45Z&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96&sks=b&skt=2024-07-16T18%3A00%3A45Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02" } ] } ``` Das Ergebnis entspricht der Grundnutzung. Das Bild mit der Größe `1024 * 1024` sieht so aus:

Bei gleicher Vorgehensweise, aber mit der Größe `1792 * 1024`, erhalten Sie folgendes Bild: ![](https://cdn.acedata.cloud/4pilae.png) Die Bildgröße ist deutlich unterschiedlich. Weitere Größen sind möglich, Details finden Sie in unserer offiziellen Dokumentation. ## Bildstilparameter `style` Der Bildstilparameter `style` hat zwei Werte: `vivid` für lebendigere Bilder und `natural` für natürlichere Bilder. Hier wird `style` auf `vivid` gesetzt, wie im Bild gezeigt:

Der rechts angezeigte Beispielcode kann kopiert oder mit „Try“ getestet werden.

Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter", "style": "vivid" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Antwort: ```json theme={null} { "created": 1721637086, "data": [ { "revised_prompt": "A baby sea otter with soft, shiny fur and sparkling eyes floating playfully on calm ocean waters. This adorable creature is trippingly frolicking amidst small, gentle waves under a bright, clear, sunny sky. The tranquility of the sea contrasts subtly with the delightful energy of this young otter. The critter gamely clings to a tiny piece of driftwood, its small paws adorably enveloping the floating object.", "url": "https://dalleprodsec.blob.core.windows.net/private/images/6e48f701-7fd3-4356-839e-a2f6f0fe82d9/generated_00.png?se=2024-07-23T08%3A31%3A37Z&sig=4percxqTbUR1j3BQmkhvj%2FAhHzInKI%2FqiTo1MP69coI%3D&ske=2024-07-27T10%3A39%3A55Z&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96&sks=b&skt=2024-07-20T10%3A39%3A55Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02" } ] } ``` Das Ergebnis entspricht der Grundnutzung. Das Bild mit `style` = `vivid` sieht so aus:

Bei gleicher Vorgehensweise, aber mit `style` = `natural`, erhalten Sie folgendes Bild:

`vivid` erzeugt lebendigere und realistischere Bilder als `natural`. ## Bildlink-Formatparameter `response_format` Der letzte Parameter `response_format` hat zwei Werte: `b64_json` für Base64-kodierte Bilddaten und `url` für normale Bild-URLs, die direkt angezeigt werden können. Hier wird `response_format` auf `url` gesetzt, wie im Bild gezeigt:

Der rechts angezeigte Beispielcode kann kopiert oder mit „Try“ getestet werden.

Python Beispielcode: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter", "response_format": "url" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Antwort: ```json theme={null} { "created": 1721637575, "data": [ { "revised_prompt": "A charming depiction of a baby sea otter. The otter is seen resting serenely on its back amidst the gentle, blue ocean waves. The baby otter's fur is an endearing mix of soft greyish brown shades, glinting subtly in the muted sunlight. Its small paws are touching, lifted slightly towards the sky as if playing with an unseen object. Its round, expressive eyes are wide in curiosity, sparking with life and innocence. Use a realistic style to evoke the otter's natural habitat and its adorably fluffy exterior.", "url": "https://dalleprodsec.blob.core.windows.net/private/images/87792c5f-8b6d-412e-81dd-f1a1baa19bd2/generated_00.png?se=2024-07-23T08%3A39%3A47Z&sig=zzRAn30TqIKHdLVqZPUUuSJdjCYpoJdaGU6BeoA76Jo%3D&ske=2024-07-23T13%3A32%3A13Z&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96&sks=b&skt=2024-07-16T13%3A32%3A13Z&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d&skv=2020-10-02&sp=r&spr=https&sr=b&sv=2020-10-02" } ] } ``` Das Ergebnis entspricht der Grundnutzung. Der Bildlink mit `response_format` = `url` ist [Bild URL](https://dalleprodsec.blob.core.windows.net/private/images/87792c5f-8b6d-412e-81dd-f1a1baa19bd2/generated_00.png?se=2024-07-23T08%3A39%3A47Z\&sig=zzRAn30TqIKHdLVqZPUUuSJdjCYpoJdaGU6BeoA76Jo%3D\&ske=2024-07-23T13%3A32%3A13Z\&skoid=e52d5ed7-0657-4f62-bc12-7e5dbb260a96\&sks=b\&skt=2024-07-16T13%3A32%3A13Z\&sktid=33e01921-4d64-4f8c-a055-5bdaffd5e33d\&skv=2020-10-02\&sp=r\&spr=https\&sr=b\&sv=2020-10-02) und kann direkt aufgerufen werden. Das Bild sieht so aus:

Bei gleicher Vorgehensweise, aber mit `response_format` = `b64_json`, erhalten Sie Base64-kodierte Bilddaten, z.B.: ```json theme={null} { "created": 1721638071, "data": [ { "b64_json": "iVBORw0..............v//AQEAAP4AAAD+AAADAQAAAwEEA/4D//8Q/Pbw64mKbVTFoQAAAABJRU5ErkJggg==", "revised_prompt": "A charming image of a young baby sea otter. The otter is gently floating on a calm blue sea, basking in the warm, golden rays of sunlight streaming down from a clear sky above. The otter's fur is a rich chocolate brown, and it looks incredibly soft and fluffy. The otter's eyes are bright and expressive, filled with childlike curiosity and joy. It has small, pricked ears and a button-like nose which adds to its overall cuteness. In the sea around it, twinkling droplets of water can be seen, pepped up by the sunlight, the sight is certainly a delightful one." } ] } ``` ## Asynchroner Callback Da die Bildgenerierung mit der OpenAI Images Generations API relativ lange dauern kann, würde eine lange Wartezeit auf die API-Antwort die HTTP-Verbindung offen halten und Systemressourcen binden. Deshalb unterstützt die API auch asynchrone Callbacks. Der Ablauf ist: Der Client sendet bei der Anfrage zusätzlich ein Feld `callback_url`. Die API antwortet sofort mit einem Ergebnis, das ein `task_id` enthält, welches die aktuelle Aufgabe identifiziert. Nach Abschluss der Bildgenerierung sendet die API die Ergebnisse per POST-JSON an die angegebene `callback_url`, inklusive des `task_id`, sodass die Aufgabe eindeutig zugeordnet werden kann. Im Folgenden ein Beispiel zur Veranschaulichung. Zunächst ist der Webhook ein HTTP-Dienst, der Anfragen empfangen kann. Entwickler sollten hier ihre eigene HTTP-Server-URL verwenden. Für die Demo nutzen wir die öffentliche Webhook-Seite [https://webhook.site/](https://webhook.site/), die eine Webhook-URL bereitstellt, wie im Bild gezeigt: ![](https://cdn.acedata.cloud/cjjfly.png) Diese URL kopieren Sie und verwenden sie als Webhook. Beispiel: `https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab`. Dann setzen Sie das Feld `callback_url` auf diese Webhook-URL und senden die Anfrage, z.B.: ```python theme={null} import requests url = "https://api.acedata.cloud/openai/images/generations" headers = { "accept": "application/json", "authorization": "Bearer {token}", "content-type": "application/json" } payload = { "model": "dall-e-3", "prompt": "A cute baby sea otter", "callback_url": "https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Nach dem Aufruf erhalten Sie sofort eine Antwort wie: ```json theme={null} { "task_id": "6a97bf49-df50-4129-9e46-119aa9fca73c" } ``` Nach kurzer Wartezeit sehen Sie auf der Webhook-Seite das Ergebnis der Bildgenerierung, z.B.: ```json theme={null} { "success": true, "task_id": "6a97bf49-df50-4129-9e46-119aa9fca73c", "trace_id": "9b4b1ff3-90f2-470f-b082-1061ec2948cc", "data": { "created": 1721626477, "data": [ { "revised_prompt": "A delightful image showcasing a young sea otter...", "url": "https://dalleprodsec.blob.core.windows.net/private/images/..." } ] } } ``` Das Ergebnis enthält ein `task_id`-Feld und ein `data`-Feld mit denselben Bildgenerierungsergebnissen wie bei synchronem Aufruf. Über `task_id` können Sie die Aufgabe eindeutig zuordnen. ## Fehlerbehandlung Wenn bei der API-Nutzung Fehler auftreten, liefert die API entsprechende Fehlercodes und Meldungen, z.B.: * `400 token_mismatched`: Ungültige Anfrage, evtl. fehlende oder falsche Parameter. * `400 api_not_implemented`: Ungültige Anfrage, evtl. fehlende oder falsche Parameter. * `401 invalid_token`: Nicht autorisiert, ungültiger oder fehlender Token. * `429 too_many_requests`: Zu viele Anfragen, Limit überschritten. * `500 api_error`: Interner Serverfehler. ### Beispiel für Fehlerantwort ```json theme={null} { "success": false, "error": { "code": "api_error", "message": "fetch failed" }, "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89" } ``` ## Fazit Mit diesem Dokument haben Sie gelernt, wie Sie die OpenAI Images Generations API nutzen, um die offiziellen OpenAI DALL-E Bildgenerierungsfunktionen einfach zu verwenden. Wir hoffen, dass dieses Dokument Ihnen bei der Integration und Nutzung der API hilft. Bei Fragen wenden Sie sich bitte jederzeit an unser technisches Support-Team.