> ## Documentation Index > Fetch the complete documentation index at: https://docs.acedata.cloud/llms.txt > Use this file to discover all available pages before exploring further. # OpenAI Images Generations API Demande et Utilisation > OpenAI generation API guide - Ace Data Cloud L'API OpenAI Images Generations prend actuellement en charge plusieurs modèles de génération d'images, y compris le classique `dall-e-3`, le `gpt-image-1` avec une capacité de rendu de texte plus forte, la dernière génération de **`gpt-image-2`**, ainsi que la série de modèles **`nano-banana` / `nano-banana-2-lite` / `nano-banana-2` / `nano-banana-pro`** accessibles via la même interface. Tous peuvent générer des images de haute qualité à partir de descriptions textuelles. Ce document présente principalement le processus d'utilisation de l'API OpenAI Images Generations, qui nous permet d'utiliser facilement les fonctionnalités de génération d'images de la série OpenAI. ## Processus de Demande Pour utiliser l'API OpenAI Images Generations, commencez par obtenir votre API Token sur le [tableau de bord Ace Data Cloud](https://platform.acedata.cloud/console/applications) pour le garder en réserve. ![](https://cdn.acedata.cloud/5hmkdg.jpg) Si vous n'êtes pas encore connecté ou inscrit, vous serez automatiquement redirigé vers la page de connexion pour vous inviter à vous inscrire et à vous connecter, après quoi vous serez automatiquement renvoyé à la page actuelle. **Un seul API Token suffit pour appeler tous les services de la plateforme, sans avoir besoin de demander séparément pour chaque service.** La première demande vous donnera un quota gratuit pour une expérience sans frais ; lorsque le quota est insuffisant, vous pouvez recharger le solde général dans le [tableau de bord](https://platform.acedata.cloud/console/coin). > 📘 Documentation complète : [OpenAI Images Generations API →](https://platform.acedata.cloud/documents/openai-images-generations) ## Modèle GPT-Image-2 `gpt-image-2` est le nouveau modèle de génération d'images lancé par OpenAI, qui présente des améliorations significatives par rapport à `dall-e-3` et `gpt-image-1` dans les domaines suivants : * **Capacité de suivi des instructions améliorée** : capable de comprendre avec précision des instructions structurées complexes concernant la composition, le comptage, les relations de position, etc. * **Rendu de texte plus clair** : dans des scénarios tels que des affiches, des menus, des infographies, des logos, l'anglais et les chiffres ne présentent presque jamais de désordre. * **Expression de style plus riche** : prend en charge nativement divers styles tels que les portraits cinématographiques, les affiches rétro, les illustrations pour enfants, la photographie de produits, les infographies, etc. * **Support natif pour plusieurs rapports + haute résolution** : couvre 5 rapports (1:1, 4:3, 3:4, 16:9, 9:16) avec 3 niveaux de résolution (1K / 2K / 4K). La méthode d'appel est identique à celle des autres modèles, il suffit de définir le champ `model` sur `gpt-image-2`. L'URL dans le résultat retourné est un lien d'image hébergé de manière permanente sur `platform.cdn.acedata.cloud`, que vous pouvez ouvrir directement dans un navigateur ou intégrer dans une page web. ### Intermédiaire Officiel / Variante Inversée (`:official` / `:reverse`) `gpt-image-2` utilise par défaut la ligne inversée. Vous pouvez explicitement choisir la ligne via le suffixe du nom du modèle : * **`gpt-image-2:official`** : ligne de transfert officielle. Prend en charge `n > 1` (retourne plusieurs images à la fois) et des résolutions réelles de 2K / 4K, **facturé par image, au prix de 2 fois le tarif par défaut de `gpt-image-2`**. Actuellement, cela n'est fourni que par le canal openai-hk, et si la ligne n'est pas disponible, une erreur sera directement retournée, sans rétrogradation vers la ligne inversée. * **`gpt-image-2:reverse`** : équivalent complet à `gpt-image-2` par défaut (ligne inversée), utilisé pour déclarer explicitement l'utilisation de la ligne inversée, sans changement de prix. > Les restrictions concernant le paramètre “n” ci-dessous ne s'appliquent qu'à la ligne par défaut / inversée ; `gpt-image-2:official` prend en charge `n > 1` et est facturé par image. ### Valeurs supportées pour `size` `gpt-image-2` vérifie uniquement le format de `size`, tant qu'il n'est pas `auto` ou une chaîne vide, il doit correspondre à `WIDTHxHEIGHT` (par exemple `1024x1024`, `2048x1152`, `800x600`) ; toute autre forme retournera 400. **Toutes les tailles (1K / 2K / 4K / personnalisées) sont facturées uniformément par image, sans augmentation de prix selon la taille.** Les contraintes strictes sur les tailles personnalisées en amont : largeur et hauteur doivent être des multiples de 16, longueur maximale ≤ 3840, nombre total de pixels ≤ 8 294 400. Tout dépassement sera refusé par l'amont et retournera un 4xx. | Rapport | 1K Recommandé | 2K Recommandé | 4K Recommandé | | ------- | ------------- | ------------- | ------------- | | 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` | > Vous pouvez également transmettre `size: "auto"` ou **omettre le champ `size`**, auquel cas le modèle choisira la taille par défaut. > En dessous de 1K, la sortie en amont ne garantit pas un alignement strict des pixels - vous pouvez transmettre `1024x1024` et obtenir `1254x1254`, le rapport restant constant. Si vous le retransmettez en tant que `size`, la facturation ne changera pas. > Un appel unique en 4K nécessite généralement 4 à 8 minutes, il est conseillé de l'utiliser avec le `callback_url` mentionné ci-dessous pour un rappel asynchrone. > **Concernant le paramètre `n`** > `gpt-image-2` **ne prend actuellement pas en charge `n > 1`** : ce paramètre sera silencieusement ignoré, que vous transmettiez `n=1` ou `n=10`, une seule image sera retournée par demande, et la facturation ne sera que pour une image. Si vous avez besoin d'obtenir plusieurs images candidates à la fois, veuillez **initier plusieurs demandes en parallèle** (il est conseillé de transmettre simultanément des `prompt` différents ou des `seed` différents, sinon les images obtenues pourraient être très similaires). Cette restriction s'applique également à `gpt-image-1` / `gpt-image-1.5`, ainsi qu'à la série `nano-banana` / `nano-banana-2-lite` / `nano-banana-2` / `nano-banana-pro`. `dall-e-2` est actuellement le seul modèle à prendre en charge nativement `n > 1` ; `dall-e-3` ne prend en charge que `n = 1`. Voici quelques exemples réels sous différents angles pour ressentir intuitivement la capacité de `gpt-image-2`. ### Scène 1 : Portrait Cinématographique Des termes cinématographiques (film 35mm, faible profondeur de champ, lumière néon, etc.) peuvent être utilisés dans les mots-clés pour contrôler précisément l'ambiance et la texture. Exemple de code d'appel Python : ```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": "Un portrait cinématographique d'une jeune femme debout dans un magasin de proximité la nuit, illuminée par des enseignes néon roses et cyan à travers la fenêtre. Prise sur film 35 mm, faible profondeur de champ, léger grain, ambiance mélancolique.", "size": "1024x1536" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Le résultat est le suivant : ```json theme={null} { "success": true, "task_id": "ab58a5df-6f46-4874-bff6-93169e2849a3", "created": 1777048800, "data": [ { "revised_prompt": "Un portrait cinématographique d'une jeune femme debout dans un magasin de proximité la nuit, illuminée par des enseignes néon roses et cyan à travers la fenêtre. Prise sur film 35 mm, faible profondeur de champ, léger grain, ambiance mélancolique.", "url": "https://platform.cdn.acedata.cloud/gpt-image/ab58a5df-6f46-4874-bff6-93169e2849a3_0.png" } ] } ``` L'image générée est comme suit :

### Scène 2 : Affiche de voyage rétro (avec rendu de texte) `gpt-image-2` se distingue par sa stabilité en typographie et rendu de police, ce qui le rend idéal pour générer des affiches, des menus, des cartes de vœux et d'autres conceptions contenant du texte. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Une affiche de voyage vintage de la Côte Amalfitaine, en Italie. Illustration art déco stylisée de maisons jaunes citron en cascade sur une mer turquoise, avec un petit voilier blanc dans le port. La typographie audacieuse en haut indique AMALFI et en bas ITALIA 1958. Palette de couleurs limitée : crème, bleu de mer, jaune citron, terre cuite. Légère texture de grain de papier.", "size": "1024x1536" } ``` L'image correspondant au champ `url` dans le résultat est comme suit :

On peut voir que le modèle a non seulement restitué avec précision le style visuel de l'affiche Art Déco, mais que le texte du titre `AMALFI` et `ITALIA 1958` a également été rendu de manière claire et correcte. ### Scène 3 : Composition complexe et comptage Le prompt suivant est utilisé pour tester la capacité du modèle à suivre des instructions structurées telles que "quantité" et "position". ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Une étagère en bois composée de trois étagères : Sur la première étagère, il doit y avoir un livre. Sur la deuxième étagère, il doit y avoir trois livres. Sur la troisième étagère, il doit y avoir sept livres. Éclairage doux et chaud, photoréaliste, atmosphère de bibliothèque confortable.", "size": "1024x1024" } ``` L'image générée est comme suit :

On peut voir que le nombre de livres sur les trois étagères (1 / 3 / 7) correspond exactement au prompt, ce qui était difficile à réaliser de manière stable à l'époque de `dall-e-3`. ### Scène 4 : Style d'illustration (paysage) En spécifiant le médium artistique et des mots-clés d'émotion, on peut guider le modèle à produire des illustrations stylisées. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Une illustration douce et poétique d'un livre pour enfants d'un petit renard lisant un livre sous un champignon lumineux dans une forêt au clair de lune. Texture aquarelle et crayon, couleurs pastel douces, atmosphère rêveuse, sensation de dessin à la main.", "size": "1536x1024" } ``` L'illustration paysage générée est comme suit : ![](https://platform.cdn.acedata.cloud/gpt-image/6cd57e69-d237-4cc1-a666-759a93964a08_0.png) ### Asynchrone et rappel `gpt-image-2` nécessite généralement 60 à 90 secondes pour un appel unique. Si vous ne souhaitez pas maintenir une connexion longue, vous pouvez utiliser le mécanisme de rappel asynchrone `callback_url` décrit plus loin dans cet article, le processus d'appel étant identique à celui des autres modèles. ## Modèles de la série Nano Banana La série `nano-banana` est un modèle de génération d'images basé sur Gemini, qui est intégré via la même interface `/openai/images/generations`, sans avoir besoin de changer d'endpoint, il suffit de modifier `model` pour l'un des modèles du tableau ci-dessous. | Modèle | Coût (Crédits / appel) | Scénarios d'utilisation | | -------------------- | ---------------------- | ------------------------------------------------------------------------------ | | `nano-banana` | 0.14 | Génération d'images ordinaires, la plus rapide et la moins coûteuse | | `nano-banana-2-lite` | 0.14 | Modèle d'image léger Gemini 3.1, prend uniquement en charge 1K, faible latence | | `nano-banana-2` | 0.28 | Qualité et détails nettement améliorés | | `nano-banana-pro` | 0.35 | Le modèle phare de la série, meilleur en composition, détails et texte | > **Important : Plage de support des paramètres** > Nano Banana est intégré via une couche d'adaptation au protocole OpenAI, et par rapport à `gpt-image-*`, ne prend en charge que les paramètres suivants : `model`, `prompt`, `size`. > > * `size` sera mappé à l'`aspect_ratio` interne selon le tableau ci-dessous, les tailles non listées seront dégradées à `1:1` : > * `1024x1024` / `512x512` / `256x256` → `1:1` > * `1792x1024` → `16:9` > * `1024x1792` → `9:16` > * Les paramètres `n`, `quality`, `style`, `response_format`, `background`, `output_format`, etc. ne sont pas pris en charge ; même s'ils sont remplis, ils seront ignorés. > * La structure de retour suit le format OpenAI (`data[].url`), mais `created` est fixé à `0`, et `b64_json` ne sera pas retourné, `revised_prompt` sera toujours égal au `prompt` original. ### Appel de base ```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": "une petite pomme rouge sur une table blanche, photoréaliste", "size": "1024x1024" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Le résultat est le suivant : ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6870b330-65c4-436c-bb80-819fdae7a7a4.png", "revised_prompt": "une petite pomme rouge sur une table blanche, photoréaliste" } ] } ``` Les images générées peuvent être directement accessibles via le champ `url` retourné :

### Mise à niveau vers le modèle phare `nano-banana-pro` Il suffit de changer `model` en `nano-banana-pro`, les autres paramètres restant identiques : ```python theme={null} payload = { "model": "nano-banana-pro", "prompt": "peinture abstraite", "size": "1024x1024" } ``` Exemple de retour : ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6227fcc9-3442-4aa3-a76c-4a4441a99649.png", "revised_prompt": "peinture abstraite" } ] } ```

### Callback asynchrone Le mécanisme de callback asynchrone `callback_url` est également valable pour nano-banana, le processus d'appel étant identique à celui des autres modèles, voir la section [Callback asynchrone](#callback-asynchrone) ci-dessous. ## Utilisation de base Vous pouvez maintenant remplir le contenu correspondant sur l'interface, comme illustré :

Lors de la première utilisation de cette interface, nous devons remplir au moins trois éléments, l'un étant `authorization`, que vous pouvez sélectionner directement dans la liste déroulante. L'autre paramètre est `model`, qui correspond à la catégorie de modèle que nous choisissons d'utiliser sur le site officiel d'OpenAI DALL-E, ici nous avons principalement 1 type de modèle, les détails peuvent être consultés dans les modèles que nous fournissons. Le dernier paramètre est `prompt`, qui est le mot clé que nous entrons pour générer l'image. Vous pouvez également remarquer qu'il y a un code d'appel correspondant généré à droite, que vous pouvez copier et exécuter directement, ou cliquer sur le bouton « Essayer » pour tester.

Exemple de code d'appel en Python : ```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": "Un mignon bébé loutre de mer" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Après l'appel, nous constatons que le résultat retourné est le suivant : ```json theme={null} { "created": 1721626477, "data": [ { "revised_prompt": "Une image délicieuse montrant une jeune loutre de mer, qui est née brune, avec de grands yeux charmants. Elle est délicieusement allongée sur le dos, pagayant dans les eaux calmes de la mer. Son pelage dense et velouté semble humide et scintillant, capturant l'essence de son habitat. La petite créature joue curieusement avec un coquillage avec ses petites pattes, ayant l'air absolument innocente et charmante dans son environnement naturel.", "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" } ] } ``` Le résultat retourné contient plusieurs champs, décrits comme suit : * `created`, l'ID de la génération de cette image, utilisé pour identifier de manière unique cette tâche. * `data`, contenant les informations sur le résultat de la génération d'image. Le champ `data` contient les informations spécifiques sur l'image générée par le modèle, où `url` est le lien détaillé de l'image générée, comme illustré ci-dessous.

## Paramètre de qualité d'image `quality` Nous allons maintenant expliquer comment définir certains paramètres détaillés des résultats de génération d'image, où le paramètre de qualité d'image `quality` contient deux options, la première `standard` indique que l'image générée est standard, l'autre `hd` indique que l'image créée a des détails plus fins et une plus grande cohérence. Voici comment définir le paramètre de qualité d'image sur `standard`, les réglages sont illustrés ci-dessous :

Vous pouvez également remarquer qu'il y a un code d'appel correspondant généré à droite, que vous pouvez copier et exécuter directement, ou cliquer sur le bouton « Essayer » pour tester.

Exemple de code d'appel en Python : ```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": "Un mignon bébé loutre de mer", "quality": "standard" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Après l'appel, nous constatons que le résultat retourné est le suivant : ```json theme={null} { "created": 1721636023, "data": [ { "revised_prompt": "Un mignon bébé loutre de mer est allongé en jouant sur le dos dans l'eau, avec son pelage brillant et doux. Une de ses petites pattes s'étend curieusement, et il a une expression de pure joie et de chaleur sur son visage en regardant le ciel. Son corps est entouré de bulles provenant de ses tourbillons ludiques dans l'eau. Une douce brise joue avec son pelage, le rendant encore plus charmant. La scène dépeint la tranquillité et le charme de la vie marine.", "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" } ] } ``` Le résultat retourné est cohérent avec le contenu de l'utilisation de base, et vous pouvez voir que l'image générée avec le paramètre de qualité `standard` est illustrée ci-dessous :

与上述相同操作，仅需将图片质量参数设置为 `hd` ，可以得到如下图所示的图片：

可以看到 `hd` 比 `standard` 生成的图片具有更精细的细节和更大的一致性。 ## 图片大小尺寸参数 `size` 我们还可以设置生成图片的尺寸大小，我们可以进行下面的设置。 下面设置图片的尺寸大小为 `1024 * 1024` ，具体设置如下图：

同时您可以注意到右侧有对应的调用代码生成，您可以复制代码直接运行，也可以直接点击「Try」按钮进行测试。

Python 样例调用代码： ```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) ``` 调用之后，我们发现返回结果如下： ```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" } ] } ``` 返回的结果与基本使用的内容一致，可以看到图片的尺寸大小为 `1024 * 1024` 的生成图片如下图所示：

与上述相同操作，仅需将图片的尺寸大小为 `1792 * 1024` ，可以得到如下图所示的图片： ![](https://cdn.acedata.cloud/4pilae.png) 可以看到图片的尺寸大小很明显不一样，另外还可以设置更多尺寸大小，详情信息参考我们官网文档。 ## 图片风格参数 `style` 图片风格参数 `style` 包含俩个参数，第一种 `vivid` 表示生成的图片是更加生动的，另一种 `natural` 表示生成的图片更加的自然一点。 下面设置图片风格参数为 `vivid` ，具体设置如下图：

同时您可以注意到右侧有对应的调用代码生成，您可以复制代码直接运行，也可以直接点击「Try」按钮进行测试。

Python 样例调用代码： ```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) ``` 调用之后，我们发现返回结果如下： ```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" } ] } ``` 返回的结果与基本使用的内容一致，可以看到图片风格参数为 `vivid` 的生成图片如下图所示：

与上述相同操作，仅需将图片风格参数为 `natural` ，可以得到如下图所示的图片：

可以看到 `vivid` 比 `natural` 生成的图片具有更加生动逼真。 ## 图片链接的格式参数 `response_format` 最后一个图片链接的格式参数 `response_format` 也有俩种，第一种 `b64_json` 是对图片链接进行 Base64 编码，另一种 `url` 就是普通的图片链接，可以直接查看图片。 下面设置图片链接的格式参数为 `url` ，具体设置如下图：

同时您可以注意到右侧有对应的调用代码生成，您可以复制代码直接运行，也可以直接点击「Try」按钮进行测试。

Python 样例调用代码： ```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": "Un mignon bébé loutre de mer", "response_format": "url" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Après l'appel, nous avons constaté que le résultat retourné est le suivant : ```json theme={null} { "created": 1721637575, "data": [ { "revised_prompt": "Une charmante représentation d'un bébé loutre de mer. La loutre est vue se reposant sereinement sur son dos au milieu des douces vagues bleues de l'océan. Le pelage du bébé loutre est un mélange attendrissant de nuances de brun grisâtre doux, scintillant subtilement sous la lumière tamisée du soleil. Ses petites pattes touchent, légèrement levées vers le ciel comme si elles jouaient avec un objet invisible. Ses yeux ronds et expressifs sont grands de curiosité, pétillants de vie et d'innocence. Utilisez un style réaliste pour évoquer l'habitat naturel de la loutre et son extérieur adorablement duveteux.", "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" } ] } ``` Le résultat retourné est cohérent avec le contenu de base utilisé, on peut voir que le lien de l'image avec le paramètre de format `url` pour l'image générée est [URL de l'image](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) c'est accessible directement, le contenu de l'image est illustré ci-dessous :

Avec la même opération ci-dessus, il suffit de définir le paramètre de format de lien d'image comme `b64_json`, pour obtenir le lien de l'image encodé en Base64, le résultat spécifique est illustré ci-dessous : ```json theme={null} { "created": 1721638071, "data": [ { "b64_json": "iVBORw0..............v//AQEAAP4AAAD+AAADAQAAAwEEA/4D//8Q/Pbw64mKbVTFoQAAAABJRU5ErkJggg==", "revised_prompt": "Une image charmante d'un jeune bébé loutre de mer. La loutre flotte doucement sur une mer bleue calme, se prélassant sous les chauds rayons dorés du soleil qui descendent d'un ciel clair au-dessus. Le pelage de la loutre est d'un riche brun chocolat, et il semble incroyablement doux et duveteux. Les yeux de la loutre sont brillants et expressifs, remplis de curiosité enfantine et de joie. Elle a de petites oreilles dressées et un nez en forme de bouton qui ajoute à son charme global. Dans la mer autour d'elle, des gouttelettes d'eau scintillantes peuvent être vues, rehaussées par la lumière du soleil, la vue est certainement délicieuse." } ] } ``` ## Rappel asynchrone Étant donné que le temps de génération d'images de l'API OpenAI Images Generations peut être relativement long, si l'API ne répond pas pendant une longue période, la requête HTTP maintiendra la connexion, entraînant une consommation supplémentaire de ressources système, donc cette API propose également un support de rappel asynchrone. Le processus global est le suivant : lorsque le client initie une requête, il spécifie en plus un champ `callback_url`, après que le client ait lancé la requête API, l'API renverra immédiatement un résultat, contenant un champ d'information `task_id`, représentant l'ID de la tâche actuelle. Lorsque la tâche est terminée, le résultat de l'image générée sera envoyé au `callback_url` spécifié par le client sous forme de POST JSON, qui inclut également le champ `task_id`, permettant ainsi de lier le résultat de la tâche par ID. Voyons comment procéder avec un exemple. Tout d'abord, le rappel Webhook est un service capable de recevoir des requêtes HTTP, les développeurs devraient le remplacer par l'URL de leur propre serveur HTTP. Ici, pour des raisons de démonstration, nous utilisons un site Web de modèle Webhook public [https://webhook.site/](https://webhook.site/), en ouvrant ce site, vous obtiendrez une URL Webhook, comme illustré ci-dessous : ![](https://cdn.acedata.cloud/cjjfly.png) Copiez cette URL, vous pouvez l'utiliser comme Webhook, l'exemple ici est `https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab`. Ensuite, nous pouvons définir le champ `callback_url` sur l'URL Webhook ci-dessus, tout en remplissant les paramètres correspondants, comme le montre le code suivant : ```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": "Un mignon bébé loutre de mer", "callback_url": "https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` En cliquant sur exécuter, vous pouvez constater que vous obtiendrez immédiatement un résultat, comme suit : ```json theme={null} { "task_id": "6a97bf49-df50-4129-9e46-119aa9fca73c" } ``` Après un moment, nous pouvons observer le résultat de l'image générée sur l'URL Webhook, le contenu est le suivant : ```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": "Une image délicieuse montrant un jeune loutre de mer...", "url": "https://dalleprodsec.blob.core.windows.net/private/images/..." } ] } } ``` On peut voir que le résultat contient un champ `task_id`, le champ `data` contient les mêmes résultats de génération d'images que l'appel synchrone, et grâce au champ `task_id`, il est possible de lier la tâche. ## Gestion des erreurs Lors de l'appel de l'API, si une erreur se produit, l'API renverra le code d'erreur et les informations correspondantes. Par exemple : * `400 token_mismatched` : Mauvaise demande, probablement en raison de paramètres manquants ou invalides. * `400 api_not_implemented` : Mauvaise demande, probablement en raison de paramètres manquants ou invalides. * `401 invalid_token` : Non autorisé, jeton d'autorisation invalide ou manquant. * `429 too_many_requests` : Trop de demandes, vous avez dépassé la limite de taux. * `500 api_error` : Erreur interne du serveur, quelque chose s'est mal passé sur le serveur. ### Exemples de réponse d'erreur ```json theme={null} { "success": false, "error": { "code": "api_error", "message": "échec de la récupération" }, "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89" } ``` ## Conclusion Grâce à ce document, vous avez compris comment utiliser l'API de génération d'images OpenAI pour utiliser facilement la fonction de génération d'images officielle d'OpenAI DALL-E. Nous espérons que ce document vous aidera à mieux intégrer et utiliser cette API. Si vous avez des questions, n'hésitez pas à contacter notre équipe de support technique.