Source: https://ailoot.ai/models/it/openai-gpt-5-image/ Canonical: https://ailoot.ai/models/it/openai-gpt-5-image/ Language: it # OpenAI: GPT-5 Image [Markdown](https://ailoot.ai/models/it/openai-gpt-5-image/index.md) · [JSON](https://ailoot.ai/models/it/openai-gpt-5-image/facts.json) ## [OpenAI: GPT-5 Image](https://ailoot.ai/models/it/openai-gpt-5-image/) GPT-5 Image combina le capacità linguistiche e di ragionamento di GPT-5 di OpenAI con GPT Image 1 per la generazione di immagini e le modifiche guidate da riferimenti. Accetta testo, immagini e documenti e restituisce testo e immagini, collegando indicazioni scritte a un risultato visivo. - [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image`](https://ailoot.ai/models/it/openai-gpt-5-image/#method-0) - [**Ailoot Ultra · Immagini** `POST /v1/images/generations` `openai/gpt-5-image`](https://ailoot.ai/models/it/openai-gpt-5-image/#method-1) - [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `openai/gpt-5-image`](https://ailoot.ai/models/it/openai-gpt-5-image/#method-2) Informazioni sul modello Questa descrizione illustra le funzionalità del modello. Gli input, gli output e le opzioni disponibili in Ailoot per il metodo selezionato sono elencati di seguito. GPT-5 Image è un profilo combinato che unisce il modello linguistico GPT-5 di OpenAI a GPT Image 1. La componente linguistica interpreta i requisiti e il materiale di origine; la componente di immagini crea il risultato visivo. La descrizione pubblicata evidenzia ragionamento, rispetto delle istruzioni, resa del testo e modifica dettagliata delle immagini. Il profilo è adatto ad attività in cui un risultato visivo e la sua interpretazione scritta devono seguire le stesse indicazioni. #### Interpretare le indicazioni e creare il risultato Fornite al modello lo scopo dell’immagine, il pubblico previsto e il contenuto che deve comparire. Separate i fatti da rappresentare accuratamente dalle scelte di composizione o trattamento visivo. Le indicazioni per uno schema possono individuare entità e relazioni, poi specificare etichette, disposizione e stile. Quelle per un manifesto possono definire le informazioni dell’evento, la gerarchia e la scena, con le parole esatte che devono comparire nell’immagine. Per esempio, preparate un concept di manifesto per un evento scientifico rivolto alla comunità. Fornite i fatti relativi all’evento, chiedete una spiegazione breve dell’impaginazione e richiedete un’immagine che usi un titolo chiaro con elementi visivi di accompagnamento. Specificate quali parole devono comparire nell’immagine e quali soltanto nella descrizione allegata. Verificate insieme la spiegazione scritta e il manifesto generato, affinché un piano di impaginazione sensato venga confrontato con il risultato effettivamente visibile. Testo, immagini e file come PDF sono input documentati del profilo combinato. Un documento può fornire i requisiti per un’immagine o le informazioni da riassumere. Le immagini di riferimento possono definire un soggetto, un prodotto, un luogo o una disposizione. Nominate ogni fonte e spiegatene il ruolo prima di descrivere l’obiettivo, soprattutto quando un riferimento contiene elementi da preservare ed elementi da modificare. #### Modifiche guidate da riferimenti e resa del testo Per una revisione, individuate l’immagine di origine e descrivete con precisione la modifica richiesta. Una modifica a una scena di prodotto può cambiare l’ambientazione mantenendo la forma dell’oggetto e la sua etichettatura visibile. Una spiegazione visiva può sostituire un elemento conservando le relazioni circostanti. Indicate i requisiti di conservazione nelle istruzioni ed esaminate l’immagine effettiva per i dettagli importanti. La scheda del preciso profilo combinato consente fino a sedici immagini di riferimento per la modifica. Mantenete i riferimenti pertinenti all’attività e spiegate quali caratteristiche apporta ciascuno. Quando più immagini mostrano illuminazioni, punti di vista o trattamenti diversi, individuate la composizione desiderata anziché chiedere a ogni fonte di dominare il risultato. Conservate le fonti con l’immagine completata, affinché una correzione successiva possa fare riferimento allo stesso materiale. Il profilo pubblicato include la resa del testo tra le proprie capacità. Fornite formulazione esatta, punteggiatura e posizionamento per il testo importante e specificatene la relazione con gli oggetti o le altre etichette. Verificate ogni parola e numero richiesto nell’immagine restituita alle dimensioni di visualizzazione previste. Per uno schema, controllate anche che linee, posizioni e raggruppamenti esprimano la relazione descritta dalla fonte scritta. #### Contesto e struttura della risposta Il profilo combinato indica una finestra di contesto di 400 000 token e fino a 128 000 token di generazione. Queste capacità descrivono l’input e la risposta generata, non una particolare dimensione in pixel o un numero di immagini. Usate il contesto per i requisiti pertinenti, i riferimenti e lo stato della conversazione e lasciate spazio per l’output richiesto. Etichettate il materiale di origine lungo, affinché il modello possa collegare ogni istruzione al passaggio corretto. Le specifiche documentate dell’output testuale supportano risultati strutturati attraverso uno schema JSON. Una risposta scritta può definire i campi necessari per descrivere un concept, riassumere un requisito o individuare una modifica richiesta. Convalidate quei campi e i relativi valori rispetto alla fonte prima che un’applicazione li utilizzi. Il profilo combinato non mette a disposizione chiamate di funzione applicative, anche se la combinazione denominata di linguaggio e immagini esegue internamente la generazione visiva. Lo schema della richiesta chat può selezionare le modalità di output text e image. Indicate i risultati scritti e visivi effettivi nelle istruzioni, poi verificate che la risposta completata li contenga entrambi. La configurazione delle immagini è specifica del modello e dell’interfaccia precisi. Conservate le impostazioni accettate con la richiesta e usate soltanto i controlli documentati per quel profilo combinato; l’interfaccia diretta di una componente di immagini può organizzare diversamente campi e capacità. #### Usare consapevolmente la combinazione denominata La componente di immagini indicata per questo profilo è GPT Image 1. Il suo profilo diretto di generazione di immagini gestisce carichi di lavoro centrati sulle immagini, mentre GPT-5 Image unisce quella capacità all’elaborazione linguistica di GPT-5. GPT-5 Image Mini è una combinazione distinta di GPT-5 Mini e GPT Image 1 Mini. Conservate l’identità del profilo selezionato con il materiale di origine e le impostazioni di output, anziché trattare combinazioni dai nomi simili come lo stesso modello. Per una conversazione che comprende più revisioni, trasmettete i requisiti scritti pertinenti e i riferimenti di origine. Indicate la correzione specifica nelle istruzioni più recenti, per esempio spostare un’etichetta, cambiare un oggetto o semplificare la composizione. Evitate una richiesta priva di direzione di migliorare tutto, quando la modifica utile è già visibile nel risultato restituito. #### Conservare e verificare il risultato completato Conservate la risposta scritta e ogni immagine effettiva fornita dalla risposta generata. Salvate le immagini nel formato indicato, insieme al prompt, ai riferimenti di origine e alle impostazioni scelte. Esaminate l’immagine stessa per composizione, dettagli del soggetto e testo; confrontate il testo di accompagnamento con gli elementi che descrive. Un risultato finale utile unisce i requisiti scritti a un’immagine che può essere aperta, verificata e inserita nel documento, nella pagina o nel processo creativo previsto. Caso pratico ### Caso pratico Esempio tecnico in inglese ``` Simplify a community-event poster Edit the supplied community science poster. Preserve the exact event title, date, venue and central telescope illustration. Remove the small decorative stars around the footer, increase the empty space around the title and keep the original portrait layout and two-color palette. Add no new event facts or text. Return the revised poster image. ``` #### Risultato atteso ``` A revised poster image retaining all event wording and the telescope while simplifying the requested areas. ``` #### Verificare il risultato ``` Check every event word and number against the source and confirm that only the named decorative elements were removed. ``` **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `openai/gpt-5-image` [`openai/gpt-5-image`](https://ailoot.ai/models/it/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) OpenAI /`openai/gpt-5-image` ### Introduzione GPT-5 Image combina le capacità linguistiche e di ragionamento di GPT-5 di OpenAI con GPT Image 1 per la generazione di immagini e le modifiche guidate da riferimenti. Accetta testo, immagini e documenti e restituisce testo e immagini, collegando indicazioni scritte a un risultato visivo. Input accettati Testo Risultati Testo ### Disponibile in Ailoot · input e metodi **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` Tipi di input `text` Tipi di output `text` Formato di output json o SSE | Campo | Tipo | Requisito | Valori e limiti | Predefinito | | --- | --- | --- | --- | --- | | Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti openai/gpt-5-image | Predefinito— | | Campo`messages` | Tipo`message[]` | RequisitoObbligatorio | Valori e limiti Numero minimo di elementi: 1 | Predefinito— | | Campo`messages[].role` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Esempi: system, user, assistant, tool, function Condizioni: Questi ruoli sono rappresentati esplicitamente dai tipi di compatibilità del codice sorgente; l’insieme esatto dei ruoli rimane specifico del modello. Dipende dal modello | Predefinito— | | Campo`messages[].content` | Tipo`string\|content_part[]\|null` | RequisitoFacoltativo | Valori e limiti | Predefinito— | | Campo`messages[].tool_calls` | Tipo`tool_call[]` | RequisitoFacoltativo | Valori e limiti | Predefinito— | | Campo`messages[].tool_call_id` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Si applica quando: role=tool; usa l’ID effettivamente restituito | Predefinito— | | Campo`messages[].name` | Tipo`string` | RequisitoFacoltativo | Valori e limiti | Predefinito— | | Campo`messages[].reasoning_content` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Si applica quando: Reinserisci il ragionamento effettivamente restituito quando il modello lo utilizza | Predefinito— | | Campo`messages[].reasoning_details` | Tipo`object\|array` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`max_tokens` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Dipende dal modello | Predefinito— | | Campo`max_completion_tokens` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Dipende dal modello | Predefinito— | | Campo`stream` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse | | Campo`stream_options.include_usage` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`temperature` | Tipo`number` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`top_p` | Tipo`number` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`stop` | Tipo`string\|string[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`tools` | Tipo`function_tool[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`tools[].type` | Tipo`string` | RequisitoFacoltativo | Valori e limiti function Dipende dal modello | Predefinito— | | Campo`tools[].function.name` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Si applica quando: Funzione fornita come strumento | Predefinito— | | Campo`tools[].function.description` | Tipo`string` | RequisitoFacoltativo | Valori e limiti | Predefinito— | | Campo`tools[].function.parameters` | Tipo`JSON_schema` | RequisitoFacoltativo | Valori e limiti | Predefinito— | | Campo`tool_choice` | Tipo`string\|object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`parallel_tool_calls` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`response_format` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`reasoning_effort` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`reasoning` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`service_tier` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`instructions` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Campo di compatibilità | Predefinito— | | Campo`functions` | Tipo`function[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`function_call` | Tipo`string\|object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`prompt_cache_options` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— | | Campo`modalities` | Tipo`string[]` | RequisitoFacoltativo | Valori e limiti text | Predefinito— | | Campo`provider` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Condizioni: provider.options viene rifiutato su questa rotta testuale Ultra | Predefinito— | | Campo`cache_control.ttl` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Condizioni: 1h viene rifiutato nelle posizioni effettive della cache dei prompt | Predefinito— | Combinazioni di materiali in input **Testo** · Testo UTF8 `messages[].content` Parametri e ciclo di vita del metodo | Parametro | Contratto | | --- | --- | | Parametro`content_type` | Contrattoapplication/json | | Parametro`required` | Contrattomodel, messages | | Parametro`material_types` | Contrattotext | | Parametro`messages` | ContrattoArray di messaggi con struttura role/content | | Parametro`file_material` | ContrattoDocumento UTF-8 effettivo inserito come testo letterale; nessun ID di file dedotto | | Parametro`optional_controls` | Contrattostream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice | | Parametro`control_scope` | ContrattoSpecifico del modello; gli strumenti di funzione dell’utente differiscono dagli strumenti ospitati | | Parametro`output_modalities` | Contrattotext | | Parametro`hosted_operations` | Contrattofalse | | Parametro`multimodal_input_binding` | Contrattonull | Ciclo di vita: `synchronous_or_streamed` Invia l’ID esatto del modello con messages. La lunghezza del contesto non è un limite di uscita. Un file di testo può fornire testo letterale; gli ingressi immagine/audio/oggetto file richiedono un’associazione esatta. ### Tariffe Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato. Modalità rapida Tariffa standard Quando è selezionata la modalità rapida Modalità flex Tariffa standard Quando è selezionata la modalità flex Sforzo massimo di ragionamento Tariffa standard Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default) #### Tariffe Ailoot #### Prezzi per configurazione Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative. | Configurazione | Listino delle tariffe | Token di contesto, più di | Token di contesto, fino al limite incluso | Costo | | --- | --- | --- | --- | --- | | ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Token di contesto, più di— | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.02** / 1K token Output · Token in output **$0.02** / 1K token Input · Lettura dalla cache **$0.0025** / 1K token Input · Scrittura nella cache **—** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token Output · Token immagine in uscita **$0.08** / 1K token immagine | | ConfigurazioneFascia 1 di lunghezza della richiesta | Listino delle tariffe— | Token di contesto, più di0 | Token di contesto, fino al limite inclusoNessun limite superiore | Costo Input · Token in input **$0.02** / 1K token Output · Token in output **$0.02** / 1K token Input · Lettura dalla cache **$0.0025** / 1K token Input · Scrittura nella cache **—** / 1K token Input · Scrittura nella cache, 1 ora **—** / 1K token | #### Dettagli della tariffa di riferimento I listini di riferimento del modello non modificano la selezione del metodo, i preventivi o gli addebiti. Gli addebiti attivi usano le tariffe del metodo Ailoot selezionato. OpenAI: GPT-5 Image #### Prezzi per configurazione | Configurazione | Condizioni di fatturazione | Costo | | --- | --- | --- | | ConfigurazioneOpenAI: GPT-5 Image · Configurazione predefinita | Condizioni di fatturazioneConfigurazione predefinita | Costo Input · Token in input **0,02 USD** / 1K token Output · Token in output **0,02 USD** / 1K token Output · Immagine in uscita **0,08 USD** / 1K token Output · Ricerca web **0,02 USD** per ricerca Input · Lettura dalla cache **0,0025 USD** / 1K token | Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. [Come funzionano la prenotazione e l’addebito finale →](https://ailoot.ai/docs/it/billing/reserve/) ### Esempi di richieste #### Ailoot Ultra · OpenAI Chat curlPython SDKStreaming Python ```bash set -eu : "${AILOOT_API_KEY:?Set your Ailoot API key}" python3 - <<'PY_REQUEST' import json,os from pathlib import Path p=json.loads('{"model": "openai/gpt-5-image", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}') Path("request.json").write_text(json.dumps(p,ensure_ascii=False)) PY_REQUEST curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \ -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \ --data-binary @request.json -D response-headers.txt -o result.json python3 - <<'PY_RESULT' import json from pathlib import Path r=json.loads(Path("result.json").read_text()) for x in r.get("choices",[]): if x.get("message",{}).get("content"): print(x["message"]["content"]) PY_RESULT ``` ```python from openai import OpenAI import os if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request") client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0) result=client.chat.completions.create(model='openai/gpt-5-image',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) import base64, json from pathlib import Path def save_result(data, stem="result"): # Keep every field, including usage, IDs, reasoning and tool requests. Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps(data, ensure_ascii=False, indent=2)) def save_blob(encoded, suffix, label): raw = base64.b64decode(encoded, altchars=b"-_", validate=True) ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix file = Path(stem + "-" + label + "." + ext) file.write_bytes(raw) print("Saved", file) for index, block in enumerate(data.get("content") or []): print("Content", index, json.dumps(block, ensure_ascii=False)) for choice in data.get("choices") or []: print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False)) for index, item in enumerate(data.get("output") or []): print("Output", index, json.dumps(item, ensure_ascii=False)) if item.get("type") == "image_generation_call" and item.get("result"): save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index)) for ci, candidate in enumerate(data.get("candidates") or []): for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []): print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False)) blob = part.get("inlineData") or part.get("inline_data") if blob and blob.get("data"): mime = blob.get("mimeType") or blob.get("mime_type") suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin") save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi)) save_result(result.to_dict(mode="json")) ``` ```python from openai import OpenAI import os from pathlib import Path if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request") client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0) import base64, json from pathlib import Path def save_result(data, stem="result"): # Keep every field, including usage, IDs, reasoning and tool requests. Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") print(json.dumps(data, ensure_ascii=False, indent=2)) def save_blob(encoded, suffix, label): raw = base64.b64decode(encoded, altchars=b"-_", validate=True) ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix file = Path(stem + "-" + label + "." + ext) file.write_bytes(raw) print("Saved", file) for index, block in enumerate(data.get("content") or []): print("Content", index, json.dumps(block, ensure_ascii=False)) for choice in data.get("choices") or []: print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False)) for index, item in enumerate(data.get("output") or []): print("Output", index, json.dumps(item, ensure_ascii=False)) if item.get("type") == "image_generation_call" and item.get("result"): save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index)) for ci, candidate in enumerate(data.get("candidates") or []): for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []): print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False)) blob = part.get("inlineData") or part.get("inline_data") if blob and blob.get("data"): mime = blob.get("mimeType") or blob.get("mime_type") suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin") save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi)) with client.chat.completions.stream(model='openai/gpt-5-image',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream: with Path("stream-events.jsonl").open("w",encoding="utf-8") as log: for event in stream: payload=event.to_dict(mode="json") log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush() print(json.dumps(payload,ensure_ascii=False)) final=stream.get_final_completion() save_result(final.to_dict(mode="json"),"stream-result") ``` ### Ricevi e salva i risultati #### Ailoot Ultra · OpenAI Chat json o SSE ##### Conserva tutti i risultati completati Conserva ogni risposta, file e parte di contenuto restituiti per intero. Conserva ogni scelta con contenuto, chiamate agli strumenti e ragionamento. In SSE assembla i delta per indice di scelta e strumento e conserva il motivo finale di completamento e i dati di utilizzo. ##### Se occorre verificare la risposta originale Conserva gli ID e le intestazioni di richiesta/risposta. Non viene fornito alcun URL generico per recuperare un’attività testuale. Campi della risposta | Campo | Tipo | | --- | --- | | Campo`choices[].index` | Tipointeger | | Campo`choices[].message.content` | Tipostring\|null | | Campo`choices[].message.tool_calls` | Tipotool\_call\[\] | | Campo`choices[].message.reasoning_content` | Tipostring | | Campo`choices[].message.reasoning_details` | Tipoobject\|array | | Campo`choices[].finish_reason` | Tipostring\|null | | Campo`usage` | Tipoobject | Errori e passaggi successivi | Risposta | Condizione | Passaggio successivo | | --- | --- | --- | | Risposta400 · `invalid_request_error` | CondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validi | Passaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione. | ### Alias #### Alias del modello **Ailoot Ultra** [`openai/gpt-5-image`](https://ailoot.ai/models/it/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) #### Alias dei percorsi dei metodi `/v1/images` #### ID di chiamata correlati [`openai/gpt-5-image`](https://ailoot.ai/models/it/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=chat) **Ailoot Ultra · Immagini** `POST /v1/images/generations` `openai/gpt-5-image` [`openai/gpt-5-image`](https://ailoot.ai/models/it/#m=openai%2Fgpt-5-image&route=Ultra&caller=openai%2Fgpt-5-image&fmt=images) OpenAI /`openai/gpt-5-image` ### Introduzione GPT-5 Image combina le capacità linguistiche e di ragionamento di GPT-5 di OpenAI con GPT Image 1 per la generazione di immagini e le modifiche guidate da riferimenti. Accetta testo, immagini e documenti e restituisce testo e immagini, collegando indicazioni scritte a un risultato visivo. Input accettati Testo · Immagini Risultati Immagini ### Disponibile in Ailoot · input e metodi **Ailoot Ultra · Immagini** `POST /v1/images/generations` Tipi di input `text`, `image` Tipi di output `image` | Campo | Tipo | Requisito | Valori e limiti | Predefinito | | --- | --- | --- | --- | --- | | Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti openai/gpt-5-image | Predefinito— | | Campo`prompt` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Lunghezza minima: 1 | Predefinito— | | Campo`aspect_ratio` | Tipo`string` | RequisitoFacoltativo | Valori e limiti 1:1, 3:2, 2:3, auto | Predefinito— | | Campo`quality` | Tipo`string` | RequisitoFacoltativo | Valori e limiti auto, low, medium, high | Predefinito— | | Campo`background` | Tipo`string` | RequisitoFacoltativo | Valori e limiti auto, transparent, opaque | Predefinito— | | Campo`n` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Massimo: 10 | Predefinito— | | Campo`input_references` | Tipo`array` | RequisitoFacoltativo | Valori e limiti Numero minimo di elementi: 0 Numero massimo di elementi: 16 | Predefinito— | | Campo`output_compression` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 0 Massimo: 100 | Predefinito— | | Campo`provider` | Tipo`object` | RequisitoFacoltativo | Valori e limiti | Predefinito— | Parametri e ciclo di vita del metodo | Parametro | Contratto | | --- | --- | | Parametro`content_type` | Contrattoapplication/json | | Parametro`required` | Contrattomodel, prompt | | Parametro`material_types` | Contrattotext, image | Ciclo di vita: `synchronous_result_then_owned_library` `GET /v1/media/tasks/{task_id}` · task\_id effettivamente restituito o record della libreria multimediale `GET /v1/media/assets/{asset_id}/content` `GET /v1/media/assets` `GET /v1/media/assets/{asset_id}` ### Tariffe ##### Calcolo del costo finale Le tariffe visualizzate stimano il costo prima della generazione. L'addebito finale viene calcolato in base al costo registrato per la generazione originale. La durata misurata dell'output e le quantità previste non costituiscono la quantità finale fatturabile. Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato. Modalità rapida Non specificato Quando è selezionata la modalità rapida Modalità flex Non specificato Quando è selezionata la modalità flex Sforzo massimo di ragionamento Non specificato Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default) #### Tariffe stimate per il confronto #### Prezzi per configurazione Associa ogni costo alle condizioni indicate. Usa una sola tariffa per ogni insieme di configurazioni alternative. | Configurazione | Listino delle tariffe | Quantità prevista | Costo | | --- | --- | --- | --- | | ConfigurazioneTariffe base dei token | Listino delle tariffeTariffa base | Quantità prevista— | Costo Input · Token in input · Stima solo a fini di confronto **—** / 1K token Output · Token in output · Stima solo a fini di confronto **—** / 1K token Input · Lettura dalla cache · Stima solo a fini di confronto **—** / 1K token Input · Scrittura nella cache · Stima solo a fini di confronto **—** / 1K token Input · Scrittura nella cache, 1 ora · Stima solo a fini di confronto **—** / 1K token | | ConfigurazioneCosto stimato della generazione | Listino delle tariffe— | Quantità previstastima per una generazione | Costo Output · Costo di generazione stimato · Stima solo a fini di confronto **$0.32768** stima prima della generazione Questa stima non è un addebito aggiuntivo né una tariffa fissa per la generazione completata. | Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. [Come funzionano la prenotazione e l’addebito finale →](https://ailoot.ai/docs/it/billing/reserve/) ### Esempi di richieste #### Ailoot Ultra · Immagini curl ```bash set -eu : "${AILOOT_API_KEY:?Set your Ailoot API key}" export AILOOT_API_KEY python3 - <<'PY_REQUEST' import json,os from pathlib import Path p={'model': 'openai/gpt-5-image', 'prompt': 'a red panda astronaut floating in space, studio lighting'} Path("request.json").write_text(json.dumps(p,ensure_ascii=False)) PY_REQUEST curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/images/generations \ -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \ --data-binary @request.json -D response-headers.txt -o result.json python3 - <<'PY_RESULT' import base64, json, os, subprocess from pathlib import Path from urllib.parse import urlsplit, urljoin def save_images(items): if not items: raise SystemExit("No completed images; retain the full response") for index, item in enumerate(items): encoded=item.get("b64_json") uri=item.get("url", "") if not encoded and uri.startswith("data:image/"): header, separator, encoded=uri.partition(",") if not separator or ";base64" not in header: raise SystemExit("Unsupported image data URI") if encoded: raw=base64.b64decode(encoded,validate=True) elif uri: uri=urljoin("https://api.ailoot.ai",uri) parsed=urlsplit(uri) if parsed.scheme!="https" or not parsed.netloc or parsed.username or parsed.password: raise SystemExit("Invalid returned image URL") owned=parsed.netloc=="api.ailoot.ai" and parsed.path.startswith("/v1/media/assets/") and parsed.path.endswith("/content") args=["curl","--fail-with-body","--silent","--show-error",uri] if owned: args += ["-H","Authorization: Bearer "+os.environ["AILOOT_API_KEY"]] temporary=Path(f"image-{index}.bin") subprocess.run(args+["-o",str(temporary)],check=True) raw=temporary.read_bytes() temporary.unlink() else: raise SystemExit("Image has neither bytes nor URL") if not raw: raise SystemExit("Empty image result") ext="png" if raw.startswith(b"\x89PNG") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else "svg" if raw.lstrip().startswith((b"