Source: https://ailoot.ai/models/it/grok-imagine-image-quality/
Canonical: https://ailoot.ai/models/it/grok-imagine-image-quality/
Language: it

# grok-imagine-image-quality

[Markdown](https://ailoot.ai/models/it/grok-imagine-image-quality/index.md) · [JSON](https://ailoot.ai/models/it/grok-imagine-image-quality/facts.json)

## [grok-imagine-image-quality](https://ailoot.ai/models/it/grok-imagine-image-quality/)

Grok Imagine Image Quality crea immagini da testo e appartiene alla famiglia visiva xAI Imagine. Il modello può anche lavorare con immagini in ingresso; Grok Imagine Image Pro è un suo alias confermato.

- [**Ailoot · Immagini** `POST /v1/images/generations` `grok-imagine-image-quality`](https://ailoot.ai/models/it/grok-imagine-image-quality/#method-0)
- [**Ailoot · Immagini** `POST /v1/images/generations` `grok-imagine-image-pro`](https://ailoot.ai/models/it/grok-imagine-image-quality/#method-1)

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.

Grok Imagine Image Quality è un modello di xAI che può ricevere testo e immagini e produce un'immagine. Nell'attuale metodo di generazione di Ailoot si utilizza **input testuale**: descrizione della scena, degli oggetti e del risultato visivo desiderato.

#### Dimensioni dell'immagine

La scheda del modello elenca le dimensioni quadrate **1024×1024, 1408×1408 e 2048×2048**, corrispondenti a 1K, 1.5K e 2K. Il controllo della generazione prevede la scelta di `resolution` tra 1K e 2K. La menzione di 1.5K nelle caratteristiche del risultato non indica una modalità separata di generazione selezionabile.

#### Generazione di varianti

Per una descrizione testuale si possono impostare da 1 a 10 immagini. Le proporzioni vengono definite separatamente dalla risoluzione: si può preparare un'inquadratura quadrata, verticale o ampia oppure lasciare la scelta automatica in base al contenuto della richiesta.

#### Input visivo

Il modello stesso prevede l'uso di un'immagine iniziale e di un'istruzione testuale. Nella modifica sequenziale, ogni risultato può diventare materiale per il passaggio successivo. Questa capacità del modello riguarda la modalità visiva, mentre la generazione pubblicata di Ailoot riguarda la creazione da testo.

Grok Imagine Image Quality non dispone dell'impostazione `quality` con `low`, `medium` e `auto`: xAI offre questa scelta per Image 2.0. Le immagini vengono trasmesse come file tramite collegamento o dati in base64.

Grok Imagine Image Pro è un altro nome dello stesso Grok Imagine Image Quality. Il nome Pro non indica un modello separato con input, output o impostazioni diversi.

**Ailoot · Immagini** `POST /v1/images/generations` `grok-imagine-image-quality`

[`grok-imagine-image-quality`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-quality&fmt=images)

xAI /`grok-imagine-image-quality`

ID del modello

- `grok-imagine-image-quality`
- `grok-imagine-image-pro`

### Introduzione

Grok Imagine Image Quality crea immagini da testo e appartiene alla famiglia visiva xAI Imagine. Il modello può anche lavorare con immagini in ingresso; Grok Imagine Image Pro è un suo alias confermato.

Input accettati

Testo

Risultati

Immagini

### Disponibile in Ailoot · input e metodi

**Ailoot · Immagini** `POST /v1/images/generations`

Tipi di input

`text`

Tipi di output

`image`

Formato di output

File immagine

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti grok-imagine-image-quality | Predefinito— |
| Campo`prompt` | Tipo`string` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`n` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Massimo: 10 | Predefinito1 |
| Campo`response_format` | Tipo`string` | RequisitoFacoltativo | Valori e limiti url, b64\_json | Predefinitourl |
| Campo`resolution` | Tipo`string` | RequisitoFacoltativo | Valori e limiti 1k, 2k | Predefinito1k |
| Campo`aspect_ratio` | Tipo`string` | RequisitoFacoltativo | Valori e limiti auto, 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 2:1, 1:2, 19.5:9, 9:19.5, 20:9, 9:20, 21:9, 5:2 | Predefinitoauto |
| Campo`quality` | Tipo`string` | RequisitoNon supportato | Valori e limiti | Predefinito— |

Combinazioni di materiali in input

**Da testo a immagine** · Obbligatorio: prompt

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`material_types` | Contrattotext |
| Parametro`required` | Contrattomodel, prompt |
| Parametro`optional_controls` | Contrattonull |
| Parametro`content_type` | Contrattoapplication/json |

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}`

Le strutture dei metodi e gli ID sono esatti; la capacità del fornitore è distinta dall’ammissione delle richieste.

### Tariffe

#### Tariffe dei metodi Ailoot

Input

0,01 USD *per immagine in input*

Output

0,06 USD *per immagine 1.5K*

Output

0,05 USD *per immagine 1K*

Output

0,07 USD *per immagine 2K*

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 · Immagini

curlPython SDKNode.js SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
export AILOOT_API_KEY
: "${AILOOT_PROMPT_FILE:?Set your actual UTF-8 image brief}"
export AILOOT_PROMPT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-imagine-image-quality", "prompt": ""}')
f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 brief")
p['prompt']=f.read_text(encoding="utf-8")
if not p['prompt'].strip():raise SystemExit("Brief must contain text")
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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

```python
from openai import OpenAI
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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")

f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Set your actual UTF-8 image brief file")
request={'model': 'grok-imagine-image-quality', 'prompt': ''}
request["prompt"]=f.read_text(encoding="utf-8")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.images.generate(**request)
Path("sdk-result.txt").write_text(str(result),encoding="utf-8")
save_images([{"b64_json":getattr(item,"b64_json",None),"url":getattr(item,"url",None)} for item in result.data])
```

```js
import OpenAI from "openai";
import { readFileSync, writeFileSync } from "node:fs";
const key=process.env.AILOOT_API_KEY;
if(!key) throw new Error("Set your actual Ailoot API key");
const client=new OpenAI({baseURL:"https://api.ailoot.ai/v1",apiKey:key,maxRetries:0});
const request={"model": "grok-imagine-image-quality", "prompt": ""};
if(!process.env.AILOOT_PROMPT_FILE)throw new Error("Set your actual UTF-8 image brief file");
request.prompt=readFileSync(process.env.AILOOT_PROMPT_FILE,"utf8");
const result=await client.images.generate(request);
writeFileSync("sdk-result.json",JSON.stringify(result,null,2));
if(!result.data?.length) throw new Error("No completed images");
for(let index=0;index<result.data.length;index++) {
  const item=result.data[index];let encoded=item.b64_json,uri=item.url||"",raw;
  if(!encoded && uri.startsWith("data:image/")) {
    const comma=uri.indexOf(",");if(comma<0 || !uri.slice(0,comma).includes(";base64")) throw new Error("Unsupported image data URI");
    encoded=uri.slice(comma+1);
  }
  if(encoded) {
    if(encoded.length%4!==0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw new Error("Invalid Base64");
    raw=Buffer.from(encoded,"base64");
  } else if(uri) {
    const u=new URL(uri,"https://api.ailoot.ai");
    if(u.protocol!=="https:" || u.username || u.password) throw new Error("Invalid returned URL");
    const owned=u.origin==="https://api.ailoot.ai" && u.pathname.startsWith("/v1/media/assets/") && u.pathname.endsWith("/content");
    const response=await fetch(u,{headers:owned?{Authorization:"Bearer "+key}:{},redirect:"manual"});
    if(!response.ok) throw new Error("Image content download failed: "+response.status);
    raw=Buffer.from(await response.arrayBuffer());
  } else throw new Error("Image has neither bytes nor URL");
  if(!raw.length) throw new Error("Empty image result");
  const ext=raw.subarray(0,4).equals(Buffer.from([137,80,78,71]))?"png":raw[0]===255&&raw[1]===216?"jpg":raw.toString("ascii",0,4)==="RIFF"&&raw.toString("ascii",8,12)==="WEBP"?"webp":raw.toString("utf8").trimStart().startsWith("<svg")||raw.toString("utf8").trimStart().startsWith("<?xml")?"svg":"bin";
  writeFileSync(`image-${index}.${ext}`,raw);
}
console.log("Every returned image saved; sdk-result.json retains complete metadata");
```

### Ricevi e salva i risultati

#### Ailoot · Immagini

Scarica ogni immagine restituita o salvane il contenuto Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

##### Conserva tutti i risultati completati

Salva ogni immagine completata; recupera ogni URL restituito oppure decodificane il contenuto Base64.

Salva ogni elemento data. Decodifica ogni b64\_json o recupera ogni URL firmato restituito. Scegli l'estensione del nome del file in base al MIME e ai byte effettivi.

##### Se occorre verificare la risposta originale

Se il risultato di una generazione o modifica di immagini richiede una verifica, conserva operation\_id/X-Client-Request-ID originale e le informazioni sul risultato restituito. Recupera i risultati esistenti che ti appartengono tramite la libreria multimediale usando i valori effettivi di task\_id o asset\_id. Non reinviare la richiesta di generazione/modifica e non costruire un URL di polling a partire da operation\_id.

Campi della risposta

| Campo | Tipo |
| --- | --- |
| Campo`created` | Tipointeger |
| Campo`data[].url` | Tipostring |
| Campo`data[].b64_json` | Tipobase64 string |
| 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. |
| Risposta`server_error` | CondizioneLa risposta restituita indica che l'operazione o il risultato richiede una verifica | Passaggio successivoConserva l'ID originale di operazione/task restituito, gli header della richiesta e la risposta; continua a leggere l'operazione originale tramite le modalità supportate. Non reinviare la richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot** [`grok-imagine-image-quality`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-quality&fmt=images), [`grok-imagine-image-pro`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-pro&fmt=images)

#### Alias dei percorsi dei metodi

Usa i percorsi dei metodi indicati sopra.

#### ID di chiamata correlati

[`grok-imagine-image-quality`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-quality&fmt=images), [`grok-imagine-image-pro`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-pro&fmt=images)

**Ailoot · Immagini** `POST /v1/images/generations` `grok-imagine-image-pro`

[`grok-imagine-image-pro`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-pro&fmt=images)

xAI /`grok-imagine-image-pro`

ID del modello

- `grok-imagine-image-quality`
- `grok-imagine-image-pro`

### Introduzione

Grok Imagine Image Quality crea immagini da testo e appartiene alla famiglia visiva xAI Imagine. Il modello può anche lavorare con immagini in ingresso; Grok Imagine Image Pro è un suo alias confermato.

Input accettati

Testo

Risultati

Immagini

### Disponibile in Ailoot · input e metodi

**Ailoot · Immagini** `POST /v1/images/generations`

Tipi di input

`text`

Tipi di output

`image`

Formato di output

File immagine

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti grok-imagine-image-pro | Predefinito— |
| Campo`prompt` | Tipo`string` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`n` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Massimo: 10 | Predefinito1 |
| Campo`response_format` | Tipo`string` | RequisitoFacoltativo | Valori e limiti url, b64\_json | Predefinitourl |
| Campo`resolution` | Tipo`string` | RequisitoFacoltativo | Valori e limiti 1k, 2k | Predefinito1k |
| Campo`aspect_ratio` | Tipo`string` | RequisitoFacoltativo | Valori e limiti auto, 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3, 2:1, 1:2, 19.5:9, 9:19.5, 20:9, 9:20, 21:9, 5:2 | Predefinitoauto |
| Campo`quality` | Tipo`string` | RequisitoNon supportato | Valori e limiti | Predefinito— |

Combinazioni di materiali in input

**Da testo a immagine** · Obbligatorio: prompt

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`material_types` | Contrattotext |
| Parametro`required` | Contrattomodel, prompt |
| Parametro`optional_controls` | Contrattonull |
| Parametro`content_type` | Contrattoapplication/json |

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}`

Le strutture dei metodi e gli ID sono esatti; la capacità del fornitore è distinta dall’ammissione delle richieste.

### Tariffe

#### Tariffe dei metodi Ailoot

Input

0,01 USD *per immagine in input*

Output

0,06 USD *per immagine 1.5K*

Output

0,05 USD *per immagine 1K*

Output

0,07 USD *per immagine 2K*

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 · Immagini

curlPython SDKNode.js SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
export AILOOT_API_KEY
export AILOOT_API_KEY
: "${AILOOT_PROMPT_FILE:?Set your actual UTF-8 image brief}"
export AILOOT_PROMPT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "grok-imagine-image-pro", "prompt": ""}')
f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 brief")
p['prompt']=f.read_text(encoding="utf-8")
if not p['prompt'].strip():raise SystemExit("Brief must contain text")
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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")
save_images(json.loads(Path("result.json").read_text())["data"])
PY_RESULT
```

```python
from openai import OpenAI
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"<svg",b"<?xml")) else "bin"
        Path(f"image-{index}.{ext}").write_bytes(raw)
    print("Every returned image saved; complete response metadata retained")

f=Path(os.environ["AILOOT_PROMPT_FILE"])
if not f.is_file():raise SystemExit("Set your actual UTF-8 image brief file")
request={'model': 'grok-imagine-image-pro', 'prompt': ''}
request["prompt"]=f.read_text(encoding="utf-8")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.images.generate(**request)
Path("sdk-result.txt").write_text(str(result),encoding="utf-8")
save_images([{"b64_json":getattr(item,"b64_json",None),"url":getattr(item,"url",None)} for item in result.data])
```

```js
import OpenAI from "openai";
import { readFileSync, writeFileSync } from "node:fs";
const key=process.env.AILOOT_API_KEY;
if(!key) throw new Error("Set your actual Ailoot API key");
const client=new OpenAI({baseURL:"https://api.ailoot.ai/v1",apiKey:key,maxRetries:0});
const request={"model": "grok-imagine-image-pro", "prompt": ""};
if(!process.env.AILOOT_PROMPT_FILE)throw new Error("Set your actual UTF-8 image brief file");
request.prompt=readFileSync(process.env.AILOOT_PROMPT_FILE,"utf8");
const result=await client.images.generate(request);
writeFileSync("sdk-result.json",JSON.stringify(result,null,2));
if(!result.data?.length) throw new Error("No completed images");
for(let index=0;index<result.data.length;index++) {
  const item=result.data[index];let encoded=item.b64_json,uri=item.url||"",raw;
  if(!encoded && uri.startsWith("data:image/")) {
    const comma=uri.indexOf(",");if(comma<0 || !uri.slice(0,comma).includes(";base64")) throw new Error("Unsupported image data URI");
    encoded=uri.slice(comma+1);
  }
  if(encoded) {
    if(encoded.length%4!==0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) throw new Error("Invalid Base64");
    raw=Buffer.from(encoded,"base64");
  } else if(uri) {
    const u=new URL(uri,"https://api.ailoot.ai");
    if(u.protocol!=="https:" || u.username || u.password) throw new Error("Invalid returned URL");
    const owned=u.origin==="https://api.ailoot.ai" && u.pathname.startsWith("/v1/media/assets/") && u.pathname.endsWith("/content");
    const response=await fetch(u,{headers:owned?{Authorization:"Bearer "+key}:{},redirect:"manual"});
    if(!response.ok) throw new Error("Image content download failed: "+response.status);
    raw=Buffer.from(await response.arrayBuffer());
  } else throw new Error("Image has neither bytes nor URL");
  if(!raw.length) throw new Error("Empty image result");
  const ext=raw.subarray(0,4).equals(Buffer.from([137,80,78,71]))?"png":raw[0]===255&&raw[1]===216?"jpg":raw.toString("ascii",0,4)==="RIFF"&&raw.toString("ascii",8,12)==="WEBP"?"webp":raw.toString("utf8").trimStart().startsWith("<svg")||raw.toString("utf8").trimStart().startsWith("<?xml")?"svg":"bin";
  writeFileSync(`image-${index}.${ext}`,raw);
}
console.log("Every returned image saved; sdk-result.json retains complete metadata");
```

### Ricevi e salva i risultati

#### Ailoot · Immagini

Scarica ogni immagine restituita o salvane il contenuto Base64

- `GET /v1/media/tasks/{task_id}`
- `GET /v1/media/assets/{asset_id}/content`
- `GET /v1/media/assets`
- `GET /v1/media/assets/{asset_id}`

##### Conserva tutti i risultati completati

Salva ogni immagine completata; recupera ogni URL restituito oppure decodificane il contenuto Base64.

Salva ogni elemento data. Decodifica ogni b64\_json o recupera ogni URL firmato restituito. Scegli l'estensione del nome del file in base al MIME e ai byte effettivi.

##### Se occorre verificare la risposta originale

Se il risultato di una generazione o modifica di immagini richiede una verifica, conserva operation\_id/X-Client-Request-ID originale e le informazioni sul risultato restituito. Recupera i risultati esistenti che ti appartengono tramite la libreria multimediale usando i valori effettivi di task\_id o asset\_id. Non reinviare la richiesta di generazione/modifica e non costruire un URL di polling a partire da operation\_id.

Campi della risposta

| Campo | Tipo |
| --- | --- |
| Campo`created` | Tipointeger |
| Campo`data[].url` | Tipostring |
| Campo`data[].b64_json` | Tipobase64 string |
| 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. |
| Risposta`server_error` | CondizioneLa risposta restituita indica che l'operazione o il risultato richiede una verifica | Passaggio successivoConserva l'ID originale di operazione/task restituito, gli header della richiesta e la risposta; continua a leggere l'operazione originale tramite le modalità supportate. Non reinviare la richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot** [`grok-imagine-image-quality`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-quality&fmt=images), [`grok-imagine-image-pro`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-pro&fmt=images)

#### Alias dei percorsi dei metodi

Usa i percorsi dei metodi indicati sopra.

#### ID di chiamata correlati

[`grok-imagine-image-quality`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-quality&fmt=images), [`grok-imagine-image-pro`](https://ailoot.ai/models/it/#m=grok-imagine-image-quality&route=Core&caller=grok-imagine-image-pro&fmt=images)

FAQ · grok-imagine-image-quality

Quali input e risultati sono disponibili?

`POST /v1/images/generations` · `grok-imagine-image-quality`: `text` → `image` `POST /v1/images/generations` · `grok-imagine-image-pro`: `text` → `image`

Quali campi usa la richiesta?

`POST /v1/images/generations` · `grok-imagine-image-quality`: `model`, `prompt`, `n`, `response_format`, `resolution`, `aspect_ratio` `POST /v1/images/generations` · `grok-imagine-image-pro`: `model`, `prompt`, `n`, `response_format`, `resolution`, `aspect_ratio`

Quali limiti si applicano?

`POST /v1/images/generations` · `grok-imagine-image-quality`: `n.minimum`: `1`; `n.maximum`: `10` `POST /v1/images/generations` · `grok-imagine-image-pro`: `n.minimum`: `1`; `n.maximum`: `10`

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

## L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

## Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento

Scegli un piano scontato per richieste regolari.

Codice fino al 50%

Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.

Spese nella cronologia

Modello, token e importo sono salvati per ogni richiesta.

[Scegli abbonamento](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale

Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.

Licenza reseller

Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.

Documenti sul sito

Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

[Richiedi licenza reseller](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.