OpenAI Images Generations API Richiesta e Utilizzo

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 per ottenere il tuo API Token, da conservare per uso futuro.

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.

📘 Documentazione Completa: OpenAI Images Generations API →

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:

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:

{
  "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.

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

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.

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:

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

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:

{
  "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:

payload = {
    "model": "nano-banana-pro",
    "prompt": "abstract painting",
    "size": "1024x1024"
}

Esempio di risposta:

{
  "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:

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:

{
  "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:

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:

{
  "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 样例调用代码：

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)

调用之后，我们发现返回结果如下：

{
  "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 ，可以得到如下图所示的图片：

可以看到图片的尺寸大小很明显不一样，另外还可以设置更多尺寸大小，详情信息参考我们官网文档。

图片风格参数 `style`

图片风格参数 style 包含俩个参数，第一种 vivid 表示生成的图片是更加生动的，另一种 natural 表示生成的图片更加的自然一点。下面设置图片风格参数为 vivid ，具体设置如下图：

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

Python 样例调用代码：

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)

调用之后，我们发现返回结果如下：

{
  "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 样例调用代码：

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:

{
  "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 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:

{
  "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/, aprendo questo sito si ottiene un URL Webhook, come mostrato nell’immagine:

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:

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:

{
  "task_id": "6a97bf49-df50-4129-9e46-119aa9fca73c"
}

Dopo un momento, possiamo osservare il risultato dell’immagine generata sull’URL Webhook, il contenuto è il seguente:

{
  "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

{
  "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.

Inizia

Chat AI

Immagine AI

Video AI

Audio AI

Web e Dati

CAPTCHA

Identità

Proxy

Avanzato

OpenAI Images Generations API Richiesta e Utilizzo

Processo di Richiesta

Modello GPT-Image-2

Percorso Ufficiale / Variante Inversa (`:official` / `:reverse`)

Valori Supportati per `size`

Scenario 1: Ritratto Cinematografico

Scena due: Poster di viaggio vintage (con rendering del testo)

Scena tre: Composizione complessa e conteggio

Scena quattro: Stile illustrazione (orizzontale)

Asincrono e callback

Modelli della serie Nano Banana

Chiamata di base

Aggiorna al modello di punta `nano-banana-pro`

Callback asincrono

Utilizzo di base

Parametro di qualità dell’immagine `quality`

图片大小尺寸参数 `size`

图片风格参数 `style`

图片链接的格式参数 `response_format`

Callback asincrona

Gestione degli errori

Esempio di risposta di errore

Conclusione

​Processo di Richiesta

​Modello GPT-Image-2

​Percorso Ufficiale / Variante Inversa (:official / :reverse)

​Valori Supportati per size

​Scenario 1: Ritratto Cinematografico

​Scena due: Poster di viaggio vintage (con rendering del testo)

​Scena tre: Composizione complessa e conteggio

​Scena quattro: Stile illustrazione (orizzontale)

​Asincrono e callback

​Modelli della serie Nano Banana

​Chiamata di base

​Aggiorna al modello di punta nano-banana-pro

​Callback asincrono

​Utilizzo di base

​Parametro di qualità dell’immagine quality

​图片大小尺寸参数 size

​图片风格参数 style

​图片链接的格式参数 response_format

​Callback asincrona

​Gestione degli errori

​Esempio di risposta di errore

​Conclusione

Processo di Richiesta

Modello GPT-Image-2

Percorso Ufficiale / Variante Inversa (`:official` / `:reverse`)

Valori Supportati per `size`

Scenario 1: Ritratto Cinematografico

Scena due: Poster di viaggio vintage (con rendering del testo)

Scena tre: Composizione complessa e conteggio

Scena quattro: Stile illustrazione (orizzontale)

Asincrono e callback

Modelli della serie Nano Banana

Chiamata di base

Aggiorna al modello di punta `nano-banana-pro`

Callback asincrono

Utilizzo di base

Parametro di qualità dell’immagine `quality`

图片大小尺寸参数 `size`

图片风格参数 `style`

图片链接的格式参数 `response_format`

Callback asincrona

Gestione degli errori

Esempio di risposta di errore

Conclusione