Source: https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/ Canonical: https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/ Language: de-ch # Google: Nano Banana (Gemini 2.5 Flash Image) [Markdown](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/index.md) · [JSON](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/facts.json) ## [Google: Nano Banana (Gemini 2.5 Flash Image)](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/) Nano Banana (Gemini 2.5 Flash Image) erzeugt und bearbeitet Bilder aus Text und Bildern. Nutzen Sie den Ablauf im Gespräch, um eine Szene zu komponieren, ein gewähltes Element zu ändern, visuelle Referenzen zu verbinden oder ein Produktbild zu verfeinern, und geben Sie dabei die zu erhaltenden Details an. - [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/#method-0) - [**Ailoot Ultra · Bilder** `POST /v1/images/generations` `google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/#method-1) - [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/google-gemini-2-5-flash-image/#method-2) Ü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. Gemini 2.5 Flash Image, auch als Nano Banana bekannt, ist Googles Text-und-Bild-Modell für visuelle Erzeugung und Bildbearbeitung im Gespräch. Es verarbeitet eine Anweisung mit optionalen Bildreferenzen und kann Bilder mit Begleittext zurückgeben. Genau diese Edition 2.5 Flash Image ist von Nano Banana 2, Nano Banana Pro und späteren Lite-Bildmodellen getrennt. Ihr hilfreiches Ergebnis ist eine erzeugte oder überarbeitete Darstellung, keine Antwort des allgemeinen Textmodells Gemini 2.5. Die genaue Modellkarte nennt 65’536 Eingabetoken und 32’768 Ausgabetoken. Bilder und Anweisungen gehören zur Eingabe, und das zurückgegebene Bild oder der Text ist Teil des Ergebnisses. Die Auflösungstabelle des Leitfadens nennt unter den unterstützten Seitenverhältnissen Ausgaben in 1:1 mit 1’024×1’024, in 3:4 mit 864×1’184 und in 16:9 mit 1’344×768. Wählen Sie die gewünschte Anzeigeform, bevor Sie die Szene gestalten. Die hochauflösenden Optionen einer späteren Gemini-Bildedition sollten nicht als für genau dieses Modell dokumentierte Steuerungen behandelt werden. Bestimmen Sie für die Text-zu-Bild-Erzeugung Motiv, Handlung, Umgebung, Stil, Beleuchtung und Blickwinkel. Eine Produktillustration könnte eine bereitgestellte visuelle Identität verwenden und ein klar sichtbares Materialdetail in einer passenden Umgebung verlangen. Erklären Sie den Bildzweck, damit das Modell Raum für Motiv und etwaigen Text einplanen kann. Fotografische Beschreibungen wie Nahansicht, Aufsicht oder Perspektive aus niedrigem Kamerawinkel definieren den Bildausschnitt klarer als eine Liste unverbundener Stilwörter. Stellen Sie für eine Bearbeitung das Originalbild bereit und bestimmen Sie den zu ändernden Teil. Der Herstellerleitfaden beschreibt das Hinzufügen oder Entfernen von Elementen, semantische Maskierung, Stilübertragung und Komposition mit Referenzen. Eine hilfreiche Anfrage nennt sowohl die Überarbeitung als auch die zu erhaltenden Bedingungen, etwa einen Hintergrundwechsel bei Erhalt von Produktform, Oberfläche und Etikett. Kennzeichnen Sie beim Verbinden von Referenzen die Rolle jeder Eingabe, etwa Motivaussehen, Umgebung oder Stil. Laut Leitfaden arbeitet diese Edition am besten mit bis zu drei Eingabebildern; dies ist eine praktische Empfehlung, kein Grund, eine unbegrenzte Sammlung widersprüchlicher Referenzen zu verbinden. Verfeinerung im Gespräch kann dasselbe Motiv erhalten und zugleich eine bestimmte visuelle Entscheidung ändern. Verlangen Sie jeweils eine zusammenhängende Überarbeitung und bewahren Sie das für diesen Gesprächsschritt verwendete Quellbild und akzeptierte Ergebnis auf. Beschreiben Sie, was konsistent bleiben soll und was variieren darf. Bestimmen Sie für eine Reihe von Bildern das gemeinsame Motiv, Farben und visuelle Regeln ausdrücklich, statt ihre Wiederherstellung durch einen neuen isolierten Prompt anzunehmen. Vergleichen Sie das überarbeitete Bild mit der Referenz, bevor Sie eine Erhaltungsanweisung als erfolgreich befolgt behandeln. Legen Sie für Text im Bild zuerst den genauen Wortlaut fest und verlangen Sie dann das Bild mit diesem Text, wie im Leitfaden empfohlen. Geben Sie Sprache, Lesereihenfolge, Platzierung und relative Gewichtung der Beschriftungen an. Ein Infografikauftrag sollte die von jeder Beschriftung erklärte Beziehung und die stützenden visuellen Elemente bestimmen. Prüfen Sie Rechtschreibung, Zeichensetzung und visuelle Zuordnung in der tatsächlichen Anzeigegrösse; eine lesbar wirkende erzeugte Beschriftung kann dennoch einen Namen, eine Zahl oder die gewünschte Bedeutung verändern. Die Modellkarte führt für diese Edition weder Denken, Such-Grounding, Funktionsaufrufe, Codeausführung noch eingeschränkte strukturierte Ausgabe auf. Sie weist auch weder Audioerzeugung noch Live API aus. Ihre dokumentierte Eingabe ist Text und Bilder, weshalb Audio-, Video- und Dokumentverarbeitungsfunktionen anderer Gemini-Modelle diesem Profil nicht zugeschrieben werden sollten. Eine Anwendung sollte die zurückgegebenen Inhaltsteile ausdrücklich verarbeiten, statt das fertige Bild als Bestandteil einer gewöhnlichen Fliesstextantwort vorauszusetzen. Der Leitfaden weist darauf hin, dass die gewünschte Bildanzahl nicht immer eingehalten wird und erzeugte Bilder eine SynthID-Kennzeichnung enthalten. Prüfen Sie jedes zurückgegebene Bild auf Komposition, Motivtreue, Objektanzahl und genauen Wortlaut. Beschreiben Sie bei einer Szene mit mehreren Bestandteilen deren gewünschte Anordnung in klarer Reihenfolge und formulieren Sie das gewünschte Aussehen positiv. Bewahren Sie die genaue Modellidentität, den Prompt und Referenzen zusammen mit dem Ergebnis auf. So wird die visuelle Erzeugungs- oder Bearbeitungsaufgabe prüfbar, und eine spätere Überarbeitung erhält einen konkreten Ausgangspunkt. Praktische Aufgabe ### Praktische Aufgabe Technisches Beispiel auf Englisch ``` Change a product photo background Using the supplied product photograph, preserve the ceramic mug's shape, handle, glaze and existing logo exactly. Replace only the background with a pale stone tabletop and soft morning side light. Keep the camera angle and mug position. Remove unrelated background clutter and add no new lettering, props or decorative marks. ``` #### Erwartetes Ergebnis ``` An edited image retaining the reference mug while changing its setting and light as requested. ``` #### Ergebnis prüfen ``` Compare the result with the reference for mug geometry, logo fidelity, camera angle and removal of clutter. ``` **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-2.5-flash-image` [`google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/#m=google%2Fgemini-2.5-flash-image&route=Ultra&caller=google%2Fgemini-2.5-flash-image&fmt=chat) Google /`google/gemini-2.5-flash-image` ### Einstieg Nano Banana (Gemini 2.5 Flash Image) erzeugt und bearbeitet Bilder aus Text und Bildern. Nutzen Sie den Ablauf im Gespräch, um eine Szene zu komponieren, ein gewähltes Element zu ändern, visuelle Referenzen zu verbinden oder ein Produktbild zu verfeinern, und geben Sie dabei die zu erhaltenden Details an. Zulässige Eingaben Text Ergebnisse Text ### In Ailoot verfügbar · Eingaben und Methoden **Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` Eingabe `text` Ausgabe `text` Ausgabeformat json oder SSE | Feld | Typ | Anforderung | Werte und Limits | Standard | | --- | --- | --- | --- | --- | | Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-2.5-flash-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 einschliesslich | Gebühr | | --- | --- | --- | --- | --- | | KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschliesslichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0006** / 1K Tokens Ausgabe · Ausgabetoken **$0.005** / 1K Tokens Eingabe · Cache lesen **$0.00006** / 1K Tokens Eingabe · Cache schreiben **$0.0001666666666666666** / 1K Tokens Eingabe · Cache schreiben, 1 Stunde **—** / 1K Tokens Ausgabe · Bildausgabe-Tokens **$0.06** / 1K Bild-Tokens | | KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschliesslichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0006** / 1K Tokens Ausgabe · Ausgabetoken **$0.005** / 1K Tokens Eingabe · Cache lesen **$0.00006** / 1K Tokens Eingabe · Cache schreiben **$0.0001666666666666666** / 1K Tokens Eingabe · Cache schreiben, 1 Stunde **—** / 1K Tokens | #### 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/gemini-2.5-flash-image #### Preise nach Konfiguration | Konfiguration | Abrechnungsbedingungen | Gebühr | | --- | --- | --- | | Konfigurationgoogle/gemini-2.5-flash-image · Standardkonfiguration | AbrechnungsbedingungenStandardkonfiguration | Gebühr Eingabe · Eingabe **$ 0.0006** / 1K Tokens Ausgabe · Ausgabe **$ 0.06** / 1K Tokens | Google: Nano Banana (Gemini 2.5 Flash Image) #### Preise nach Konfiguration | Konfiguration | Abrechnungsbedingungen | Gebühr | | --- | --- | --- | | KonfigurationGoogle: Nano Banana (Gemini 2.5 Flash Image) · Standardkonfiguration | AbrechnungsbedingungenStandardkonfiguration | Gebühr Eingabe · Eingabetoken **$ 0.0006** / 1K Tokens Ausgabe · Ausgabetoken **$ 0.005** / 1K Tokens Eingabe · Eingabebild **$ 0.0006** / 1K Tokens Ausgabe · Ausgabebild **$ 0.06** / 1K Tokens Eingabe · Audioeingabe **$ 0.002** / 1K Tokens Eingabe · Lesen aus dem Audio-Cache **$ 0.0002** / 1K Tokens Ausgabe · Websuche **$ 0.028** pro Suche Ausgabe · Tokens für Denkprozesse **$ 0.005** / 1K Tokens Eingabe · Cache lesen **$ 0.00006** / 1K Tokens Eingabe · Schreiben in den Cache · 5 Minuten **≈$ 0.000167** / 1K Tokens | Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschliessenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de-ch/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-2.5-flash-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-2.5-flash-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-2.5-flash-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 **Ailoot Ultra** [`google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/#m=google%2Fgemini-2.5-flash-image&route=Ultra&caller=google%2Fgemini-2.5-flash-image&fmt=chat) #### Aliasnamen für Methodenpfade `/v1/images` #### Zugehörige Aufrufer-IDs [`google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/#m=google%2Fgemini-2.5-flash-image&route=Ultra&caller=google%2Fgemini-2.5-flash-image&fmt=chat) **Ailoot Ultra · Bilder** `POST /v1/images/generations` `google/gemini-2.5-flash-image` [`google/gemini-2.5-flash-image`](https://ailoot.ai/models/de-ch/#m=google%2Fgemini-2.5-flash-image&route=Ultra&caller=google%2Fgemini-2.5-flash-image&fmt=images) Google /`google/gemini-2.5-flash-image` ### Einstieg Nano Banana (Gemini 2.5 Flash Image) erzeugt und bearbeitet Bilder aus Text und Bildern. Nutzen Sie den Ablauf im Gespräch, um eine Szene zu komponieren, ein gewähltes Element zu ändern, visuelle Referenzen zu verbinden oder ein Produktbild zu verfeinern, und geben Sie dabei die zu erhaltenden Details an. Zulässige Eingaben Text · Bilder Ergebnisse Bilder ### In Ailoot verfügbar · Eingaben und Methoden **Ailoot Ultra · Bilder** `POST /v1/images/generations` Eingabe `text`, `image` Ausgabe `image` | Feld | Typ | Anforderung | Werte und Limits | Standard | | --- | --- | --- | --- | --- | | Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-2.5-flash-image | Standard— | | Feld`prompt` | Typ`string` | AnforderungErforderlich | Werte und Limits Mindestlänge: 1 | 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: 3 | 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 | | --- | --- | --- | --- | | KonfigurationToken-Basistarife | TarifstaffelGrundtarif | Prognostizierte Menge— | Gebühr Eingabe · Eingabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Ausgabe · Ausgabetoken · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache lesen · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache schreiben · Schätzung nur zum Vergleich **—** / 1K Tokens Eingabe · Cache schreiben, 1 Stunde · Schätzung nur zum Vergleich **—** / 1K Tokens | | KonfigurationGeschätzte Erzeugungskosten | Tarifstaffel— | Prognostizierte MengeSchätzung für eine Generierung | Gebühr Ausgabe · Geschätzte Generierungskosten · Schätzung nur zum Vergleich **$0.24576** 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 abschliessenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de-ch/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-2.5-flash-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"