Source: https://ailoot.ai/models/de/gemini-3-pro-image/
Canonical: https://ailoot.ai/models/de/gemini-3-pro-image/
Language: de

# Google: Nano Banana Pro (Gemini 3 Pro Image)

[Markdown](https://ailoot.ai/models/de/gemini-3-pro-image/index.md) · [JSON](https://ailoot.ai/models/de/gemini-3-pro-image/facts.json)

## [Google: Nano Banana Pro (Gemini 3 Pro Image)](https://ailoot.ai/models/de/gemini-3-pro-image/)

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

- [**Ailoot · Bilder** `POST /v1/images/generations` `gemini-3-pro-image`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-0)
- [**Ailoot · Bilder** `POST /v1/images/generations` `gemini-3-pro-image-preview`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-1)
- [**Ailoot · Bilder** `POST /v1/images/generations` `nano-banana-pro`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-3-pro-image`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-3)
- [**Ailoot Ultra · Bilder** `POST /v1/images/generations` `google/gemini-3-pro-image`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-4)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-3-pro-image`](https://ailoot.ai/models/de/gemini-3-pro-image/#method-5)

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

Nano Banana Pro ist Googles Modell Gemini 3 Pro Image für denkgestützte Bilderzeugung und Bearbeitung. Der Hersteller stellt komplexes Grafikdesign, originalgetreue Produktentwürfe und sachbezogene Datenvisualisierung in den Mittelpunkt der vorgesehenen Nutzung. Es verarbeitet Text und Bilder und erzeugt Bild und Text. Diese benannte Pro-Bildedition basiert auf Gemini 3 Pro und behält dabei ihr eigenes Eingabe- und Fähigkeitsprofil für Bildaufgaben.

Das Modell unterstützt Bilder in 1K, 2K und 4K. Dokumentierte Formen umfassen 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9 und 21:9. Ein quadratisches Bild in 4K misst 4.096 × 4.096; ein Bild in 16:9 bei 4K misst 5.504 × 3.072. Wählen Sie Auflösung und Seitenverhältnis für das benötigte Ergebnis, etwa ein hochformatiges Plakat, eine Produktszene oder eine breite Erklärungsgrafik. Die Option 0.5K und die zusätzlichen extremen Seitenverhältnisse von Gemini 3.1 Flash Image gehören nicht zu dieser Pro-Tabelle.

Textdarstellung unterstützt klare Beschriftung in Plakaten, Diagrammen und anderen gestalteten Materialien. Stellen Sie für eine komplexe Infografik die zugrunde liegenden Fakten, den genauen Wortlaut, eine Lesereihenfolge und die Beziehung zwischen Beschriftungen und visuellen Elementen bereit. Trennen Sie die zu vermittelnden Informationen vom gewünschten künstlerischen Stil. Google empfiehlt, zuerst den Text vorzubereiten und anschließend das Bild mit diesem Text zu erzeugen. Dies ist besonders hilfreich, wenn eine Komposition eine Überschrift, ein Diagramm und mehrere kurze Bildunterschriften verbindet.

Die Eingabe mehrerer Bilder unterstützt bis zu 14 Referenzen. Googles Funktionstabelle beschreibt bis zu sechs Objektreferenzen für Wiedergabetreue, bis zu fünf Figurenreferenzen für Konsistenz und bis zu drei Stilreferenzen. Diese Rollen helfen bei der Vorbereitung einer zusammengesetzten Darstellung: Eine Produktfotografie definiert das Aussehen, ein separates Bild bestimmt die Umgebung, und ein Stilbild fließt in die Gestaltung ein. Sagen Sie dem Modell, welche Details maßgeblich sind und welche Referenzen der Inspiration dienen, statt eine wahllose Kombination aller sichtbaren Merkmale zu verlangen.

Google Search Grounding kann reale Informationen für eine sachbezogene Visualisierung oder eine von aktuellen Bedingungen geprägte Szene liefern. Der Pro-Bildablauf dokumentiert Web-Grounding; die Erweiterung Image Search ist speziell für Nano Banana 2.1 und Gemini 3.1 Flash Image dokumentiert. Stellen Sie für eine Datengrafik die darzustellenden Werte bereit oder verlangen Sie quellenbasierte Informationen im Herstellerablauf und bestimmen Sie danach Beziehung, Beschriftungen und Layout ausdrücklich. Suchgestützte Generierung erzeugt weiterhin ein zu prüfendes Bild und ersetzt nicht die Prüfung der dargestellten Fakten.

Denken unterstützt die Komposition eines komplexen Prompts vor der endgültigen Darstellung. Der Bildleitfaden beschreibt vorläufige Bilder zur Prüfung von Komposition und Logik, getrennt vom Endergebnis. Übertragen Sie weder die Steuerungstabelle minimal/high von Nano Banana 2 noch die Tabelle mit medium als Standard von Nano Banana 2.1 auf diese Pro-Edition. Stellen Sie für ein anspruchsvolles Design einen vollständigen Auftrag mit visueller Hierarchie, erforderlichen Objektbeziehungen und den Elementen bereit, die spätere Bearbeitungen überstehen müssen.

Die Modellkarte beschreibt wesentliche verbleibende Grenzen: Sehr kleiner Text und lange Passagen können schlecht dargestellt werden, das Aussehen einer Figur kann sich zwischen Referenz und Ergebnis ändern, und Bearbeitungen mit Masken oder Skizzen können Anweisungen nur teilweise befolgen oder Spuren hinterlassen. Das Modell kann auch links und rechts verwechseln oder ein Quellelement in die neue Komposition kopieren. Nennen Sie bei einer Produktüberarbeitung die zu erhaltende Geometrie und Beschriftungen ausdrücklich und prüfen Sie den bearbeiteten Bereich; vergleichen Sie bei einem Diagramm Pfeilrichtungen und relative Objektpositionen.

Die aktuelle API-Tabelle nennt eine Eingabegrenze von 65.536 Token und eine Ausgabegrenze von 32.768 Token. Bilderzeugung, Denken, Such-Grounding und Stapelverarbeitung werden unterstützt; Audioerzeugung, Funktionsaufrufe, Codeausführung, Caching, strukturierte Ausgaben, Dateisuche, URL-Kontext und Live API werden nicht unterstützt. Die Bildaufgabe akzeptiert in diesem Profil weder Audio- noch Videoeingaben. Erzeugte Bilder enthalten SynthID, und eine verlangte Anzahl von Ausgabebildern wird nicht immer genau eingehalten.

Ein praktischer Produktauftrag kann ein Produktbild, eine Beleuchtungsreferenz und die genaue Überschrift verbinden: „Erhalten Sie die Proportionen und Beschriftung des Produkts, zeigen Sie es auf einer hellen Steinoberfläche unter weichem Seitenlicht und lassen Sie das obere Drittel für die bereitgestellte Überschrift frei.“ Bestimmen Sie für ein sachbezogenes Diagramm jede Entität und Verbindung und stellen Sie die freigegebenen Beschriftungen bereit. Verfeinern Sie das Ergebnis im Gespräch, indem Sie eine Änderung und die zu erhaltenden Merkmale benennen, und bewahren Sie das gewählte Bild mit seinem erläuternden Text als Designergebnis auf.

Praktische Aufgabe

### Praktische Aufgabe

Technisches Beispiel auf Englisch

```
Visualize a supplied packaging cycle

Create one landscape explanatory graphic showing this packaging return cycle: customer returns an empty jar, store inspects it, accepted jars are washed, clean jars are refilled. Use four large illustrated stages connected clockwise. Add only these exact labels: 'RETURN', 'INSPECT', 'WASH', 'REFILL'. Make the arrow direction and stage order unmistakable.
```

#### Erwartetes Ergebnis

```
One landscape image with four labeled stages and arrows matching the supplied cycle.
```

#### Ergebnis prüfen

```
Inspect that arrows connect RETURN to INSPECT to WASH to REFILL in that order, with exact labels.
```

**Ailoot · Bilder** `POST /v1/images/generations` `gemini-3-pro-image`

[`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images)

Google /`gemini-3-pro-image`

Modell-ID

- `gemini-3-pro-image`
- `gemini-3-pro-image-preview`
- `nano-banana-pro`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text

Ergebnisse

Bilder

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

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

Eingabetypen

`text`

Ausgabetypen

`image`

Kontext

65.536 tokens

Maximale Ausgabe

32.768 tokens

Ausgabeformat

Bilddatei

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits gemini-3-pro-image | 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

Eingabe

0,002 $ */ 1K Bild-Token*

Ausgabe

0,134 $ *pro 1K-Bild*

Ausgabe

0,134 $ *pro 2K-Bild*

Ausgabe

0,24 $ *pro 4K-Bild*

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/billing/reserve/)

#### Details zum Referenztarif

Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.

Referenztarifstaffeln des Modells

#### Preise nach Konfiguration

| Konfiguration | Tarifstaffel | Gebühr |
| --- | --- | --- |
| KonfigurationUltra | TarifstaffelGrundtarif | Gebühr Eingabe · Eingabetoken **$0.004000** / 1K Token Ausgabe · Ausgabetoken **$0.024000** / 1K Token Eingabe · Bild **$0.004000** / 1K Token Ausgabe · Bildausgabe **$0.24000** / 1K Token Eingabe · Audio **$0.004000** / 1K Token Eingabe · Cache für Audioeingaben **$0.0004000** / 1K Token Ausgabe · Websuche **$0.028** pro Websuche Ausgabe · internes Reasoning **$0.024000** / 1K Token Eingabe · Cache-Lesen **$0.0004000** / 1K Token Eingabe · Cache-Schreiben **$0.000750000** / 1K Token |

### 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": "gemini-3-pro-image", "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': 'gemini-3-pro-image', '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": "gemini-3-pro-image", "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> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images)

**Ailoot · Bilder** `POST /v1/images/generations` `gemini-3-pro-image-preview`

[`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images)

Google /`gemini-3-pro-image-preview`

Modell-ID

- `gemini-3-pro-image`
- `gemini-3-pro-image-preview`
- `nano-banana-pro`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text

Ergebnisse

Bilder

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

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

Eingabetypen

`text`

Ausgabetypen

`image`

Kontext

65.536 tokens

Maximale Ausgabe

32.768 tokens

Ausgabeformat

Bilddatei

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits gemini-3-pro-image-preview | 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

Eingabe

0,002 $ */ 1K Bild-Token*

Ausgabe

0,134 $ *pro 1K-Bild*

Ausgabe

0,134 $ *pro 2K-Bild*

Ausgabe

0,24 $ *pro 4K-Bild*

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/billing/reserve/)

#### Details zum Referenztarif

Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.

Referenztarifstaffeln des Modells

#### Preise nach Konfiguration

| Konfiguration | Tarifstaffel | Gebühr |
| --- | --- | --- |
| KonfigurationUltra | TarifstaffelGrundtarif | Gebühr Eingabe · Eingabetoken **$0.004000** / 1K Token Ausgabe · Ausgabetoken **$0.024000** / 1K Token Eingabe · Bild **$0.004000** / 1K Token Ausgabe · Bildausgabe **$0.24000** / 1K Token Eingabe · Audio **$0.004000** / 1K Token Eingabe · Cache für Audioeingaben **$0.0004000** / 1K Token Ausgabe · Websuche **$0.028** pro Websuche Ausgabe · internes Reasoning **$0.024000** / 1K Token Eingabe · Cache-Lesen **$0.0004000** / 1K Token Eingabe · Cache-Schreiben **$0.000750000** / 1K Token |

### 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": "gemini-3-pro-image-preview", "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': 'gemini-3-pro-image-preview', '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": "gemini-3-pro-image-preview", "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> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images)

**Ailoot · Bilder** `POST /v1/images/generations` `nano-banana-pro`

[`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images)

Google /`nano-banana-pro`

Modell-ID

- `gemini-3-pro-image`
- `gemini-3-pro-image-preview`
- `nano-banana-pro`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text

Ergebnisse

Bilder

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

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

Eingabetypen

`text`

Ausgabetypen

`image`

Kontext

65.536 tokens

Maximale Ausgabe

32.768 tokens

Ausgabeformat

Bilddatei

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits nano-banana-pro | 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

Eingabe

0,002 $ */ 1K Bild-Token*

Ausgabe

0,134 $ *pro 1K-Bild*

Ausgabe

0,134 $ *pro 2K-Bild*

Ausgabe

0,24 $ *pro 4K-Bild*

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/billing/reserve/)

#### Details zum Referenztarif

Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.

Referenztarifstaffeln des Modells

#### Preise nach Konfiguration

| Konfiguration | Tarifstaffel | Gebühr |
| --- | --- | --- |
| KonfigurationUltra | TarifstaffelGrundtarif | Gebühr Eingabe · Eingabetoken **$0.004000** / 1K Token Ausgabe · Ausgabetoken **$0.024000** / 1K Token Eingabe · Bild **$0.004000** / 1K Token Ausgabe · Bildausgabe **$0.24000** / 1K Token Eingabe · Audio **$0.004000** / 1K Token Eingabe · Cache für Audioeingaben **$0.0004000** / 1K Token Ausgabe · Websuche **$0.028** pro Websuche Ausgabe · internes Reasoning **$0.024000** / 1K Token Eingabe · Cache-Lesen **$0.0004000** / 1K Token Eingabe · Cache-Schreiben **$0.000750000** / 1K Token |

### 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": "nano-banana-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': 'nano-banana-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": "nano-banana-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");
```

### 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> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images)

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-3-pro-image`

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=chat)

Google /`google/gemini-3-pro-image`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text

Ergebnisse

Text

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

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`

Eingabetypen

`text`

Ausgabetypen

`text`

Ausgabeformat

json oder SSE

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-3-pro-image | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`modalities` | Typ`string[]` | AnforderungOptional | Werte und Limits text | Standard— |
| Feld`provider` | Typ`object` | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
| Feld`cache_control.ttl` | Typ`string` | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |

Kombinationen von Eingabematerialien

**Text** · UTF8-Text

`messages[].content`

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages |
| Parameter`material_types` | Vertragtext |
| Parameter`messages` | VertragNachrichtenarray mit role/content-Struktur |
| Parameter`file_material` | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
| Parameter`optional_controls` | Vertragstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
| Parameter`output_modalities` | Vertragtext |
| Parameter`hosted_operations` | Vertragfalse |
| Parameter`multimodal_input_binding` | Vertragnull |

Lebenszyklus: `synchronous_or_streamed`

Die genaue Modell-ID zusammen mit messages senden.

Die Kontextlänge ist keine Ausgabeobergrenze.

Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.

### Tarife

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

Schnellmodus

Standardtarif Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Standardtarif Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

Preise für explizites Caching

Nicht aktiviert Wenn explizites Caching angefordert wird

#### Ailoot-Tarife

#### Preise nach Konfiguration

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

| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.0004** / 1K Token Eingabe · Cache-Schreiben **$0.00075** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token Ausgabe · Bildausgabetoken **$0.24** / 1K Bild-Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.0004** / 1K Token Eingabe · Cache-Schreiben **$0.00075** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |

#### Details zum Referenztarif

Referenztarifstaffeln auf Modellebene ändern weder Methodenauswahl noch Kostenvoranschläge oder Gebühren. Für die aktive Abrechnung gelten die Tarife der ausgewählten Ailoot-Methode.

Google: Nano Banana Pro (Gemini 3 Pro Image)

#### Preise nach Konfiguration

| Konfiguration | Abrechnungsbedingungen | Gebühr |
| --- | --- | --- |
| KonfigurationGoogle: Nano Banana Pro (Gemini 3 Pro Image) · Standardkonfiguration | AbrechnungsbedingungenStandardkonfiguration | Gebühr Eingabe · Eingabetoken **0,004 $** / 1K Token Ausgabe · Ausgabetoken **0,024 $** / 1K Token Eingabe · Eingabebild **0,004 $** / 1K Token Ausgabe · Ausgabebild **0,24 $** / 1K Token Eingabe · Audioeingabe **0,004 $** / 1K Token Eingabe · Lesen von Audio aus dem Cache **0,0004 $** / 1K Token Ausgabe · Websuche **0,028 $** pro Suche Ausgabe · Reasoning-Token **0,024 $** / 1K Token Eingabe · Cache-Lesen **0,0004 $** / 1K Token Eingabe · Cache-Schreiben · 5 Minuten **0,00075 $** / 1K Token |

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/billing/reserve/)

### Beispielanfragen

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPython-Stream

```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": "google/gemini-3-pro-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='google/gemini-3-pro-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='google/gemini-3-pro-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")
```

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · OpenAI Chat

json oder SSE

##### Alle fertiggestellten Ergebnisse aufbewahren

Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.

Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.

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

Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| 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. |

### Aliasnamen

#### Modellaliasnamen

<strong>Ailoot</strong> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=chat)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=chat), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image)

**Ailoot Ultra · Bilder** `POST /v1/images/generations` `google/gemini-3-pro-image`

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images)

Google /`google/gemini-3-pro-image`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text · Bilder

Ergebnisse

Bilder

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

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

Eingabetypen

`text`, `image`

Ausgabetypen

`image`

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-3-pro-image | Standard— |
| Feld`prompt` | Typ`string` | AnforderungErforderlich | Werte und Limits Mindestlänge: 1 | Standard— |
| Feld`resolution` | Typ`string` | AnforderungOptional | Werte und Limits 1K, 2K, 4K | Standard— |
| Feld`aspect_ratio` | Typ`string` | AnforderungOptional | Werte und Limits 1:1, 2:3, 3:2, 3:4, 4:3, 4:5, 5:4, 9:16, 16:9, 21:9 | Standard— |
| Feld`n` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Maximum: 1 | Standard— |
| Feld`input_references` | Typ`array` | AnforderungOptional | Werte und Limits Mindestanzahl Elemente: 0 Maximale Anzahl Elemente: 14 | Standard— |
| Feld`provider` | Typ`object` | AnforderungOptional | Werte und Limits | Standard— |

Methodenparameter und Lebenszyklus

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

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 Token | TarifstaffelGrundtarif | Prognostizierte Menge— | Gebühr Eingabe · Eingabetoken · Schätzung nur zum Vergleich **—** / 1K Token Ausgabe · Ausgabetoken · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Lesen · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Schreiben · Schätzung nur zum Vergleich **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde · Schätzung nur zum Vergleich **—** / 1K Token |
| KonfigurationGeschätzte Generierungskosten | Tarifstaffel— | Prognostizierte MengeSchätzung für eine Generierung | Gebühr Ausgabe · Geschätzte Generierungskosten · Schätzung nur zum Vergleich **$0.98304** 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/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={'model': 'google/gemini-3-pro-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"<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> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=images), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview&fmt=images), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro&fmt=images), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image&fmt=images)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-3-pro-image`

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=messages)

Google /`google/gemini-3-pro-image`

### Start

Nano Banana Pro (Gemini 3 Pro Image) ist Googles denkgestütztes Bildmodell für komplexes Design, Produktentwürfe und sachbezogene Visualisierungen. Es verarbeitet Text und Bildreferenzen und erzeugt Bilder mit Text, mit Ausgaben in 1K–4K und detaillierter kreativer Steuerung.

Zulässige Eingaben

Text

Ergebnisse

json · sse

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

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`

Eingabetypen

`text`

Ausgabetypen

`json`, `sse`

Ausgabeformat

JSON oder SSE

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-3-pro-image | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |

Kombinationen von Eingabematerialien

**Text** · UTF-8-Text

`Zeichenfolge messages[].content`

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragstream |
| Parameter`material_types` | Vertragtext |
| Parameter`text_file_material` | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |

Lebenszyklus: `synchronous_or_streamed`

### Tarife

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

Schnellmodus

Standardtarif Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Standardtarif Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

Preise für explizites Caching

Nicht aktiviert Wenn explizites Caching angefordert wird

#### Ailoot-Tarife

#### Preise nach Konfiguration

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

| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.0004** / 1K Token Eingabe · Cache-Schreiben **$0.00075** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token Ausgabe · Bildausgabetoken **$0.24** / 1K Bild-Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.004** / 1K Token Ausgabe · Ausgabetoken **$0.024** / 1K Token Eingabe · Cache-Lesen **$0.0004** / 1K Token Eingabe · Cache-Schreiben **$0.00075** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |

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/billing/reserve/)

### Beispielanfragen

#### Ailoot Ultra · Anthropic Messages

Vollständiger minimaler JSON-Bodycurl · eigenes UTF-8-Dokument verwendenPython · das vollständige Ergebnis speichern

```json
{
  "model": "google/gemini-3-pro-image",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'google/gemini-3-pro-image', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```

```python
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'google/gemini-3-pro-image', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · Anthropic Messages

JSON oder SSE

##### Alle fertiggestellten Ergebnisse aufbewahren

Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.

Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.

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

Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| 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. |

### Aliasnamen

#### Modellaliasnamen

<strong>Ailoot</strong> [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro)
**Ailoot Ultra** [`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=messages)

#### Aliasnamen für Methodenpfade

`/v1/images`

#### Zugehörige Aufrufer-IDs

[`google/gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Ultra&caller=google%2Fgemini-3-pro-image&fmt=messages), [`gemini-3-pro-image-preview`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image-preview), [`nano-banana-pro`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=nano-banana-pro), [`gemini-3-pro-image`](https://ailoot.ai/models/de/#m=google%2Fgemini-3-pro-image&route=Core&caller=gemini-3-pro-image)

FAQ · Google: Nano Banana Pro (Gemini 3 Pro Image)

Welche Eingaben und Ergebnisse sind verfügbar?

`POST /v1/images/generations` · `gemini-3-pro-image`: `text` → `image` `POST /v1/images/generations` · `gemini-3-pro-image-preview`: `text` → `image` `POST /v1/images/generations` · `nano-banana-pro`: `text` → `image` `POST /v1/chat/completions` · `google/gemini-3-pro-image`: `text` → `text` `POST /v1/images/generations` · `google/gemini-3-pro-image`: `text`, `image` → `image` `POST /v1/messages` · `google/gemini-3-pro-image`: `text` → `json`, `sse`

Welche Felder verwendet die Anfrage?

`POST /v1/images/generations` · `gemini-3-pro-image`: `model`, `prompt`, `n`, `response_format`, `stream` `POST /v1/images/generations` · `gemini-3-pro-image-preview`: `model`, `prompt`, `n`, `response_format`, `stream` `POST /v1/images/generations` · `nano-banana-pro`: `model`, `prompt`, `n`, `response_format`, `stream` `POST /v1/chat/completions` · `google/gemini-3-pro-image`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/images/generations` · `google/gemini-3-pro-image`: `model`, `prompt`, `resolution`, `aspect_ratio`, `n`, `input_references`, `provider` `POST /v1/messages` · `google/gemini-3-pro-image`: `model`, `messages`, `max_tokens`, `stream`

Welche Grenzen gelten?

`POST /v1/images/generations` · `gemini-3-pro-image`: `ctx`: `65536`; `max_out`: `32768`; `n.minimum`: `1` `POST /v1/images/generations` · `gemini-3-pro-image-preview`: `ctx`: `65536`; `max_out`: `32768`; `n.minimum`: `1` `POST /v1/images/generations` · `nano-banana-pro`: `ctx`: `65536`; `max_out`: `32768`; `n.minimum`: `1` `POST /v1/chat/completions` · `google/gemini-3-pro-image`: `messages.min_items`: `1` `POST /v1/images/generations` · `google/gemini-3-pro-image`: `n.minimum`: `1`; `n.maximum`: `1`

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/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/)

## 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)

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