Source: https://ailoot.ai/models/de-at/gpt-image-1-5/
Canonical: https://ailoot.ai/models/de-at/gpt-image-1-5/
Language: de-at

# GPT Image 1.5

[Markdown](https://ailoot.ai/models/de-at/gpt-image-1-5/index.md) · [JSON](https://ailoot.ai/models/de-at/gpt-image-1-5/facts.json)

## [GPT Image 1.5](https://ailoot.ai/models/de-at/gpt-image-1-5/)

GPT Image 1.5 erstellt Bilder anhand einer Textanweisung und legt dabei besonderen Wert auf die Befolgung detaillierter Vorgaben. Vorgesehen sind drei Bildformen, mehrere Qualitätsstufen und Ausgabeformate.

- [**Ailoot · Bilder** `POST /v1/images/generations` `gpt-image-1.5`](https://ailoot.ai/models/de-at/gpt-image-1-5/#method-0)
- [**Ailoot Ultra · Bilder** `POST /v1/images/generations` `gpt-image-1.5`](https://ailoot.ai/models/de-at/gpt-image-1-5/#method-1)

Über das Modell

Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.

#### Bilder nach detaillierten Vorgaben

GPT Image 1.5 ist ein Modell von OpenAI zur Bildgenerierung anhand von Text. Es ist darauf ausgerichtet, detaillierte Vorgaben zu Inhalt, Komposition, Objekten und Stil zu befolgen. Das Ergebnis dieser Methode ist ein Bild.

In der aktuellen Ailoot-Karte ist Texteingabe angegeben. Die bei OpenAI vorgesehene Bildeingabe, Bildbearbeitung und Bearbeitung einzelner Bereiche erfordern eine gesonderte Unterstützung für visuelle Eingaben und gehören nicht zur aktuellen Text-zu-Bild-Generierung.

Im separaten Bearbeitungsmodus von OpenAI dient eine Maske als Orientierung für die Bearbeitung und garantiert keine exakt eingehaltene Umrisslinie. Dafür wird ein Eingabebild benötigt; die aktuelle Generierung in Ailoot bleibt textbasiert.

#### Drei Bildformen und Qualitätseinstellungen

Das Modell unterstützt das quadratische Format `1024x1024`, das Querformat `1536x1024` und das Hochformat `1024x1536` sowie eine automatische Auswahl. Beliebige Größen aus den Einstellungen anderer Bildmodelle dürfen dieser Version nicht zugeschrieben werden.

Die Qualitätsstufen sind `low`, `medium`, `high` und `auto`. Die Qualitätsstufe beeinflusst den Verarbeitungsaufwand und die Detailgenauigkeit. Qualität und Größe sind getrennte Einstellungen: Die Bildausrichtung legt den Raum für die Komposition fest, die Qualitätsstufe den Modus ihrer Erstellung. Die Stufen `xhigh` und `max` sind für GPT Image 1.5 nicht angegeben.

#### Dateiformat und Hintergrund

PNG ist das Standardformat; weitere Ausgabeformate sind JPEG und WebP. Die Komprimierung bei JPEG und WebP ist eine Dateieinstellung und unterscheidet sich von der Qualität der Bildgenerierung.

Der Hintergrund kann transparent, deckend oder automatisch gewählt sein. Transparenz erfordert PNG oder WebP; JPEG unterstützt keinen Alphakanal. Diese Option ist hilfreich, wenn ein separates Objekt ohne Hintergrund benötigt wird. Welche Parameter verfügbar sind, hängt von der Methode ab.

#### Text und Komposition müssen geprüft werden

Das Modell kann Text und Szenenelemente wiedergeben, garantiert aber keine exakte Position jedes Zeichens oder Objekts. Auch die Konsistenz von Figuren und Stil zwischen unabhängig erzeugten Bildern muss überprüft werden.

Komplexe Aufgaben können länger dauern; OpenAI nennt für anspruchsvolle Generierungen eine Bearbeitungszeit von bis zu zwei Minuten. Die Ausgangsanweisung muss vollständig sein, und die fertige Datei muss auf Lesbarkeit, Positionierung und korrekte Umsetzung der Szene geprüft werden.

**Ailoot · Bilder** `POST /v1/images/generations` `gpt-image-1.5`

[`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Core&caller=gpt-image-1.5&fmt=images)

OpenAI /`gpt-image-1.5`

### Einstieg

GPT Image 1.5 erstellt Bilder anhand einer Textanweisung und legt dabei besonderen Wert auf die Befolgung detaillierter Vorgaben. Vorgesehen sind drei Bildformen, mehrere Qualitätsstufen und Ausgabeformate.

Zulässige Eingaben

Text

Ergebnisse

Bilder

### In Ailoot verfügbar · Eingaben und Methoden

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

Eingabe

`text`

Ausgabe

`image`

Ausgabeformat

Bilddatei

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits gpt-image-1.5 | Standard— |
| Feld`prompt` | Typ`string` | AnforderungErforderlich | Werte und Limits Mindestlänge: 1 | Standard— |
| Feld`n` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 | Standard1 |
| Feld`response_format` | Typ`string` | AnforderungOptional | Werte und Limits url, b64\_json | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`size` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`quality` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`background` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_format` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`output_compression` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`moderation` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`input_fidelity` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`style` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`partial_images` | Typ`integer` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |

Kombinationen von Eingabematerialien

**Text zu Bild** · Erforderlich: prompt

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`material_types` | Vertragtext |
| Parameter`required` | Vertragmodel, prompt |
| Parameter`optional_controls` | Vertragnull |
| Parameter`content_type` | Vertragapplication/json |

Lebenszyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · die tatsächlich zurückgegebene task\_id oder ein Eintrag in der Medienbibliothek

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.

### Tarife

#### Ailoot-Methodentarife

Texteingabe

$ 0,005 */ 1K*

Textausgabe

$ 0,01 */ 1K*

Eingabe, Bild

$ 0,008 */ 1K tokens*

Ausgabe, Bild

$ 0,032 */ 1K tokens*

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de-at/billing/reserve/)

### Beispielanfragen

#### Ailoot · Bilder

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": "gpt-image-1.5", "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': 'gpt-image-1.5', '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": "gpt-image-1.5", "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");
```

### Ergebnisse abrufen und speichern

#### Ailoot · Bilder

Laden Sie jedes zurückgegebene Bild herunter oder speichern Sie seinen Base64-Inhalt

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

##### Alle fertiggestellten Ergebnisse aufbewahren

Speichern Sie jedes fertiggestellte Bild; rufen Sie jede zurückgegebene URL ab oder dekodieren Sie seinen Base64-Inhalt.

Jedes Datenelement speichern. Jedes b64\_json dekodieren oder jede zurückgegebene signierte URL abrufen. Die Dateiendung anhand des tatsächlichen MIME-Typs bzw. der Bytes wählen.

##### Wenn die ursprüngliche Antwort geprüft werden muss

Wenn das Ergebnis einer Bildgenerierung oder -bearbeitung geprüft werden muss, die ursprüngliche operation\_id/X-Client-Request-ID und die zurückgegebenen Ergebnisinformationen aufbewahren. Bereits vorhandene eigene Ergebnisse über die Medienbibliothek anhand tatsächlicher task\_id- oder asset\_id-Werte wiederherstellen. Die Generierungs-/Bearbeitungsanfrage nicht erneut senden und keine Abfrage-URL aus operation\_id bilden.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`created` | Typinteger |
| Feld`data[].url` | Typstring |
| Feld`data[].b64_json` | Typbase64 string |
| Feld`usage` | Typobject |

Fehler und nächste Schritte

| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |
| Antwort`server_error` | BedingungDie zurückgegebene Antwort gibt an, dass der Vorgang oder das Ergebnis eine Prüfung erfordert | Nächster SchrittDie ursprünglich zurückgegebene Vorgangs-/Aufgaben-ID, die Anfrageheader und die Antwort aufbewahren; mit unterstützten Leseaufrufen für diesen ursprünglichen Vorgang fortfahren. Die Erstellungsanfrage nicht erneut senden. |

### Aliasnamen

#### Modellaliasnamen

<strong>Ailoot</strong> [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Core&caller=gpt-image-1.5&fmt=images)
**Ailoot Ultra** [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Ultra&caller=gpt-image-1.5&fmt=images)

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Core&caller=gpt-image-1.5&fmt=images), [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Ultra&caller=gpt-image-1.5&fmt=images)

**Ailoot Ultra · Bilder** `POST /v1/images/generations` `gpt-image-1.5`

[`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Ultra&caller=gpt-image-1.5&fmt=images)

OpenAI /`gpt-image-1.5`

### Einstieg

GPT Image 1.5 erstellt Bilder anhand einer Textanweisung und legt dabei besonderen Wert auf die Befolgung detaillierter Vorgaben. Vorgesehen sind drei Bildformen, mehrere Qualitätsstufen und Ausgabeformate.

Zulässige Eingaben

Text

Ergebnisse

Bilder

### In Ailoot verfügbar · Eingaben und Methoden

**Ailoot Ultra · Bilder** `POST /v1/images/generations`

Eingabe

`text`

Ausgabe

`image`

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits gpt-image-1.5 | Standard— |
| Feld`prompt` | Typ`string` | AnforderungErforderlich | Werte und Limits Maximale Länge: 32 000 | Standard— |
| Feld`size` | Typ`string` | AnforderungOptional | Werte und Limits 1024x1024, 1536x1024, 1024x1536, auto | Standardauto |
| Feld`background` | Typ`string` | AnforderungOptional | Werte und Limits transparent, opaque, auto | Standardauto |
| Feld`moderation` | Typ`string` | AnforderungOptional | Werte und Limits low, auto Bedingungen: Verwenden Sie auto für die standardmäßige Inhaltsmoderation. | Standard— |
| Feld`n` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Maximum: 10 | Standard1 |
| Feld`quality` | Typ`string` | AnforderungOptional | Werte und Limits auto, high, medium, low | Standardauto |
| Feld`output_compression` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 0 Maximum: 100 Bedingungen: Gilt für JPEG- und WebP-Ausgaben; senden Sie den dokumentierten ganzzahligen Wert. | Standard100 |
| Feld`output_format` | Typ`string` | AnforderungOptional | Werte und Limits webp, png, jpeg | Standardpng |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits false Bedingungen: Diese Route liefert eine abgeschlossene JSON-Antwort zurück. | Standardfalse |

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragprompt, model |
| Parameter`material_types` | Vertragtext |
| Parameter`optional` | Vertragsize, background, moderation, n, quality, output\_compression, output\_format, stream |
| Parameter`conditions` | VertragEin transparenter Hintergrund erfordert PNG oder WebP., Ausgabekomprimierung gilt für JPEG oder WebP., Die ausgewählte Methode generiert aus Text. Die beim Hersteller beschriebenen Bearbeitungs- und Streaming-Steuerungen sind separate Funktionen. |

Lebenszyklus: `synchronous_result_then_owned_library`

`GET /v1/media/tasks/{task_id}` · die tatsächlich zurückgegebene task\_id oder ein Eintrag in der Medienbibliothek

`GET /v1/media/assets/{asset_id}/content`

`GET /v1/media/assets`

`GET /v1/media/assets/{asset_id}`

### Tarife

##### So wird die endgültige Gebühr berechnet

Die angezeigten Tarife dienen zur Kostenschätzung vor der Generierung. Der endgültige Betrag wird aus den für die ursprüngliche Generierung erfassten Kosten berechnet. Die gemessene Ausgabedauer und prognostizierte Mengen sind nicht die endgültige abrechenbare Menge.

Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.

Schnellmodus

Nicht angegeben Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Nicht angegeben Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Nicht angegeben Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

#### Geschätzte Tarife zum Vergleich

#### Preise nach Konfiguration

Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.

| Konfiguration | Tarifstaffel | Prognostizierte Menge | Gebühr |
| --- | --- | --- | --- |
| KonfigurationBasistarife für Tokens | TarifstaffelGrundtarif | Prognostizierte Menge— | Gebühr Eingabe · Eingabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Ausgabe · Ausgabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache lesen · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · In Cache schreiben · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · In Cache schreiben, 1 Stunde · Schätzung nur zum Vergleich **—** / 1K Tokens |
| KonfigurationGeschätzte Generierungskosten | Tarifstaffel— | Prognostizierte MengeSchätzung für eine Generierung | Gebühr Ausgabe · Geschätzte Generierungskosten · Schätzung nur zum Vergleich **$0.32768** Schätzung vor der Generierung Diese Schätzung ist weder eine zusätzliche Gebühr noch ein fester Tarif für die abgeschlossene Generierung. |

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de-at/billing/reserve/)

### Beispielanfragen

#### Ailoot Ultra · Bilder

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={'prompt': 'A cute baby sea otter', 'model': 'gpt-image-1.5', 'size': '1024x1024', 'n': 1, 'background': 'auto', 'moderation': 'auto', 'output_format': 'png'}

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

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · Bilder

Laden Sie jedes zurückgegebene Bild herunter oder speichern Sie seinen Base64-Inhalt

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

Abrufe anderer Inhalte

Vorhandene eigene Dateien abrufen

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/media/assets \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o owned-assets.json
# Preserve every returned asset and follow its exact signed content URL. Do not construct a signed token.
```

##### Alle fertiggestellten Ergebnisse aufbewahren

Speichern Sie jedes fertiggestellte Bild; rufen Sie jede zurückgegebene URL ab oder dekodieren Sie seinen Base64-Inhalt.

Die vollständige Antwort und ihre Header, jede tatsächliche Ausgabe, die ursprünglich zurückgegebenen Kennungen und alle Nutzungsfelder aufbewahren. Den ursprünglichen Vorgang wiederaufnehmen, ohne die Erstellung erneut anzufordern.

##### Wenn die ursprüngliche Antwort geprüft werden muss

Die zurückgegebene X-Client-Request-ID zum Abgleich aufbewahren. Nur tatsächlich zurückgegebene task\_id-/asset\_id-Werte oder die eigene Medienbibliothek abfragen; niemals eine Aufgaben-URL aus der Vorgangs-ID bilden und die Erstellung niemals erneut anfordern.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`created` | Typ |
| Feld`data[].url` | Typ |
| Feld`data[].b64_json` | Typ |
| Feld`usage` | Typ |

### Aliasnamen

#### Modellaliasnamen

<strong>Ailoot</strong> [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Core&caller=gpt-image-1.5&fmt=images)
**Ailoot Ultra** [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Ultra&caller=gpt-image-1.5&fmt=images)

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Core&caller=gpt-image-1.5&fmt=images), [`gpt-image-1.5`](https://ailoot.ai/models/de-at/#m=gpt-image-1.5&route=Ultra&caller=gpt-image-1.5&fmt=images)

FAQ · GPT Image 1.5

Welche Eingaben und Ergebnisse sind verfügbar?

`POST /v1/images/generations` · `gpt-image-1.5`: `text` → `image` `POST /v1/images/generations` · `gpt-image-1.5`: `text` → `image`

Welche Felder verwendet die Anfrage?

`POST /v1/images/generations` · `gpt-image-1.5`: `model`, `prompt`, `n`, `response_format`, `stream` `POST /v1/images/generations` · `gpt-image-1.5`: `model`, `prompt`, `size`, `background`, `moderation`, `n`, `quality`, `output_compression`, `output_format`, `stream`

Welche Grenzen gelten?

`POST /v1/images/generations` · `gpt-image-1.5`: `n.minimum`: `1` `POST /v1/images/generations` · `gpt-image-1.5`: `prompt.maximum_length`: `32000`; `n.minimum`: `1`; `n.maximum`: `10`; `output_compression.minimum`: `0`; `output_compression.maximum`: `100`

Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung.

## Das Unternehmen und sein Projektportfolio

Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.

## Tokens mit Rabatt kaufen.

Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf.

Abo

Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen.

Aktionscode bis 50%

Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet.

Ausgaben in der Historie

Modell, Tokens und Betrag werden für jede Anfrage gespeichert.

[Abo wählen](https://ailoot.ai/docs/de-at/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de-at/)

## Verbinden Sie die API mit dem Produkt, das Sie verkaufen.

SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an.

Kommerzielle Anwendung

Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes.

Reseller-Lizenz

Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an.

Dokumente auf der Website

Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich.

[Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de-at)

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.