> ## 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 Richiesta e Utilizzo > OpenAI generation API guide - Ace Data Cloud OpenAI Images Generations API attualmente supporta diversi modelli di generazione di immagini, tra cui il classico `dall-e-3`, la capacità di rendering testuale più avanzata di `gpt-image-1`, l'ultima generazione di **`gpt-image-2`**, e la serie di modelli **`nano-banana` / `nano-banana-2-lite` / `nano-banana-2` / `nano-banana-pro`** accessibili tramite la stessa interfaccia. Tutti questi modelli possono generare immagini di alta qualità in base a descrizioni testuali. Questo documento descrive principalmente il processo di utilizzo dell'API OpenAI Images Generations, che ci consente di utilizzare facilmente le funzionalità di generazione di immagini della serie OpenAI. ## Processo di Richiesta Per utilizzare l'API OpenAI Images Generations, prima di tutto visita il [Pannello di Controllo di Ace Data Cloud](https://platform.acedata.cloud/console/applications) per ottenere il tuo API Token, da conservare per uso futuro. ![](https://cdn.acedata.cloud/5hmkdg.jpg) Se non hai ancora effettuato il login o la registrazione, verrai automaticamente reindirizzato alla pagina di login che ti invita a registrarti e accedere; una volta completato, verrai riportato automaticamente alla pagina corrente. **Un API Token è sufficiente per accedere a tutti i servizi della piattaforma, senza necessità di richiederne uno separato per ogni servizio.** La prima richiesta offre un credito gratuito, permettendo di provare senza costi; quando il credito è insufficiente, puoi ricaricare il saldo generale nel [pannello di controllo](https://platform.acedata.cloud/console/coin). > 📘 Documentazione Completa: [OpenAI Images Generations API →](https://platform.acedata.cloud/documents/openai-images-generations) ## Modello GPT-Image-2 `gpt-image-2` è il nuovo modello di generazione di immagini lanciato da OpenAI, che presenta miglioramenti significativi rispetto a `dall-e-3` e `gpt-image-1` nei seguenti aspetti: * **Maggiore capacità di seguire istruzioni**: in grado di comprendere con precisione istruzioni strutturate complesse riguardanti composizione, conteggio, relazioni spaziali, ecc. * **Rendering testuale più chiaro**: in scenari come poster, menu, infografiche, loghi, l'inglese e i numeri non presentano quasi mai confusione. * **Espressione stilistica più ricca**: supporta nativamente vari stili come ritratti cinematografici, poster vintage, illustrazioni per bambini, fotografia di prodotto, infografiche, ecc. * **Supporto nativo per più proporzioni + alta risoluzione**: copre 5 proporzioni (1:1, 4:3, 3:4, 16:9, 9:16) con 3 livelli di risoluzione (1K / 2K / 4K). Il metodo di chiamata è identico a quello degli altri modelli, basta impostare il campo `model` su `gpt-image-2`. L'`url` nel risultato restituito è un link a un'immagine ospitata permanentemente su `platform.cdn.acedata.cloud`, che può essere aperto direttamente nel browser o incorporato in una pagina web. ### Percorso Ufficiale / Variante Inversa (`:official` / `:reverse`) `gpt-image-2` utilizza per impostazione predefinita il percorso inverso. È possibile scegliere esplicitamente il percorso tramite il suffisso del nome del modello: * **`gpt-image-2:official`**: percorso ufficiale. Supporta `n > 1` (restituzione di più immagini in una volta) e risoluzioni reali 2K / 4K, **con addebito per ogni immagine, il prezzo è il doppio di quello predefinito di `gpt-image-2`**. Attualmente fornito solo dal canale openai-hk; se il percorso non è disponibile, restituisce direttamente un errore, senza degradare al percorso inverso. * **`gpt-image-2:reverse`**: equivalente al `gpt-image-2` predefinito (percorso inverso), utilizzato per dichiarare esplicitamente l'uso del percorso inverso, senza variazione di prezzo. > Le limitazioni relative al parametro “n” di seguito si applicano solo ai percorsi predefiniti / inversi; `gpt-image-2:official` supporta `n > 1` e addebita per immagine. ### Valori Supportati per `size` `gpt-image-2` controlla solo il formato di `size`, purché non sia `auto` o una stringa vuota, deve corrispondere a `WIDTHxHEIGHT` (ad esempio `1024x1024`, `2048x1152`, `800x600`); qualsiasi altra forma restituirà 400. **Tutte le dimensioni (1K / 2K / 4K / personalizzate) vengono addebitate uniformemente per immagine, senza sovrapprezzo per dimensione.** Vincoli rigidi per dimensioni personalizzate: larghezza e altezza devono essere multipli di 16, lunghezza massima ≤ 3840, numero totale di pixel ≤ 8.294.400. Superare questi limiti comporterà un rifiuto da parte del sistema con un errore 4xx. | Proporzione | 1K Raccomandato | 2K Raccomandato | 4K Raccomandato | | ----------- | --------------- | --------------- | --------------- | | 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` | > Puoi anche passare `size: "auto"` o **omettendo il campo `size`**, in questo caso il modello sceglierà automaticamente la dimensione predefinita. > Nella fascia 1K, l'output non garantisce un allineamento rigoroso dei pixel: se invii `1024x1024`, potresti ricevere `1254x1254`, mantenendo la proporzione. Se lo reinserisci come `size`, l'addebito rimane invariato. > Una chiamata a 4K richiede solitamente 4–8 minuti, si consiglia di utilizzare il `callback_url` per il callback asincrono. > **Riguardo al parametro `n`** > `gpt-image-2` attualmente **non supporta `n > 1`**: questo parametro verrà silenziosamente ignorato, sia che tu invii `n=1` che `n=10`, la richiesta restituirà solo 1 immagine e verrà addebitata solo per 1 immagine. Se hai bisogno di ricevere più immagini candidate in una sola volta, ti preghiamo di **inviare più richieste in parallelo** (si consiglia di inviare contemporaneamente diversi `prompt` o diversi `seed`, altrimenti le immagini ottenute potrebbero essere molto simili). Questa limitazione si applica anche a `gpt-image-1` / `gpt-image-1.5`, così come alla serie `nano-banana` / `nano-banana-2-lite` / `nano-banana-2` / `nano-banana-pro`. `dall-e-2` è attualmente l'unico modello che supporta nativamente `n > 1`; `dall-e-3` supporta solo `n = 1`. Di seguito, alcuni esempi reali da diverse angolazioni per percepire intuitivamente le capacità di `gpt-image-2`. ### Scenario 1: Ritratto Cinematografico Nella frase di input, puoi utilizzare termini cinematografici (pellicola 35mm, profondità di campo ridotta, luci al neon, ecc.) per controllare con precisione l'atmosfera e la qualità. Esempio di codice di chiamata in 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 ritratto cinematografico di una giovane donna in piedi in un negozio di alimentari di notte, illuminata da morbidi cartelli al neon rosa e ciano attraverso la finestra. Ripresa su pellicola da 35 mm, profondità di campo ridotta, leggero grano, umore malinconico.", "size": "1024x1536" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Il risultato restituito è il seguente: ```json theme={null} { "success": true, "task_id": "ab58a5df-6f46-4874-bff6-93169e2849a3", "created": 1777048800, "data": [ { "revised_prompt": "Un ritratto cinematografico di una giovane donna in piedi in un negozio di alimentari di notte, illuminata da morbidi cartelli al neon rosa e ciano attraverso la finestra. Ripresa su pellicola da 35 mm, profondità di campo ridotta, leggero grano, umore malinconico.", "url": "https://platform.cdn.acedata.cloud/gpt-image/ab58a5df-6f46-4874-bff6-93169e2849a3_0.png" } ] } ``` L'immagine generata è mostrata di seguito:

### Scena due: Poster di viaggio vintage (con rendering del testo) `gpt-image-2` si comporta in modo stabile nella composizione e nel rendering dei caratteri, rendendolo molto adatto per generare poster, menu, biglietti d'auguri e altri design con testo. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Un poster di viaggio vintage della Costiera Amalfitana, Italia. Illustrazione in stile art-deco di case giallo limone a strapiombo che scendono verso un mare turchese, con una piccola barca a vela bianca nel porto. La tipografia audace in alto recita AMALFI e in basso ITALIA 1958. Palette di colori limitata: crema, blu mare, giallo limone, terracotta. Leggera texture di grana di carta.", "size": "1024x1536" } ``` L'immagine corrispondente al campo `url` nel risultato restituito è mostrata di seguito:

Si può notare che il modello ha non solo riprodotto accuratamente lo stile visivo del poster Art Deco, ma anche il testo del titolo `AMALFI` e `ITALIA 1958` è stato reso in modo chiaro e corretto. ### Scena tre: Composizione complessa e conteggio Il seguente suggerimento è utilizzato per testare la capacità del modello di seguire istruzioni strutturate come "quantità" e "posizione". ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Una libreria in legno composta da tre ripiani: Sul ripiano superiore, ci deve essere un libro. Sul secondo ripiano, ci devono essere tre libri. Sul ripiano inferiore, ci devono essere sette libri. Illuminazione calda e morbida, fotorealistica, atmosfera accogliente di biblioteca.", "size": "1024x1024" } ``` L'immagine generata è mostrata di seguito:

Si può notare che il numero di libri sui tre ripiani (1 / 3 / 7) corrisponde esattamente a quanto indicato nel suggerimento, cosa che era difficile da realizzare in modo stabile nell'era di `dall-e-3`. ### Scena quattro: Stile illustrazione (orizzontale) Specificando il mezzo artistico e le parole chiave emotive, è possibile guidare il modello a produrre illustrazioni stilizzate. ```python theme={null} payload = { "model": "gpt-image-2", "prompt": "Un'illustrazione morbida e poetica di un libro per bambini di una piccola volpe che legge un libro sotto un fungo luminoso in una foresta illuminata dalla luna. Texture ad acquerello e matita, colori pastello delicati, atmosfera da sogno, sensazione di disegno a mano.", "size": "1536x1024" } ``` L'illustrazione orizzontale generata è mostrata di seguito: ![](https://platform.cdn.acedata.cloud/gpt-image/6cd57e69-d237-4cc1-a666-759a93964a08_0.png) ### Asincrono e callback `gpt-image-2` richiede solitamente 60-90 secondi per una singola chiamata; se non si desidera mantenere una connessione lunga, è possibile utilizzare il meccanismo di callback asincrono `callback_url` descritto in seguito, il flusso di chiamata è completamente identico a quello di altri modelli. ## Modelli della serie Nano Banana La serie `nano-banana` è un modello di generazione di immagini basato su Gemini, già integrato tramite lo stesso endpoint `/openai/images/generations`, senza necessità di cambiare endpoint, basta cambiare `model` in uno qualsiasi di quelli nella tabella sottostante. | Modello | Costo (Crediti / volta) | Scenari applicabili | | -------------------- | ----------------------- | -------------------------------------------------------------------------------------- | | `nano-banana` | 0.14 | Generazione di immagini generiche, la più veloce e a costo più basso | | `nano-banana-2-lite` | 0.14 | Modello di immagine leggero Gemini 3.1, supporta solo 1K, bassa latenza di generazione | | `nano-banana-2` | 0.28 | Qualità e dettagli notevolmente migliorati | | `nano-banana-pro` | 0.35 | Il flagship della serie, migliore in composizione, dettagli e testo | > **Importante: intervallo di supporto dei parametri** > Nano Banana si integra con il protocollo OpenAI tramite un livello di adattamento, rispetto a `gpt-image-*` supporta solo i seguenti parametri: `model`, `prompt`, `size`. > > * `size` verrà mappato come `aspect_ratio` interno secondo la tabella sottostante, le dimensioni non elencate verranno degradate a `1:1`: > * `1024x1024` / `512x512` / `256x256` → `1:1` > * `1792x1024` → `16:9` > * `1024x1792` → `9:16` > * Non supporta i parametri `n`, `quality`, `style`, `response_format`, `background`, `output_format`, ecc.; anche se inseriti verranno ignorati. > * La struttura di ritorno segue il formato OpenAI (`data[].url`), ma `created` è fisso a `0`, e non verrà restituito `b64_json`, `revised_prompt` è sempre uguale al `prompt` originale. ### Chiamata di 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": "una piccola mela rossa su un tavolo bianco, fotorealistica", "size": "1024x1024" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Il risultato restituito è il seguente: ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6870b330-65c4-436c-bb80-819fdae7a7a4.png", "revised_prompt": "una piccola mela rossa su un tavolo bianco, fotorealistica" } ] } ``` 生成的 immagini possono essere direttamente accessibili tramite il campo `url` restituito:

### Aggiorna al modello di punta `nano-banana-pro` Basta cambiare `model` in `nano-banana-pro`, gli altri parametri rimangono completamente invariati: ```python theme={null} payload = { "model": "nano-banana-pro", "prompt": "abstract painting", "size": "1024x1024" } ``` Esempio di risposta: ```json theme={null} { "created": 0, "data": [ { "url": "https://platform.cdn.acedata.cloud/nanobanana/6227fcc9-3442-4aa3-a76c-4a4441a99649.png", "revised_prompt": "abstract painting" } ] } ```

### Callback asincrono Il meccanismo di callback asincrono `callback_url` è altrettanto efficace per nano-banana, il flusso di chiamata è completamente identico ad altri modelli, vedere la sezione [Callback asincrono](#异步回调) qui sotto. ## Utilizzo di base Ora puoi compilare i contenuti corrispondenti nell'interfaccia, come mostrato nell'immagine:

Quando utilizzi per la prima volta questa interfaccia, è necessario compilare almeno tre contenuti, uno è `authorization`, che può essere selezionato direttamente dall'elenco a discesa. Un altro parametro è `model`, `model` è la categoria del modello che scegliamo di utilizzare dal sito ufficiale di OpenAI DALL-E, qui abbiamo principalmente 1 tipo di modello, i dettagli possono essere visti nei modelli forniti. L'ultimo parametro è `prompt`, `prompt` è la parola chiave che inseriamo per generare l'immagine. Puoi anche notare che a destra ci sono i codici di chiamata corrispondenti generati, puoi copiare il codice e eseguirlo direttamente, oppure puoi semplicemente fare clic sul pulsante "Try" per testare.

Esempio di codice di chiamata 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" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Dopo la chiamata, abbiamo trovato che il risultato restituito è il seguente: ```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" } ] } ``` Il risultato restituito ha diversi campi, descritti come segue: * `created `, l'ID generato per questa generazione di immagini, utilizzato per identificare univocamente questo compito. * `data`, contiene le informazioni sui risultati della generazione dell'immagine. Dove `data` include le informazioni specifiche sull'immagine generata dal modello, il cui `url` è il link ai dettagli dell'immagine generata, come mostrato nell'immagine.

## Parametro di qualità dell'immagine `quality` Ora presenteremo come impostare alcuni parametri dettagliati per i risultati della generazione dell'immagine, dove il parametro di qualità dell'immagine `quality` include due tipi, il primo `standard` indica che l'immagine generata è standard, l'altro `hd` indica che l'immagine creata ha dettagli più fini e maggiore coerenza. Di seguito impostiamo il parametro di qualità dell'immagine su `standard`, le impostazioni specifiche sono mostrate nell'immagine:

Puoi anche notare che a destra ci sono i codici di chiamata corrispondenti generati, puoi copiare il codice e eseguirlo direttamente, oppure puoi semplicemente fare clic sul pulsante "Try" per testare.

Esempio di codice di chiamata 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", "quality": "standard" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Dopo la chiamata, abbiamo trovato che il risultato restituito è il seguente: ```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" } ] } ``` Il risultato restituito è coerente con il contenuto di utilizzo di base, e puoi vedere che l'immagine generata con il parametro di qualità `standard` è mostrata nell'immagine qui sotto:

与上述相同操作，仅需将图片质量参数设置为 `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 adorabile cucciolo di lontra marina", "response_format": "url" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Dopo la chiamata, abbiamo scoperto che il risultato restituito è il seguente: ```json theme={null} { "created": 1721637575, "data": [ { "revised_prompt": "Una rappresentazione affascinante di un cucciolo di lontra marina. La lontra è vista riposare serenamente sulla schiena tra le dolci onde blu dell'oceano. Il pelo del cucciolo di lontra è un mix adorabile di morbide sfumature marrone grigiastro, che brillano sottilmente alla luce solare attenuata. Le sue piccole zampe sono toccanti, sollevate leggermente verso il cielo come se stessero giocando con un oggetto invisibile. I suoi occhi rotondi ed espressivi sono spalancati dalla curiosità, brillando di vita e innocenza. Usa uno stile realistico per evocare l'habitat naturale della lontra e il suo adorabile aspetto peloso.", "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" } ] } ``` Il risultato restituito è coerente con il contenuto di base utilizzato, si può vedere che il link dell'immagine con il parametro di formato `url` per l'immagine generata è [URL dell'immagine](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) questo è accessibile direttamente, il contenuto dell'immagine è mostrato nella figura sottostante:

Con la stessa operazione sopra, basta impostare il parametro di formato dell'immagine a `b64_json` per ottenere il risultato del link dell'immagine codificato in Base64, il risultato specifico è mostrato nella figura sottostante: ```json theme={null} { "created": 1721638071, "data": [ { "b64_json": "iVBORw0..............v//AQEAAP4AAAD+AAADAQAAAwEEA/4D//8Q/Pbw64mKbVTFoQAAAABJRU5ErkJggg==", "revised_prompt": "Un'immagine affascinante di un giovane cucciolo di lontra marina. La lontra fluttua dolcemente su un mare blu calmo, godendosi i caldi raggi dorati del sole che filtrano da un cielo sereno sopra. Il pelo della lontra è di un ricco marrone cioccolato, e sembra incredibilmente morbido e soffice. Gli occhi della lontra sono luminosi ed espressivi, pieni di curiosità infantile e gioia. Ha piccole orecchie a punta e un naso a forma di bottone che aggiunge al suo complessivo fascino. Nel mare intorno a lei, si possono vedere gocce d'acqua scintillanti, illuminate dalla luce del sole, la vista è certamente deliziosa." } ] } ``` ## Callback asincrona Poiché il tempo di generazione delle immagini dell'API OpenAI potrebbe essere relativamente lungo, se l'API non risponde per un lungo periodo, la richiesta HTTP manterrà la connessione, causando un ulteriore consumo di risorse di sistema, quindi questa API offre anche supporto per callback asincroni. Il flusso complessivo è: quando il client avvia la richiesta, specifica un campo `callback_url` aggiuntivo, dopo che il client ha avviato la richiesta API, l'API restituirà immediatamente un risultato, contenente un campo `task_id`, che rappresenta l'ID del compito corrente. Quando il compito è completato, il risultato dell'immagine generata verrà inviato al `callback_url` specificato dal client in formato JSON POST, che include anche il campo `task_id`, in modo che il risultato del compito possa essere associato tramite l'ID. Di seguito, attraverso un esempio, vediamo come operare concretamente. Innanzitutto, il callback Webhook è un servizio in grado di ricevere richieste HTTP, gli sviluppatori dovrebbero sostituirlo con l'URL del proprio server HTTP. Qui, per comodità di dimostrazione, utilizziamo un sito Web pubblico di esempio per Webhook [https://webhook.site/](https://webhook.site/), aprendo questo sito si ottiene un URL Webhook, come mostrato nell'immagine: ![](https://cdn.acedata.cloud/cjjfly.png) Copia questo URL e puoi usarlo come Webhook, l'esempio qui è `https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab`. Successivamente, possiamo impostare il campo `callback_url` su questo URL Webhook, riempiendo i parametri corrispondenti, come mostrato nel seguente codice: ```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 adorabile cucciolo di lontra marina", "callback_url": "https://webhook.site/3d32690d-6780-4187-a65c-870061e8c8ab" } response = requests.post(url, json=payload, headers=headers) print(response.text) ``` Cliccando su Esegui, si può notare che si ottiene immediatamente un risultato, come segue: ```json theme={null} { "task_id": "6a97bf49-df50-4129-9e46-119aa9fca73c" } ``` Dopo un momento, possiamo osservare il risultato dell'immagine generata sull'URL Webhook, il contenuto è il seguente: ```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": "Un'immagine deliziosa che mostra un giovane cucciolo di lontra marina...", "url": "https://dalleprodsec.blob.core.windows.net/private/images/..." } ] } } ``` Si può vedere che nel risultato c'è un campo `task_id`, il campo `data` contiene lo stesso risultato di generazione dell'immagine della chiamata sincrona, attraverso il campo `task_id` è possibile realizzare l'associazione del compito. ## Gestione degli errori Quando si chiama l'API, se si verifica un errore, l'API restituirà il codice di errore e le informazioni corrispondenti. Ad esempio: * `400 token_mismatched`：Richiesta non valida, probabilmente a causa di parametri mancanti o non validi. * `400 api_not_implemented`：Richiesta non valida, probabilmente a causa di parametri mancanti o non validi. * `401 invalid_token`：Non autorizzato, token di autorizzazione non valido o mancante. * `429 too_many_requests`：Troppe richieste, hai superato il limite di frequenza. * `500 api_error`：Errore interno del server, qualcosa è andato storto sul server. ### Esempio di risposta di errore ```json theme={null} { "success": false, "error": { "code": "api_error", "message": "fetch failed" }, "trace_id": "2cf86e86-22a4-46e1-ac2f-032c0f2a4e89" } ``` ## Conclusione Attraverso questo documento, hai appreso come utilizzare facilmente le funzionalità di generazione di immagini dell'API OpenAI Images Generations con l'ufficiale DALL-E di OpenAI. Speriamo che questo documento possa aiutarti a integrare e utilizzare meglio questa API. Se hai domande, non esitare a contattare il nostro team di supporto tecnico.