Gemini 2.5 Flash ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
", "aboutText": "Gemini 2.5 Flash ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.\n\nDie Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.\n\nDefinieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.\n\nBestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.\n\nGoogles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.\n\nDie genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.\n\nDie native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.\n\nDie stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.", "editorialOverlay": { "copy_fields": { "practical_html": "Technisches Beispiel auf Englisch
Extract changes in an approval rule\n\nCompare these rules for a purchase request. [OLD] Any manager may approve expenses up to 500 units. [NEW] A team manager may approve up to 300 units; above that, finance approval is required. Return the changed requirement, source wording and effect on a 450-unit request. Mark any ambiguity about the currency.A structured comparison and a source-backed explanation of the 450-unit case, with the currency gap retained.Check that the example uses the new threshold and does not invent the unit's currency.gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1/messagestext, imagetext| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits gemini-2.5-flash | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
Feldmessages[].content | Typstring|content_block[] | AnforderungErforderlich | Werte und Limits | Standard— |
Feldsystem | Typstring|content_block[] | AnforderungOptional | Werte und Limits | Standard— |
Feldmax_tokens | Typinteger | AnforderungErforderlich | Werte und Limits Minimum: 1 Limit gilt für: Genaue Obergrenze des ausgewählten Modells bzw. seiner Modellkarte | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Feldtemperature | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtop_p | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldstop_sequences | Typstring[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools | Typtool[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools[].name | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: Werkzeug bereitgestellt | Standard— |
Feldtools[].description | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Feldtools[].input_schema | TypJSON_schema | AnforderungOptional | Werte und Limits | Standard— |
Feldtool_choice | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldthinking.type | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldthinking.budget_tokens | Typinteger | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldoutput_config.effort | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldmetadata | Typobject | AnforderungOptional | Werte und Limits | Standard— |
Feldcache_control | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Text · UTF8-Text
messages[].content oder Block mit type=text
Text + Bild
{type:image,source:{type:base64,media_type,data}} oder Quelle mit type=url
| Parameter | Vertrag |
|---|---|
Parametermaterial_types | Vertragtext, image |
Parameterrequired | Vertragmodel, messages, max_tokens |
Parameteroptional_controls | Vertragnull |
Parametercontent_type | Vertragapplication/json |
Parametertext_file_material | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: exact retained published method
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
POST /v1/messagesAiloot 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 →
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.
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 |
|---|---|---|---|---|
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-2.5-flash", "max_tokens": 1024, "messages": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\\n\\n"+text}]\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-2.5-flash", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nimport anthropic\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)\nmsg = client.messages.create(\n model="gemini-2.5-flash",\n max_tokens=1024,\n messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],\n)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(msg.to_dict(mode="json"))\nimport Anthropic from "@anthropic-ai/sdk";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });\nconst msg = await client.messages.create({\n model: "gemini-2.5-flash",\n max_tokens: 1024,\n messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],\n});\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(msg);\nimport anthropic,os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.messages.stream(model='gemini-2.5-flash',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_message()\n save_result(final.to_dict(mode="json"),"stream-result")\njson oder SSE
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.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldid | Typstring |
Feldmodel | Typstring |
Feldcontent[] | Typtext|thinking|tool_use|other content block |
Feldstop_reason | Typstring|null |
Feldusage | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1beta/models/{model}:generateContenttext, imagetext| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldpath.model | Typstring | AnforderungErforderlich | Werte und Limits gemini-2.5-flash | Standard— |
Feldcontents | Typcontent[] | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
Feldcontents[].role | Typstring | AnforderungOptional | Werte und Limits user, model | Standard— |
Feldcontents[].parts | Typpart[] | AnforderungErforderlich | Werte und Limits | Standard— |
FeldsystemInstruction | Typcontent | AnforderungOptional | Werte und Limits | Standard— |
FeldgenerationConfig.maxOutputTokens | Typinteger | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
FeldgenerationConfig.temperature | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldgenerationConfig.topP | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldgenerationConfig.topK | Typinteger | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldgenerationConfig.stopSequences | Typstring[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldgenerationConfig.thinkingConfig.includeThoughts | Typboolean | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldgenerationConfig.thinkingConfig.thinkingBudget | Typinteger | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools[].functionDeclarations | Typfunction_declaration[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldtoolConfig.functionCallingConfig.mode | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldsafetySettings | Typobject[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
FeldsessionId | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Text · UTF8-Text
contents[].parts[].text
Text + Bild
parts[].inlineData={mimeType,data}
| Parameter | Vertrag |
|---|---|
Parametermaterial_types | Vertragtext, image |
Parameterrequired | Vertragcontents |
Parameteroptional_controls | Vertragnull |
Parametercontent_type | Vertragapplication/json |
Parametertext_file_material | VertragTatsächlicher UTF-8-Inhalt wird als Text eingefügt; Datei-IDs/URLs müssen separat und exakt unterstützt werden |
Lebenszyklus: exact retained published method
Methodenstrukturen und IDs sind exakt; die Fähigkeiten des Anbieters sind von der Zulassung einer Anfrage zu unterscheiden.
POST /v1beta/models/{model}:generateContentAiloot 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 →
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.
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 |
|---|---|---|---|---|
| KonfigurationOpenAI Chat · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationOpenAI Chat · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnthropic Messages · Token-Basispreise | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnthropic Messages · Stufe 1 nach Anfragelänge | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["contents"]=[{"role":"user","parts":[{"text":"Summarize this material and quote supporting source passages.\\n\\n"+text}]}]\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-2.5-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": [{"role": "user", "parts": [{"text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["contents"][0]["parts"].append({"inlineData":{"mimeType":mime,"data":b64}})\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-2.5-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nfrom google import genai\nfrom google.genai import types\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = genai.Client(\n api_key=os.environ["AILOOT_API_KEY"],\n http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),\n)\nresp = client.models.generate_content(model="gemini-2.5-flash", contents="Explain the difference between an observation and a hypothesis in three sentences.")\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(resp.to_json_dict())\nimport { GoogleGenAI } from "@google/genai";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst ai = new GoogleGenAI({ apiKey: process.env.AILOOT_API_KEY, httpOptions: { baseUrl: "https://api.ailoot.ai" } });\nconst resp = await ai.models.generateContent({ model: "gemini-2.5-flash", contents: "Explain the difference between an observation and a hypothesis in three sentences." });\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(resp);\nfrom google import genai\nfrom google.genai import types\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=genai.Client(api_key=os.environ["AILOOT_API_KEY"],http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\ncount=0\nwith Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for chunk in client.models.generate_content_stream(model='gemini-2.5-flash',contents="Explain observations and hypotheses in three sentences."):\n payload=chunk.to_json_dict()\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n save_result(payload,"stream-chunk-"+str(count))\n count+=1\njson oder unterstütztes Streaming
Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.
Alle Kandidaten und Teile einschließlich Funktionsaufrufen, Gedankensignaturen und Verbrauchsdaten beibehalten; Streaming-Abschnitte in der richtigen Reihenfolge zusammensetzen.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
FeldresponseId | Typstring |
FeldmodelVersion | Typstring |
Feldcandidates[].content.parts[] | Typtext|inlineData|functionCall|other part |
Feldcandidates[].finishReason | Typstring |
FeldusageMetadata | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1/chat/completionstexttext| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits gemini-2.5-flash | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits Modellabhängig | Standard— |
Feldmessages[].content | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: Textgespräch | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Text · UTF8-Text
messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages |
Parametermaterial_types | Vertragtext |
Parametermessages | VertragNachrichtenarray mit role/content-Struktur |
Parameterfile_material | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
Parameteroptional_controls | Vertragstream |
Parametercontrol_scope | VertragTextgespräch; stream ist ein boolescher Wert und standardmäßig false. |
Parameteroutput_modalities | Vertragtext |
Parameterhosted_operations | Vertragfalse |
Parametermultimodal_input_binding | Vertragnull |
Methodenaliasnamen: /chat/completions
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.
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
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.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 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 →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model":"gemini-2.5-flash","messages":[{"role":"user","content":"hello"}],"stream":false}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model="gemini-2.5-flash", messages=[{"role":"user","content":"hello"}], stream=False)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\njson oder SSE
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.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldchoices[].index | Typinteger |
Feldchoices[].message.content | Typstring|null |
Feldchoices[].message.tool_calls | Typtool_call[] |
Feldchoices[].message.reasoning_content | Typstring |
Feldchoices[].message.reasoning_details | Typobject|array |
Feldchoices[].finish_reason | Typstring|null |
Feldusage | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1/messagestextjson, sse| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits gemini-2.5-flash | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
Feldmessages[].content | Typstring | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmax_tokens | Typinteger | AnforderungErforderlich | Werte und Limits | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Text · UTF-8-Text
Zeichenfolge messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages, max_tokens |
Parameteroptional_controls | Vertragstream |
Parametermaterial_types | Vertragtext |
Parametertext_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
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
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.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 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 →
{\n "model": "gemini-2.5-flash",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'gemini-2.5-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'gemini-2.5-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON oder SSE
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.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldid | Typstring |
Feldmodel | Typstring |
Feldcontent[] | Typtext|thinking|tool_use|other content block |
Feldstop_reason | Typstring|null |
Feldusage | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
google/gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1/chat/completionstexttext| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits google/gemini-2.5-flash | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
Feldmessages[].role | Typstring | 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— |
Feldmessages[].content | Typstring|content_part[]|null | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].tool_calls | Typtool_call[] | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].tool_call_id | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
Feldmessages[].name | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Feldmessages[].reasoning_content | Typstring | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
Feldmessages[].reasoning_details | Typobject|array | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldmax_tokens | Typinteger | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
Feldmax_completion_tokens | Typinteger | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Feldstream_options.include_usage | Typboolean | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtemperature | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtop_p | Typnumber | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldstop | Typstring|string[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools | Typfunction_tool[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldtools[].type | Typstring | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
Feldtools[].function.name | Typstring | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
Feldtools[].function.description | Typstring | AnforderungOptional | Werte und Limits | Standard— |
Feldtools[].function.parameters | TypJSON_schema | AnforderungOptional | Werte und Limits | Standard— |
Feldtool_choice | Typstring|object | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldparallel_tool_calls | Typboolean | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldresponse_format | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldreasoning_effort | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldreasoning | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldservice_tier | Typstring | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldinstructions | Typstring | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
Feldfunctions | Typfunction[] | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldfunction_call | Typstring|object | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldprompt_cache_options | Typobject | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
Feldmodalities | Typstring[] | AnforderungOptional | Werte und Limits text | Standard— |
Feldprovider | Typobject | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
Feldcache_control.ttl | Typstring | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |
Text · UTF8-Text
messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages |
Parametermaterial_types | Vertragtext |
Parametermessages | VertragNachrichtenarray mit role/content-Struktur |
Parameterfile_material | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
Parameteroptional_controls | Vertragstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Parametercontrol_scope | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
Parameteroutput_modalities | Vertragtext |
Parameterhosted_operations | Vertragfalse |
Parametermultimodal_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.
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
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.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 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 →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "google/gemini-2.5-flash", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='google/gemini-2.5-flash',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='google/gemini-2.5-flash',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson oder SSE
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.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldchoices[].index | Typinteger |
Feldchoices[].message.content | Typstring|null |
Feldchoices[].message.tool_calls | Typtool_call[] |
Feldchoices[].message.reasoning_content | Typstring |
Feldchoices[].message.reasoning_details | Typobject|array |
Feldchoices[].finish_reason | Typstring|null |
Feldusage | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
google/gemini-2.5-flashGemini 2.5 Flash ist Googles stabiles hybrides Denkmodell für multimodale Analyse und Agentenaufgaben. Sein dynamisches Denkbudget lässt sich von 0 bis 24.576 Token einstellen und umfasst einen ausgeschalteten Modus. Text, Bilder, Audio, Video und Dokumente werden zu Text oder strukturierten Ergebnissen, mit einer dokumentierten Eingabegrenze von 1.048.576 Token.
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 ist Googles stabiles hybrides Denkprofil für vielseitige multimodale Arbeit und agentengestützte Werkzeugnutzung. Es bietet Antworten mit und ohne Denken für umfangreiche multimodale Aufgaben mit unterschiedlichen Anforderungen an den Denkumfang. Text, Bilder, Audio und Video tragen zu einer Textantwort bei. Dokumenteingaben werden außerdem in Googles modellspezifischem Cloudprofil beschrieben. Ein hilfreiches Ergebnis kann ein Dokumentvergleich, ein interpretiertes Diagramm, ein Transkript, Code oder ein strukturierter Datensatz sein.
Die Denksteuerung dieser Edition verwendet thinkingBudget. Dynamisches Denken ist der Standard; eine Einstellung von -1 lässt das Modell seinen Denkprozess an die Aufgabenkomplexität anpassen. Ein ausdrückliches Budget kann von null bis 24.576 Token reichen, und null schaltet Denken aus. Wählen Sie ein zum tatsächlichen Problem passendes Budget, statt einer einfachen Kategorisierung und einer Analyse mit mehreren Bedingungen denselben Aufwand zuzuweisen. Der Leitfaden behandelt das Budget als Orientierung, und die native Modellkarte weist darauf hin, dass es möglicherweise nicht genau eingehalten wird.
Definieren Sie für eine Dokument- oder Datenaufgabe die Frage, erforderlichen Felder und Belege, die das Ergebnis begleiten sollen. Vergleichen Sie für einen Anforderungsvergleich zwei Spezifikationen und geben Sie die geänderte Anforderung, ihre Quellpassage und die Auswirkung auf einen benannten Arbeitsablauf zurück. Strukturierte Ausgabe ist hilfreich, wenn jede Feststellung dieselbe Datensatzform benötigt. Erhalten Sie die Unsicherheit, wenn die Quelle mehrere mögliche Werte nennt oder ein Feld offenlässt, statt eine einzelne plausible Antwort zu erzwingen. Prüfen Sie zurückgegebene Werte anhand der bereitgestellten Seiten oder Daten.
Bestimmen Sie bei Bild- oder Audiomaterial das relevante Objekt, die Beschriftung, das Ereignis oder die Aufnahmepassage. Verlangen Sie die benötigte Textart: sichtbare Werte eines Diagramms, eine Ereignisbeschreibung, ein Transkript oder eine Zusammenfassung. Dies sind unterschiedliche Ergebnisse, und die Anweisung sollte sagen, welches erzeugt werden soll. Die gemeinsame native Modellkarte umfasst Flash Image und Flash Audio als separat benannte Fähigkeiten; deren erzeugte Bild- und Sprachausgaben gehören nicht zu diesem stabilen Textprofil.
Googles genaues Cloudprofil dokumentiert PDF- und Klartexteingaben mit schnittstellenspezifischen Grenzen: 50 MB pro über die API importierter PDF-Datei und bis zu 3.000 Seiten pro Datei, mit einer Grenze von 7 MB für Klartextdateien. Dieses Profil beschreibt außerdem ungefähr 45 Minuten Video mit Audio oder eine Stunde ohne Audio sowie ungefähr 8,4 Stunden Audio innerhalb des Eingabebudgets von einer Million Token. Dies sind die genannten Bedingungen der Cloudschnittstelle, getrennt vom allgemeinen Tokenfenster des Modells. Bereiten Sie den relevanten Abschnitt und das Quellformat vor, statt für jeden Dateityp oder Uploadpfad dieselbe Grenze anzunehmen.
Die genaue Gemini API-Tabelle nennt Funktionsaufrufe, Codeausführung, Dateisuche, Such-Grounding, Maps Grounding, URL-Kontext und strukturierte Ausgaben. Definieren Sie Rolle und Parameterform jeder Funktion und setzen Sie mit dem tatsächlich zurückgegebenen Ergebnis fort. Ein Modell kann einen Vorgang anfordern, während die angebundene Anwendung ihn ausführt. Erhalten Sie bei der Fortsetzung einer Denkaufgabe in der zustandslosen Schnittstelle den notwendigen Denksignaturkontext. Eine strukturierte Antwort oder ein Funktionsvorschlag belegt nicht unabhängig den Erfolg eines externen Vorgangs.
Die native Modellkarte nennt 1M Kontext und 64K Textausgabe, während die genaue API-Tabelle 1.048.576 Eingabetoken und 65.536 Ausgabetoken festlegt. Eine Antwortgrenze umfasst Denktoken, weshalb eine zu kleine Grenze die abschließende Antwort abschneiden oder leer lassen kann. Verlangen Sie ein zum Ausgabebudget passendes Ergebnis und verwenden Sie das Denkbudget zur Aufwandssteuerung. Caching, Stapelverarbeitung sowie Flex- und Priority-Verarbeitung sind für dieses Herstellerprofil dokumentiert. Erhalten Sie bei der Vorbereitung mehrerer unabhängiger Datensätze die Elementkennungen.
Die stabile Edition bleibt von Flash Preview-Varianten und späteren Gemini 3-Modellen getrennt. Ihre Karte nennt mögliche Halluzinationen, Grenzen beim Kausalverständnis und komplexen logischen oder kontrafaktischen Denken sowie einen Wissensstand bis Januar 2025. Stellen Sie aktuelle Belege bereit, wenn eine Aufgabe von neueren Informationen abhängt. Prüfen Sie Berechnungen, extrahierte Werte, Transkripte und vorgeschlagenen Code anhand der tatsächlichen Quelle oder des Ausführungsergebnisses. Hybrides Denken ist hilfreich, wenn es dieses konkrete Ergebnis unterstützt, statt seine Prüfung zu ersetzen.
POST /v1/messagestextjson, sse| Feld | Typ | Anforderung | Werte und Limits | Standard |
|---|---|---|---|---|
Feldmodel | Typstring | AnforderungErforderlich | Werte und Limits google/gemini-2.5-flash | Standard— |
Feldmessages | Typmessage[] | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmessages[].role | Typstring | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
Feldmessages[].content | Typstring | AnforderungErforderlich | Werte und Limits | Standard— |
Feldmax_tokens | Typinteger | AnforderungErforderlich | Werte und Limits | Standard— |
Feldstream | Typboolean | AnforderungOptional | Werte und Limits | Standardfalse |
Text · UTF-8-Text
Zeichenfolge messages[].content
| Parameter | Vertrag |
|---|---|
Parametercontent_type | Vertragapplication/json |
Parameterrequired | Vertragmodel, messages, max_tokens |
Parameteroptional_controls | Vertragstream |
Parametermaterial_types | Vertragtext |
Parametertext_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
Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.
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.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 1K Token Eingabe · Cache-Schreiben, 1 Stunde — / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken $0.0006 / 1K Token Ausgabe · Ausgabetoken $0.005 / 1K Token Eingabe · Cache-Lesen $0.00006 / 1K Token Eingabe · Cache-Schreiben $0.0001666666666666666 / 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 →
{\n "model": "google/gemini-2.5-flash",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'google/gemini-2.5-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'google/gemini-2.5-flash', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON oder SSE
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.
Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.
| Feld | Typ |
|---|---|
Feldid | Typstring |
Feldmodel | Typstring |
Feldcontent[] | Typtext|thinking|tool_use|other content block |
Feldstop_reason | Typstring|null |
Feldusage | Typobject |
| 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. |
Ailoot gemini-2.5-flash
Ailoot Ultra gemini-2.5-flash, google/gemini-2.5-flash
/chat/completions
Technisches Beispiel auf Englisch
Extract changes in an approval rule\n\nCompare these rules for a purchase request. [OLD] Any manager may approve expenses up to 500 units. [NEW] A team manager may approve up to 300 units; above that, finance approval is required. Return the changed requirement, source wording and effect on a 450-unit request. Mark any ambiguity about the currency.A structured comparison and a source-backed explanation of the 450-unit case, with the currency gap retained.Check that the example uses the new threshold and does not invent the unit's currency.