TL;DR
GPT Image 2.6 API in CometAPI offre agli sviluppatori un percorso pratico per la generazione e l’editing di immagini con due varianti: Sunburst e Flare.
Crea asset di immagini con Python e una chiave CometAPI: inizia con una richiesta raster, poi aggiungi output SVG, immagini di riferimento o un livello di annotazione PNG trasparente quando il tuo percorso li supporta. Gli esempi usano Python 3.10 o successivo e mantengono la chiave API sul tuo server.
La distinzione più importante: un PNG trasparente come output è un asset finito; un file PNG trasparente di markup è un input che indica al modello dove modificare.
Key Takeaways
- Usa GPT Image 2.6 Flare per bozze rapide e Sunburst per revisioni dettagliate.
- Invia le richieste di generazione e di modifica ai rispettivi endpoint dell’Image API.
- Usa SVG per asset vettoriali e PNG trasparente per ritagli raster.
- Mantieni il markup separato dall’immagine sorgente e allinea le loro dimensioni orientate.
- Conferma il supporto del percorso prima di abilitare campi avanzati nella tua applicazione.
What Is the GPT Image 2.6 API?
OpenAI ha introdotto GPT Image 2.6 il 4 novembre 2026. La famiglia di modelli accetta input testuali e di immagini per creazione e revisione visiva.
Le due varianti condividono un ruolo orientato al workflow, ma con priorità differenti.
What Parameters Does the GPT Image 2.6 API Support?
Inizia con una configurazione piccola ed esplicita.
Per le modifiche, la richiesta fornisce anche immagini sorgente. Lo schema image-edit supporta fino a 16 immagini di riferimento.
Lascia complexity al valore predefinito per la prima generazione. Per una modifica mirata, come ricolorare un oggetto, inizia con low e verifica che i dettagli circostanti rimangano intatti.
How Do You Use GPT Image 2.6 API with CometAPI?
Segui la guida di configurazione CometAPI per creare una chiave, quindi conservala nella variabile d’ambiente seguente. Avrai anche bisogno di file PNG locali come sorgenti per gli esempi di editing.
Gli esempi usano Python requests per mostrare direttamente i corpi delle richieste JSON e multipart.
Questi esempi utilizzano il formato di richiesta dell’OpenAI Image API tramite CometAPI. Prima di eseguirli, conferma che il percorso CometAPI selezionato supporti il modello e i campi usati nell’esempio.
Install the dependencies
pip install requests pillow
Imposta la chiave nella shell:
export COMETAPI_KEY="YOUR_COMETAPI_KEY"
Gli utenti PowerShell possono usare:
$env:COMETAPI_KEY = "YOUR_COMETAPI_KEY"
Create shared request helpers
Salva gli helper condivisi come image_workflows.py. Metti ciascun esempio di workflow in uno script separato e importa gli helper che usa. Esegui solo il workflow che vuoi testare.
import base64
import os
from pathlib import Path
import requests
BASE_URL = "https://api.cometapi.com/v1"
HEADERS = {"Authorization": f"Bearer {os.environ['COMETAPI_KEY']}"}
MODEL = "gpt-image-2.6-flare"
def save_result(response, destination):
response.raise_for_status()
payload = response.json()
Path(destination).write_bytes(
base64.b64decode(payload["data"][0]["b64_json"], validate=True)
)
print(f"Saved: {destination}; usage: {payload.get('usage', 'Not returned')}")
def generate(prompt, destination, **options):
response = requests.post(
f"{BASE_URL}/images/generations", headers=HEADERS,
json={"model": MODEL, "prompt": prompt, "n": 1, "size": "1024x1024",
"quality": "medium", "complexity": "low", **options},
timeout=(15, 300),
)
save_result(response, destination)
Questo helper solleva un errore per una risposta HTTP non riuscita o dati base64 non validi. Si aspetta data[0].b64_json; se il tuo percorso restituisce una struttura diversa, ispeziona quella risposta prima di modificare la funzione di salvataggio.
Conserva il record di utilizzo restituito insieme all’output. Se una richiesta va in timeout, ispeziona il suo stato o il record di fatturazione prima di reinviarla: un timeout non stabilisce che la generazione sia fallita.
Generate a first image
Esegui questa chiamata dopo gli helper condivisi per generare una singola immagine prodotto e salvarla come cup.png.
Per i successivi esempi di editing, crea una copia di cup.png denominata product.png nella stessa directory di lavoro. Mantieni cup.png invariato come originale. In alternativa, puoi usare una tua fotografia del prodotto, salvata come product.png.
Prepara setting.png separatamente: usa una fotografia PNG dello sfondo o ambientazione in cui vuoi che appaia la tazza, con spazio sufficiente per il prodotto. Usa un’immagine che hai il permesso di caricare. Salvala accanto a product.png; la richiesta con più riferimenti la utilizza per l’ambientazione, non come seconda immagine di riferimento del prodotto.
generate(
prompt=(
"Create a studio product photograph of an unbranded teal "
"ceramic travel cup on a warm cream background. "
"Show one cup, a clean silhouette, and a soft contact shadow. "
"No text or decorative objects."
),
destination="cup.png",
output_format="png",
)
Verifica il risultato con una breve checklist di accettazione: una tazza, colore corretto, silhouette pulita e nessun oggetto extra.
How Do You Generate SVG with GPT Image 2.6?
Usa l’output SVG per asset vettoriali modificabili. Richiedilo tramite l’endpoint di generazione con n=1, quindi decodifica la risposta in un file .svg. L’output SVG non supporta lo streaming.
generate(
prompt=(
"Design an original minimalist icon of a teal travel cup "
"with a small leaf motif. Use simple closed vector shapes, "
"two flat colors, and generous negative space. "
"No text, gradients, photographs, or background scenery."
),
destination="cup-icon.svg",
output_format="svg",
)
Un test di accettazione utile per gli SVG va oltre l’apertura del file:
- Ispeziona l’icona a dimensioni piccole e grandi.
- Verifica che forme e colori siano facili da modificare.
- Conferma che il risultato si adatti al sistema visivo previsto.
- Controlla l’XML prima di incorporare SVG forniti esternamente in un’applicazione.
Non inviare un SVG come input per l’editing raster. Mantieni separati i workflow di revisione vettoriale e di image-editing.
How Do You Create Transparent PNG Assets with GPT Image 2.6?
Per un ritaglio, richiedi output PNG e uno sfondo trasparente. L’esempio ufficiale transparent-logo sottolinea anche bordi alpha puliti e l’assenza di una scacchiera disegnata.
generate(
prompt=(
"Create a single teal ceramic travel cup as an isolated "
"e-commerce asset. Center the entire cup with generous padding. "
"Keep clean edges and a fully transparent background. "
"No floor, backdrop, checkerboard pattern, or text."
),
destination="cup-transparent.png",
output_format="png",
background="transparent",
)
Valida la trasparenza effettiva:
from PIL import Image
with Image.open("cup-transparent.png") as image:
alpha = image.convert("RGBA").getchannel("A")
minimum, maximum = alpha.getextrema()
if minimum == 255:
raise RuntimeError("The output contains no transparent pixels.")
if maximum == 0:
raise RuntimeError("The output is entirely transparent.")
print("The output contains visible content and transparency.")
Questo intercetta un’immagine opaca che si spaccia per un ritaglio. Non valuta la qualità dei bordi; ispeziona l’asset su sfondi chiari e scuri.
How Do You Edit Images with Multiple GPT Image 2.6 References?
Assegna a ogni riferimento un ruolo specifico. In questo esempio, la prima immagine fornisce l’identità del prodotto e la seconda l’ambientazione desiderata.
with (
open("product.png", "rb") as product,
open("setting.png", "rb") as setting,
):
response = requests.post(
f"{BASE_URL}/images/edits",
headers=HEADERS,
data={
"model": "gpt-image-2.6-sunburst",
"prompt": (
"Use the cup in the first image as the exact product "
"reference. Use the second image only for the setting. "
"Place the cup naturally in that setting. Preserve its "
"silhouette, lid, color, and printed details. "
"Do not copy other products from the second image."
),
"quality": "high",
"complexity": "medium",
"output_format": "png",
},
files=[
("image[]", ("product.png", product, "image/png")),
("image[]", ("setting.png", setting, "image/png")),
],
timeout=(15, 300),
)
save_result(response, "product-in-setting.png")
L’esempio multipart usa image[]. Le richieste di modifica in JSON usano un array images; non mescolare le due codifiche.
Per test ripetibili, mantieni fisso l’ordine dei riferimenti. Confronta il prodotto originale con l’output alla risoluzione completa, in particolare manici, etichette, bordi e riflessi.
How Does Transparent PNG Markup Work in GPT Image 2.6?
Il markup è un livello di annotazione. Disegna un cerchio o un’altra istruzione visiva su un PNG trasparente separato, quindi invia quel file insieme all’immagine originale.
Il workflow di markup applica le annotazioni alla prima immagine in input. L’overlay deve corrispondere alle dimensioni orientate, contenere pixel trasparenti e rimanere separato dall’originale. Non combinare markup con mask o prompt_rewriter.
La dimostrazione di OpenAI mostra un vaso marcato:
La modifica risultante cambia il vaso:
Queste sono immagini dimostrative ufficiali, non output provenienti dal codice sottostante.
Prepare an annotation layer
Il riquadro seguente definisce l’ellisse di annotazione. Regola le sue coordinate per circondare l’oggetto che vuoi modificare, quindi ispeziona l’overlay prima di inviarlo.
from PIL import Image, ImageDraw, ImageOps
with Image.open("product.png") as source:
oriented = ImageOps.exif_transpose(source).convert("RGBA")
oriented.save("product-oriented.png")
overlay = Image.new("RGBA", oriented.size, (0, 0, 0, 0))
draw = ImageDraw.Draw(overlay)
width, height = oriented.size
region = (
int(width * 0.25),
int(height * 0.15),
int(width * 0.75),
int(height * 0.85),
)
draw.ellipse(region, outline=(255, 0, 0, 255), width=6)
overlay.save("markup.png")
Submit the guided edit
with (
open("product-oriented.png", "rb") as source,
open("markup.png", "rb") as markup,
):
response = requests.post(
f"{BASE_URL}/images/edits",
headers=HEADERS,
data={
"model": MODEL,
"prompt": (
"Change the body of the cup inside the red circle "
"to matte cobalt blue. Preserve the lid, shape, "
"lighting, and surrounding scene. "
"Remove the annotation from the finished image."
),
"quality": "medium",
"complexity": "low",
"output_format": "png",
},
files={
"image": ("product.png", source, "image/png"),
"markup": ("markup.png", markup, "image/png"),
},
timeout=(15, 300),
)
save_result(response, "cup-edited.png")
La scelta progettuale importante è specificare sia la modifica richiesta sia i dettagli da preservare. Un’annotazione identifica il bersaglio; il testo definisce l’operazione.
GPT Image 2.6 API Pricing: Token Rates and SVG Costs
Entrambe le varianti hanno le seguenti tariffe token pubblicate da OpenAI.
Queste sono tariffe OpenAI, non un preventivo CometAPI verificato.
Per una richiesta non in cache, il calcolo corrispondente è:
Cost =
(text input tokens × $5
+ image input tokens × $8
+ image output tokens × $30)
÷ 1,000,000
Ad esempio, una richiesta raster con 1,000 token di input testuale, nessun token di input immagine e 2,000 token di output immagine costerebbe $0.065.
Per GPT Image 2.6 API in CometAPI, usa il prezzo mostrato per il percorso selezionato e rivedi l’addebito registrato per la tua richiesta. Le tariffe OpenAI sopra sono un calcolo di riferimento, non un preventivo CometAPI.
Una metrica aziendale utile è:
Cost per accepted asset =
total workflow spending ÷ number of approved assets
Includi nel numeratore generazioni rifiutate e round di revisione.
How Do You Migrate an Existing Image Workflow to GPT Image 2.6?
Se usi già GPT Image 2.5, aggiorna prima l’identificatore del modello e mantieni l’endpoint e la gestione della risposta espliciti. Aggiungi formati di output opzionali solo dopo che una richiesta di base ha avuto successo.
Imposta model="gpt-image-2.6-flare" o model="gpt-image-2.6-sunburst" invece di fare affidamento su un modello predefinito. Mantieni i tuoi file di input e il prompt esistenti mentre controlli la prima risposta.
Per SVG, usa l’endpoint di generazione, salva i byte decodificati con estensione .svg e ometti lo streaming. Per le modifiche raster, mantieni le immagini sorgente nella richiesta di modifica. Aggiungi markup solo dopo aver preparato un overlay trasparente separato.
Aggiorna anche il tuo livello di distribuzione file: un asset SVG e un asset PNG richiedono tipi di media diversi. Mantieni la sorgente originale e le revisioni approvate. Inizia ogni nuova modifica dalla versione che contiene le modifiche che vuoi preservare.
Conclusion
Inizia con l’esempio dell’immagine prodotto, quindi scegli il workflow che corrisponde al tuo output: SVG per artwork vettoriale modificabile, PNG trasparente per ritagli, riferimenti immagine per combinare input visivi o markup per modifiche mirate. Confronta Flare e Sunburst usando gli stessi prompt e impostazioni e monitora il costo per asset accettato.
FAQ
How should I handle a GPT Image 2.6 request timeout?
Un timeout può verificarsi mentre il server sta ancora elaborando la richiesta. Salva l’ID della richiesta e controlla il registro delle richieste del provider prima di riprovare per evitare lavoro e addebiti duplicati.
Why does my application fail to save the returned image?
L’helper si aspetta una risposta JSON contenente data[0].b64_json. Verifica prima lo stato HTTP e la struttura della risposta. Se il tuo percorso restituisce un URL dell’immagine, implementa il flusso documentato di download URL invece di passare quell’URL a un decoder base64. Mantieni l’estensione salvata coerente con il formato richiesto.
How can I keep edit files from being overwritten?
Salva la sorgente, l’overlay e ogni output con nomi separati. Ad esempio, usa product-source.png, product-markup.png e product-edit-01.png. Archivia il prompt accanto all’output. Questo ti consente di rivedere una revisione senza perdere l’originale o caricare accidentalmente un’anteprima annotata come sorgente.
What should I check before embedding a generated SVG?
Apri l’asset nel renderer di destinazione e ispeziona il suo XML con i tuoi normali strumenti di validazione SVG. Controlla dimensioni, clipping, percorsi e qualsiasi testo prima della pubblicazione. Applica la policy di sanitizzazione SVG della tua applicazione, servilo con il tipo di media corretto e verifica che rimanga leggibile alla dimensione più piccola utilizzata nella tua interfaccia.