Source: https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/
Canonical: https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/
Language: de

# Google: Gemini 2.5 Flash (batch)

[Markdown](https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/index.md) · [JSON](https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/facts.json)

## [Google: Gemini 2.5 Flash (batch)](https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/)

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

- [**Ailoot Ultra · Stapelverarbeitung** `POST /v1/batches` `google/gemini-2.5-flash:batch`](https://ailoot.ai/models/de/google-gemini-2-5-flash-u003a-batch/#method-0)

Über das Modell

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

Gemini 2.5 Flash 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.

**Ailoot Ultra · Stapelverarbeitung** `POST /v1/batches` `google/gemini-2.5-flash:batch`

[`google/gemini-2.5-flash:batch`](https://ailoot.ai/models/de/#m=google%2Fgemini-2.5-flash%3Abatch&route=Ultra&caller=google%2Fgemini-2.5-flash%3Abatch&fmt=batches)

Google /`google/gemini-2.5-flash:batch`

### Start

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

Zulässige Eingaben

Text

Ergebnisse

Text

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

**Ailoot Ultra · Stapelverarbeitung** `POST /v1/batches`

Eingabetypen

`text`

Ausgabetypen

`text`

Ausgabeformat

eingebettetes JSON unter results\[\].response.body

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`endpoint` | Typ`string` | AnforderungErforderlich | Werte und Limits /v1/chat/completions | Standard— |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits google/gemini-2.5-flash:batch | Standard— |
| Feld`requests` | Typ`batch_item[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`requests[].custom_id` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`requests[].body.messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`completion_window` | Typ`string` | AnforderungOptional | Werte und Limits 24h | Standard— |
| Feld`provider` | Typ`object\|null` | AnforderungOptional | Werte und Limits | Standard— |

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragendpoint, model, requests |
| Parameter`material_types` | Vertragtext |
| Parameter`representation` | Vertrageingebettete requests\[\]; jedes Element enthält custom\_id und body |
| Parameter`request_endpoint_profile` | Vertrag/v1/chat/completions |
| Parameter`file_material` | VertragDer Aufrufer kann tatsächliches UTF-8-JSONL lokal in requests\[\] einlesen. Es werden weder ein Upload-Zweck noch input\_file\_id oder eine Dateireferenz verwendet. Fehlendes oder leeres Kundenmaterial stoppt die Vorbereitung vor POST. |
| Parameter`serialization_order` | Vertragendpoint, model, provider (falls angegeben), completion\_window (falls angegeben), requests als letztes Feld |
| Parameter`optional_controls` | Vertragprovider.only, provider.allow\_fallbacks, completion\_window |
| Parameter`schema_scope` | VertragAnfragekörper für Text Chat Completions in der dokumentierten Inline-Batch-Struktur. |

Lebenszyklus: `asynchronous`

`GET /v1/batches/{operation_id}` · die tatsächliche response.id der ursprünglichen Erstellungsantwort; derselbe Nutzer/Schlüssel/dieselbe Gruppe

### Tarife

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

Schnellmodus

Nicht angegeben Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Nicht angegeben Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

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

Preise für explizites Caching

Nicht aktiviert Wenn explizites Caching angefordert wird

#### Ailoot-Tarife

#### Preise nach Konfiguration

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

| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0003** / 1K Token Ausgabe · Ausgabetoken **$0.0025** / 1K Token Eingabe · Cache-Lesen **$0.00006** / 1K Token Eingabe · Cache-Schreiben **—** / 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.0003** / 1K Token Ausgabe · Ausgabetoken **$0.0025** / 1K Token Eingabe · Cache-Lesen **$0.00006** / 1K Token Eingabe · Cache-Schreiben **—** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |

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

### Beispielanfragen

#### Ailoot Ultra · Stapelverarbeitung

curl · gespeicherte BeispieldatenPython HTTP · tatsächliche JSONL-Daten des Kunden

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json
from pathlib import Path
body=json.loads('{"endpoint":"/v1/chat/completions","model":"google/gemini-2.5-flash:batch","requests":[{"custom_id":"req-0001","body":{"messages":[{"role":"user","content":"Hello!"}],"max_tokens":16}}]}')
Path("batch-request.json").write_text(json.dumps(body,ensure_ascii=False),encoding="utf-8")
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/batches \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @batch-request.json -D batch-response-headers.txt -o batch-create-response.json
```

```python
import json, os
from pathlib import Path
from urllib.request import Request, urlopen

def prepare_requests(customer_path):
    path = Path(customer_path)
    if not path.is_file(): raise ValueError("Customer JSONL file is missing")
    items = [json.loads(line) for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not items: raise ValueError("Customer JSONL contains no requests")
    ids = set()
    for item in items:
        if set(item) != {"custom_id", "body"}: raise ValueError("Each item needs custom_id and body")
        cid = item["custom_id"]
        if not isinstance(cid, str) or not cid.strip() or cid in ids: raise ValueError("custom_id must be nonempty and unique")
        ids.add(cid)
        if not isinstance(item["body"], dict) or not item["body"].get("messages"): raise ValueError("Supply actual text messages")
    return {"endpoint":"/v1/chat/completions", "model":"google/gemini-2.5-flash:batch", "requests":items}

if __name__ == "__main__":
    material = os.environ.get("AILOOT_BATCH_REQUESTS_JSONL", "")
    if not material: raise SystemExit("Set AILOOT_BATCH_REQUESTS_JSONL to your actual customer file")
    body = prepare_requests(material)
    key = os.environ.get("AILOOT_API_KEY", "")
    if not key: raise SystemExit("Set AILOOT_API_KEY")
    request = Request("https://api.ailoot.ai/v1/batches", data=json.dumps(body, ensure_ascii=False).encode("utf-8"), headers={"Authorization":"Bearer " + key, "Content-Type":"application/json"}, method="POST")
    with urlopen(request) as response:
        raw = response.read()
        Path("batch-create-response.json").write_bytes(raw)
        print(raw.decode("utf-8"))
```

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · Stapelverarbeitung

eingebettetes JSON unter results\[\].response.body

- `GET /v1/batches/{operation_id}`

##### Auftragsstatus prüfen

curl · Status des ursprünglichen Vorgangs

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
BATCH_OPERATION_ID="$(python3 - <<'PY_ID'
import json
from pathlib import Path
from urllib.parse import quote
response = json.loads(Path("batch-create-response.json").read_text(encoding="utf-8"))
operation = response.get("id")
if not isinstance(operation, str) or not operation: raise SystemExit("No actual original operation ID; preserve the response and do not resubmit")
print(quote(operation, safe=""))
PY_ID
)"
curl --fail-with-body --silent --show-error "https://api.ailoot.ai/v1/batches/$BATCH_OPERATION_ID" \
  -H "Authorization: Bearer $AILOOT_API_KEY" -o batch-status-response.json
```

##### Alle fertiggestellten Ergebnisse aufbewahren

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

Bewahren Sie jedes Ergebnis, jeden Antwort- oder Fehlerinhalt, jede Auswahl und die zusammengefassten Verbrauchsdaten auf.

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

Die ursprüngliche Vorgangs-ID beibehalten. Bei 503 result\_pending\_check gilt X-Should-Retry:false; einen ursprünglichen Batch mit unbekanntem Ausgang niemals erneut einreichen.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`results[].custom_id` | Typstring |
| Feld`results[].response.body.choices[].message.content` | Typstring\|null |
| Feld`results[].error` | Typobject\|null |
| Feld`usage` | Typobject\|null |

### Aliasnamen

#### Modellaliasnamen

**Ailoot Ultra** [`google/gemini-2.5-flash:batch`](https://ailoot.ai/models/de/#m=google%2Fgemini-2.5-flash%3Abatch&route=Ultra&caller=google%2Fgemini-2.5-flash%3Abatch&fmt=batches)

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`google/gemini-2.5-flash:batch`](https://ailoot.ai/models/de/#m=google%2Fgemini-2.5-flash%3Abatch&route=Ultra&caller=google%2Fgemini-2.5-flash%3Abatch&fmt=batches)

FAQ · Google: Gemini 2.5 Flash (batch)

Welche Eingaben und Ergebnisse sind verfügbar?

`POST /v1/batches` · `google/gemini-2.5-flash:batch`: `text` → `text`

Welche Felder verwendet die Anfrage?

`POST /v1/batches` · `google/gemini-2.5-flash:batch`: `endpoint`, `model`, `requests`, `completion_window`, `provider`

Welche Grenzen gelten?

`POST /v1/batches` · `google/gemini-2.5-flash:batch`: `requests.min_items`: `1`

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

## Das Unternehmen und sein Projektportfolio

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

## Tokens mit Rabatt kaufen.

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

Abo

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

Aktionscode bis 50%

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

Ausgaben in der Historie

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

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

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

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

Kommerzielle Anwendung

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

Reseller-Lizenz

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

Dokumente auf der Website

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

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

## Ailoot · Das Unternehmen und sein Projektportfolio





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





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





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