Source: https://ailoot.ai/models/nl/gemini-2-5-flash-lite/
Canonical: https://ailoot.ai/models/nl/gemini-2-5-flash-lite/
Language: nl

# Google: Gemini 2.5 Flash Lite

[Markdown](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/index.md) · [JSON](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/facts.json)

## [Google: Gemini 2.5 Flash Lite](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/)

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

- [**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-0)
- [**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-1)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-2)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-3)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-4)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/gemini-2-5-flash-lite/#method-5)

Over het model

Deze beschrijving gaat over de mogelijkheden van het model. De via Ailoot beschikbare invoer, uitvoer en opties staan hieronder voor de geselecteerde methode.

Gemini 2.5 Flash-Lite is Googles stabiele lichtgewicht profiel voor vertaling, classificatie en eenvoudige gegevensextractie in grote volumes. Het hybride redeneren kan afhankelijk van de taak denken gebruiken of overslaan. Het accepteert tekst, afbeeldingen, audio, video en PDF en produceert tekst. Een bruikbaar resultaat is een categorie, een beknopte vertaling, een uit aangeleverd materiaal geëxtraheerd record of een afgebakende geschreven uitleg.

Definieer voor classificatie de categorieën, beslisregel en antwoordvorm. Behoud de bronidentifier in een resultaat wanneer meerdere onafhankelijke items worden verwerkt. Classificeer bij de indeling van supportberichten een bericht op probleemtype en geef de zin terug die de categorie onderbouwt. Neem een regel op voor ontbrekende of dubbelzinnige onderbouwing, zodat een vloeiend antwoord een verplicht veld niet met een gok vult. De lichtgewicht rol van het model is het nuttigst als de invoer en het vereiste resultaat duidelijk zijn vastgelegd.

Denken staat standaard uit in de gedocumenteerde configuratie van 2.5 Flash-Lite. Googles GenerateContent-denkgids staat een expliciet denkbudget van 512 tot 24.576 tokens toe, nul om denken uit te laten staan en -1 om dynamisch denken aan te vragen. Dit zijn instellingen voor het redeneerbudget, los van de ruimte voor het eindantwoord. Schakel extra redeneren in wanneer voorwaarden bij extractie op elkaar inwerken of een classificatie uitzonderingen kent; een eenvoudige omzetting kan het standaardgedrag zonder denken behouden. De gids merkt op dat het model meer of minder denktokens kan gebruiken dan het gevraagde budget.

Geef voor vertaling de doeltaal, het publiek en de te behouden termen op. Geef aan of het resultaat alleen de vertaling of een gelabeld record moet bevatten. Definieer voor documentextractie de velden en vraag om bronpassages waarmee de uitvoer kan worden gecontroleerd. Onderscheid bij een opname een transcript van een samenvatting en benoem de relevante passage. Afbeeldingen of video kunnen onderbouwing leveren voor een tekstantwoord. Het gewenste resultaat moet duidelijk blijven, ook als de invoer meerdere mediatypen combineert.

De modelspecifieke tabel voor de stabiele versie vermeldt function calling, code-uitvoering, bestandszoekfuncties, search grounding, Maps grounding, URL-context en gestructureerde uitvoer. Functies hebben een duidelijk doel en vastgelegde parameters nodig; de aangesloten toepassing voert de bewerking uit en levert het resultaat. Valideer bij schema-gebaseerde extractie de teruggegeven structuur en vergelijk de waarden met het oorspronkelijke materiaal. Een toolbeslissing of correct gevormd record is alleen nuttig in de context van de bron en werkelijk teruggegeven onderbouwing.

De native kaart vermeldt een contextvenster van 1M en 64K tekstuitvoer. De API-modelpagina specificeert 1.048.576 invoertokens en 65.536 uitvoertokens. Instructies, broninhoud en behouden gesprek gebruiken het invoerbudget, terwijl redeneren en een antwoordlimiet beïnvloeden of het eindresultaat past. Caching, batch, Flex en Priority-verwerking worden voor dit makerprofiel vermeld. Behoud bij herhaalde taken dezelfde categorie- of velddefinities en neem identifiers mee in het resultaat, zodat een latere beoordeling het oorspronkelijke item kan terugvinden.

Dit stabiele profiel staat los van de Preview-varianten van juni en september die elders in de familie worden beschreven. De gedeelde native kaart schrijft verbeteringen in het September Preview, waaronder het volgen van instructies en beknoptheid, specifiek aan die preview toe; ze mogen niet stilzwijgend naar de stabiele identifier worden overgeheveld. Latere Flash-Lite-generaties gebruiken ook andere denkinstellingen en capaciteitstabellen. Behoud de editie en kies de daarvoor gedocumenteerde instellingen, in plaats van de 2.5-budgetten te vervangen door de syntaxis voor denkniveaus van Gemini 3.

De kaart noemt hallucinaties en beperkingen in causaal begrip, complexe logische deductie en contrafeitelijk redeneren en geeft januari 2025 als kennisgrens. Lever actuele onderbouwing of gebruik een gedocumenteerde grounding-workflow als nieuwere feiten van belang zijn. Beoordeel vertalingen op betekenis, geëxtraheerde velden op brononderbouwing en transcripten aan de hand van de audio. Een gericht, klein resultaat maakt deze beoordeling praktisch zonder een verzorgd antwoord te behandelen als bewijs dat het beweerde detail in de bron stond.

Praktische taak

### Praktische taak

Technisch voorbeeld in het Engels

```
Translate a pickup instruction

Translate this pickup instruction into French for a customer: "Collect order AR-62 at reception between 14:00 and 17:00. Bring the pickup code. Do not send the code by email." Keep AR-62 and the time range unchanged. Return only the translation, preserving both the required action and the warning.
```

#### Verwacht resultaat

```
One French translation with the original order ID and time range, without commentary.
```

#### Resultaat controleren

```
Check the order ID, both times and the prohibition on emailing the code against the source.
```

**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-2.5-flash-lite`

[`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages)

Google /`gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst · Afbeeldingen

Resultaten

Tekst

### Beschikbaar in Ailoot · invoer en methoden

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

Invoertypen

`text`, `image`

Uitvoertypen

`text`

Context

1.048.576 tokens

Maximale uitvoer

65.535 tokens

Uitvoerformaat

json of SSE

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten gemini-2.5-flash-lite | Standaard— |
| Veld`messages` | Type`message[]` | VereisteVereist | Waarden en limieten Minimumaantal items: 1 | Standaard— |
| Veld`messages[].role` | Type`string` | VereisteVereist | Waarden en limieten user, assistant | Standaard— |
| Veld`messages[].content` | Type`string\|content_block[]` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`system` | Type`string\|content_block[]` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`max_tokens` | Type`integer` | VereisteVereist | Waarden en limieten Minimum: 1 Limiet geldt voor: exacte bovengrens van het gekozen model/de gekozen modelkaart | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten | Standaardfalse |
| Veld`temperature` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`top_p` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`stop_sequences` | Type`string[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`tools` | Type`tool[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`tools[].name` | Type`string` | VereisteOptioneel | Waarden en limieten Geldt wanneer: tool opgegeven | Standaard— |
| Veld`tools[].description` | Type`string` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`tools[].input_schema` | Type`JSON_schema` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`tool_choice` | Type`object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`thinking.type` | Type`string` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`thinking.budget_tokens` | Type`integer` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`output_config.effort` | Type`string` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`metadata` | Type`object` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`cache_control` | Type`object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |

Combinaties van invoermaterialen

**Tekst** · UTF8-tekst

`messages[].content of een blok met type=text`

**Tekst + afbeelding**

`{type:image,source:{type:base64,media_type,data}} of bron met type=url`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`material_types` | Contracttext, image |
| Parameter`required` | Contractmodel, messages, max\_tokens |
| Parameter`optional_controls` | Contractnull |
| Parameter`content_type` | Contractapplication/json |
| Parameter`text_file_material` | Contractwerkelijke UTF-8-inhoud ingevoegd als tekst; bestands-ID’s/URLs vereisen afzonderlijke exacte ondersteuning |

Levenscyclus: `exact retained published method`

De methodestructuren en ID’s zijn exact; de mogelijkheden van de leverancier staan los van toelating.

### Tarieven

#### Ailoot-methodetarieven

Invoer

US$ 0,0001 */ 1K*

Uitvoer

US$ 0,0004 */ 1K*

Cache lezen

US$ 0,00001 */ 1K*

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

#### Details van het referentietarief

Referentiestaffels op modelniveau veranderen de methodeselectie, kostenramingen of afschrijvingen niet. Voor de actieve kostenberekening gelden de tarieven van de geselecteerde Ailoot-methode.

Referentiestaffels van het model

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieOpenAI Chat · Basistarieven per token | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieOpenAI Chat · Tariefniveau 1 op basis van aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieAnthropic Messages · Basistarieven per token | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieAnthropic Messages · Tariefniveau 1 op basis van aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

### Voorbeeldverzoeken

#### Ailoot · Anthropic Messages

TekstvoorbeeldInvoer, afbeeldingPython SDKNode.js SDKPython-stream

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gemini-2.5-flash-lite", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "gemini-2.5-flash-lite", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="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
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```

```python
import anthropic
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
    model="gemini-2.5-flash-lite",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],
)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(msg.to_dict(mode="json"))
```

```js
import Anthropic from "@anthropic-ai/sdk";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
  model: "gemini-2.5-flash-lite",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    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;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(msg);
```

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

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=anthropic.Anthropic(base_url="https://api.ailoot.ai",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.messages.stream(model='gemini-2.5-flash-lite',max_tokens=1024,messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_message()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Resultaten ophalen en opslaan

#### Ailoot · Anthropic Messages

json of SSE

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar alle inhoudsblokken, handtekeningen van redeneringen en werkelijke toolgebruik-ID’s. Voeg alle SSE-blokdelta’s samen; het eerste tekstblok is niet de volledige uitvoer.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`id` | Typestring |
| Veld`model` | Typestring |
| Veld`content[]` | Typetext\|thinking\|tool\_use\|other content block |
| Veld`stop_reason` | Typestring\|null |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages)

**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-2.5-flash-lite`

[`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=gemini)

Google /`gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst · Afbeeldingen

Resultaten

Tekst

### Beschikbaar in Ailoot · invoer en methoden

**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent`

Invoertypen

`text`, `image`

Uitvoertypen

`text`

Uitvoerformaat

json of ondersteunde streaming

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`path.model` | Type`string` | VereisteVereist | Waarden en limieten gemini-2.5-flash-lite | Standaard— |
| Veld`contents` | Type`content[]` | VereisteVereist | Waarden en limieten Minimumaantal items: 1 | Standaard— |
| Veld`contents[].role` | Type`string` | VereisteOptioneel | Waarden en limieten user, model | Standaard— |
| Veld`contents[].parts` | Type`part[]` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`systemInstruction` | Type`content` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`generationConfig.maxOutputTokens` | Type`integer` | VereisteOptioneel | Waarden en limieten Minimum: 1 Afhankelijk van het model | Standaard— |
| Veld`generationConfig.temperature` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`generationConfig.topP` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`generationConfig.topK` | Type`integer` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`generationConfig.stopSequences` | Type`string[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`generationConfig.thinkingConfig.includeThoughts` | Type`boolean` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`generationConfig.thinkingConfig.thinkingBudget` | Type`integer` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`tools[].functionDeclarations` | Type`function_declaration[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`toolConfig.functionCallingConfig.mode` | Type`string` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`safetySettings` | Type`object[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`sessionId` | Type`string` | VereisteOptioneel | Waarden en limieten | Standaard— |

Combinaties van invoermaterialen

**Tekst** · UTF8-tekst

`contents[].parts[].text`

**Tekst + afbeelding**

`parts[].inlineData={mimeType,data}`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`material_types` | Contracttext, image |
| Parameter`required` | Contractcontents |
| Parameter`optional_controls` | Contractnull |
| Parameter`content_type` | Contractapplication/json |
| Parameter`text_file_material` | Contractwerkelijke UTF-8-inhoud ingevoegd als tekst; bestands-ID’s/URLs vereisen afzonderlijke exacte ondersteuning |

Levenscyclus: `exact retained published method`

De methodestructuren en ID’s zijn exact; de mogelijkheden van de leverancier staan los van toelating.

### Tarieven

#### Ailoot-methodetarieven

Invoer

US$ 0,0001 */ 1K*

Uitvoer

US$ 0,0004 */ 1K*

Cache lezen

US$ 0,00001 */ 1K*

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

#### Details van het referentietarief

Referentiestaffels op modelniveau veranderen de methodeselectie, kostenramingen of afschrijvingen niet. Voor de actieve kostenberekening gelden de tarieven van de geselecteerde Ailoot-methode.

Referentiestaffels van het model

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieOpenAI Chat · Basistarieven per token | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieOpenAI Chat · Tariefniveau 1 op basis van aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieAnthropic Messages · Basistarieven per token | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieAnthropic Messages · Tariefniveau 1 op basis van aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

### Voorbeeldverzoeken

#### Ailoot · Gemini generateContent

TekstvoorbeeldInvoer, afbeeldingPython SDKNode.js SDKPython-stream

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"contents": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["contents"]=[{"role":"user","parts":[{"text":"Summarize this material and quote supporting source passages.\n\n"+text}]}]
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-2.5-flash-lite:generateContent \
  -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"contents": [{"role": "user", "parts": [{"text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="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
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["contents"][0]["parts"].append({"inlineData":{"mimeType":mime,"data":b64}})
Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-2.5-flash-lite:generateContent \
  -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```

```python
from google import genai
from google.genai import types
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = genai.Client(
    api_key=os.environ["AILOOT_API_KEY"],
    http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),
)
resp = client.models.generate_content(model="gemini-2.5-flash-lite", contents="Explain the difference between an observation and a hypothesis in three sentences.")
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(resp.to_json_dict())
```

```js
import { GoogleGenAI } from "@google/genai";

if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const ai = new GoogleGenAI({ apiKey: process.env.AILOOT_API_KEY, httpOptions: { baseUrl: "https://api.ailoot.ai" } });
const resp = await ai.models.generateContent({ model: "gemini-2.5-flash-lite", contents: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";

function saveResult(data, stem = "result") {
  writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
  console.log(JSON.stringify(data, null, 2));
  const saveBlob = (encoded, suffix, label) => {
    const raw = Buffer.from(encoded, "base64");
    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;
    const file = `${stem}-${label}.${ext}`;
    writeFileSync(file, raw); console.log("Saved", file);
  };
  for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
  for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
  for (const [i, item] of (data.output || []).entries()) {
    console.log("Output", i, JSON.stringify(item));
    if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
  }
  for (const [ci, candidate] of (data.candidates || []).entries()) {
    for (const [pi, part] of (candidate.content?.parts || []).entries()) {
      console.log("Candidate/part", ci, pi, JSON.stringify(part));
      const blob = part.inlineData || part.inline_data;
      if (blob?.data) {
        const mime = blob.mimeType || blob.mime_type;
        const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
        saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
      }
    }
  }
}

saveResult(resp);
```

```python
from google import genai
from google.genai import types
import os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=genai.Client(api_key=os.environ["AILOOT_API_KEY"],http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

count=0
with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
    for chunk in client.models.generate_content_stream(model='gemini-2.5-flash-lite',contents="Explain observations and hypotheses in three sentences."):
        payload=chunk.to_json_dict()
        log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
        save_result(payload,"stream-chunk-"+str(count))
        count+=1
```

### Resultaten ophalen en opslaan

#### Ailoot · Gemini generateContent

json of ondersteunde streaming

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar alle kandidaten en onderdelen, inclusief functieaanroepen, handtekeningen van redeneringen en verbruiksgegevens; voeg streamingfragmenten in de juiste volgorde samen.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`responseId` | Typestring |
| Veld`modelVersion` | Typestring |
| Veld`candidates[].content.parts[]` | Typetext\|inlineData\|functionCall\|other part |
| Veld`candidates[].finishReason` | Typestring |
| Veld`usageMetadata` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=gemini)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=gemini), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite)

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gemini-2.5-flash-lite`

[`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=chat)

Google /`gemini-2.5-flash-lite`

Model-ID

- `gemini-2.5-flash-lite`
- `google/gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst

Resultaten

Tekst

### Beschikbaar in Ailoot · invoer en methoden

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

Invoertypen

`text`

Uitvoertypen

`text`

Uitvoerformaat

json of SSE

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten gemini-2.5-flash-lite | Standaard— |
| Veld`messages` | Type`message[]` | VereisteVereist | Waarden en limieten Minimumaantal items: 1 | Standaard— |
| Veld`messages[].role` | Type`string` | VereisteVereist | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`messages[].content` | Type`string` | VereisteOptioneel | Waarden en limieten Geldt wanneer: Tekstgesprek | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten | Standaardfalse |

Combinaties van invoermaterialen

**Tekst** · UTF8-tekst

`messages[].content`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, messages |
| Parameter`material_types` | Contracttext |
| Parameter`messages` | Contractberichtenarray met de structuur role/content |
| Parameter`file_material` | Contractwerkelijk UTF-8-document ingevoegd als letterlijke tekst; er wordt geen bestands-ID afgeleid |
| Parameter`optional_controls` | Contractstream |
| Parameter`control_scope` | ContractTekstgesprek; stream is een booleaanse waarde en is standaard false. |
| Parameter`output_modalities` | Contracttext |
| Parameter`hosted_operations` | Contractfalse |
| Parameter`multimodal_input_binding` | Contractnull |

Methodealiasnamen: `/chat/completions`

Levenscyclus: `synchronous_or_streamed`

Stuur het exacte model-ID mee met messages.

Contextlengte is geen uitvoerlimiet.

Een tekstbestand kan letterlijke tekst aanleveren; beeld-, audio- en bestandsobjectinvoer vereisen een exacte koppeling.

### Tarieven

Tariefverwijzingen voegen geen verzoekopties toe. Ondersteunde parameters staan bij de geselecteerde methode.

Snelle modus

Standaardtarief Wanneer de snelle modus is geselecteerd

Flexmodus

Standaardtarief Wanneer de modus flex is geselecteerd

Maximale redeneerinspanning

Standaardtarief Wanneer bij maximale redeneerinspanning de default-aanpassing wordt gebruikt

Tarieven voor expliciete caching

Niet ingeschakeld Wanneer expliciete caching wordt aangevraagd

#### Ailoot-tarieven

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieBasistarieven voor tokens | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieNiveau 1 voor aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

### Voorbeeldverzoeken

#### Ailoot Ultra · OpenAI Chat

curlPython SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"gemini-2.5-flash-lite","messages":[{"role":"user","content":"hello"}],"stream":false}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="gemini-2.5-flash-lite", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

### Resultaten ophalen en opslaan

#### Ailoot Ultra · OpenAI Chat

json of SSE

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar elke keuze en de bijbehorende inhoud, toolaanroepen en redeneringen. Voeg in SSE delta’s samen per keuze-/toolindex en bewaar de uiteindelijke reden van beëindiging en de verbruiksgegevens.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`choices[].index` | Typeinteger |
| Veld`choices[].message.content` | Typestring\|null |
| Veld`choices[].message.tool_calls` | Typetool\_call\[\] |
| Veld`choices[].message.reasoning_content` | Typestring |
| Veld`choices[].message.reasoning_details` | Typeobject\|array |
| Veld`choices[].finish_reason` | Typestring\|null |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=chat), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=chat)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=chat), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gemini-2.5-flash-lite`

[`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages)

Google /`gemini-2.5-flash-lite`

Model-ID

- `gemini-2.5-flash-lite`
- `google/gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst

Resultaten

json · sse

### Beschikbaar in Ailoot · invoer en methoden

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

Invoertypen

`text`

Uitvoertypen

`json`, `sse`

Uitvoerformaat

JSON of SSE

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten gemini-2.5-flash-lite | Standaard— |
| Veld`messages` | Type`message[]` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`messages[].role` | Type`string` | VereisteVereist | Waarden en limieten user, assistant | Standaard— |
| Veld`messages[].content` | Type`string` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`max_tokens` | Type`integer` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten | Standaardfalse |

Combinaties van invoermaterialen

**Tekst** · UTF-8-tekst

`messages[].content als tekenreeks`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, messages, max\_tokens |
| Parameter`optional_controls` | Contractstream |
| Parameter`material_types` | Contracttext |
| Parameter`text_file_material` | ContractLees het werkelijke UTF-8-document en plaats de tekst ervan in de aangegeven invoer of in de inhoudstekenreeks van een bericht. |

Levenscyclus: `synchronous_or_streamed`

### Tarieven

Tariefverwijzingen voegen geen verzoekopties toe. Ondersteunde parameters staan bij de geselecteerde methode.

Snelle modus

Standaardtarief Wanneer de snelle modus is geselecteerd

Flexmodus

Standaardtarief Wanneer de modus flex is geselecteerd

Maximale redeneerinspanning

Standaardtarief Wanneer bij maximale redeneerinspanning de default-aanpassing wordt gebruikt

Tarieven voor expliciete caching

Niet ingeschakeld Wanneer expliciete caching wordt aangevraagd

#### Ailoot-tarieven

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieBasistarieven voor tokens | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieNiveau 1 voor aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

### Voorbeeldverzoeken

#### Ailoot Ultra · Anthropic Messages

Volledige minimale JSON-bodycurl · gebruik je UTF-8-documentPython · sla het volledige resultaat op

```json
{
  "model": "gemini-2.5-flash-lite",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

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

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'gemini-2.5-flash-lite', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path

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

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

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

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

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

### Resultaten ophalen en opslaan

#### Ailoot Ultra · Anthropic Messages

JSON of SSE

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar alle inhoudsblokken, handtekeningen van redeneringen en werkelijke toolgebruik-ID’s. Voeg alle SSE-blokdelta’s samen; het eerste tekstblok is niet de volledige uitvoer.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`id` | Typestring |
| Veld`model` | Typestring |
| Veld`content[]` | Typetext\|thinking\|tool\_use\|other content block |
| Veld`stop_reason` | Typestring\|null |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages)

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-2.5-flash-lite`

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=chat)

Google /`google/gemini-2.5-flash-lite`

Model-ID

- `gemini-2.5-flash-lite`
- `google/gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst

Resultaten

Tekst

### Beschikbaar in Ailoot · invoer en methoden

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

Invoertypen

`text`

Uitvoertypen

`text`

Uitvoerformaat

json of SSE

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten google/gemini-2.5-flash-lite | Standaard— |
| Veld`messages` | Type`message[]` | VereisteVereist | Waarden en limieten Minimumaantal items: 1 | Standaard— |
| Veld`messages[].role` | Type`string` | VereisteVereist | Waarden en limieten Voorbeelden: system, user, assistant, tool, function Voorwaarden: Deze rollen worden expliciet weergegeven door compatibiliteitstypen in de broncode; de exacte rollenverzameling van het model blijft modelspecifiek. Afhankelijk van het model | Standaard— |
| Veld`messages[].content` | Type`string\|content_part[]\|null` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`messages[].tool_calls` | Type`tool_call[]` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`messages[].tool_call_id` | Type`string` | VereisteOptioneel | Waarden en limieten Geldt wanneer: role=tool; gebruik het werkelijk teruggegeven ID | Standaard— |
| Veld`messages[].name` | Type`string` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`messages[].reasoning_content` | Type`string` | VereisteOptioneel | Waarden en limieten Geldt wanneer: Stuur de werkelijk teruggegeven redeneringen terug wanneer dit model ze gebruikt | Standaard— |
| Veld`messages[].reasoning_details` | Type`object\|array` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`max_tokens` | Type`integer` | VereisteOptioneel | Waarden en limieten Minimum: 1 Afhankelijk van het model | Standaard— |
| Veld`max_completion_tokens` | Type`integer` | VereisteOptioneel | Waarden en limieten Minimum: 1 Afhankelijk van het model | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten | Standaardfalse |
| Veld`stream_options.include_usage` | Type`boolean` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`temperature` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`top_p` | Type`number` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`stop` | Type`string\|string[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`tools` | Type`function_tool[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`tools[].type` | Type`string` | VereisteOptioneel | Waarden en limieten function Afhankelijk van het model | Standaard— |
| Veld`tools[].function.name` | Type`string` | VereisteVereist | Waarden en limieten Geldt wanneer: functietool opgegeven | Standaard— |
| Veld`tools[].function.description` | Type`string` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`tools[].function.parameters` | Type`JSON_schema` | VereisteOptioneel | Waarden en limieten | Standaard— |
| Veld`tool_choice` | Type`string\|object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`parallel_tool_calls` | Type`boolean` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`response_format` | Type`object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`reasoning_effort` | Type`string` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`reasoning` | Type`object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`service_tier` | Type`string` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`instructions` | Type`string` | VereisteOptioneel | Waarden en limieten Compatibiliteitsveld | Standaard— |
| Veld`functions` | Type`function[]` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`function_call` | Type`string\|object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`prompt_cache_options` | Type`object` | VereisteOptioneel | Waarden en limieten Afhankelijk van het model | Standaard— |
| Veld`modalities` | Type`string[]` | VereisteOptioneel | Waarden en limieten text | Standaard— |
| Veld`provider` | Type`object` | VereisteOptioneel | Waarden en limieten Voorwaarden: provider.options wordt op deze Ultra-tekstroute geweigerd | Standaard— |
| Veld`cache_control.ttl` | Type`string` | VereisteOptioneel | Waarden en limieten Voorwaarden: 1h wordt op de daadwerkelijke locaties voor promptcaching geweigerd | Standaard— |

Combinaties van invoermaterialen

**Tekst** · UTF8-tekst

`messages[].content`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, messages |
| Parameter`material_types` | Contracttext |
| Parameter`messages` | Contractberichtenarray met de structuur role/content |
| Parameter`file_material` | Contractwerkelijk UTF-8-document ingevoegd als letterlijke tekst; er wordt geen bestands-ID afgeleid |
| Parameter`optional_controls` | Contractstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | Contractmodelspecifiek; functietools van de gebruiker verschillen van gehoste tools |
| Parameter`output_modalities` | Contracttext |
| Parameter`hosted_operations` | Contractfalse |
| Parameter`multimodal_input_binding` | Contractnull |

Levenscyclus: `synchronous_or_streamed`

Stuur het exacte model-ID mee met messages.

Contextlengte is geen uitvoerlimiet.

Een tekstbestand kan letterlijke tekst aanleveren; beeld-, audio- en bestandsobjectinvoer vereisen een exacte koppeling.

### Tarieven

Tariefverwijzingen voegen geen verzoekopties toe. Ondersteunde parameters staan bij de geselecteerde methode.

Snelle modus

Standaardtarief Wanneer de snelle modus is geselecteerd

Flexmodus

Standaardtarief Wanneer de modus flex is geselecteerd

Maximale redeneerinspanning

Standaardtarief Wanneer bij maximale redeneerinspanning de default-aanpassing wordt gebruikt

Tarieven voor expliciete caching

Niet ingeschakeld Wanneer expliciete caching wordt aangevraagd

#### Ailoot-tarieven

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieBasistarieven voor tokens | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieNiveau 1 voor aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

### Voorbeeldverzoeken

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPython-stream

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "google/gemini-2.5-flash-lite", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='google/gemini-2.5-flash-lite',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

```python
from openai import OpenAI
import os
from pathlib import Path

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

with client.chat.completions.stream(model='google/gemini-2.5-flash-lite',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_completion()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### Resultaten ophalen en opslaan

#### Ailoot Ultra · OpenAI Chat

json of SSE

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar elke keuze en de bijbehorende inhoud, toolaanroepen en redeneringen. Voeg in SSE delta’s samen per keuze-/toolindex en bewaar de uiteindelijke reden van beëindiging en de verbruiksgegevens.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`choices[].index` | Typeinteger |
| Veld`choices[].message.content` | Typestring\|null |
| Veld`choices[].message.tool_calls` | Typetool\_call\[\] |
| Veld`choices[].message.reasoning_content` | Typestring |
| Veld`choices[].message.reasoning_details` | Typeobject\|array |
| Veld`choices[].finish_reason` | Typestring\|null |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=chat), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=chat)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=chat), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-2.5-flash-lite`

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages)

Google /`google/gemini-2.5-flash-lite`

Model-ID

- `gemini-2.5-flash-lite`
- `google/gemini-2.5-flash-lite`

### Aan de slag

Gemini 2.5 Flash-Lite is Googles stabiele multimodale tekstmodel voor veelvuldige classificatie, vertaling en eenvoudige extractie. Denken staat standaard uit en kan worden ingeschakeld met een redeneerbudget van 512–24.576 tokens. Het accepteert tekst en media, met tools, gestructureerde uitvoer en een invoerlimiet van 1.048.576 tokens.

Toegestane invoer

Tekst

Resultaten

json · sse

### Beschikbaar in Ailoot · invoer en methoden

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

Invoertypen

`text`

Uitvoertypen

`json`, `sse`

Uitvoerformaat

JSON of SSE

| Veld | Type | Vereiste | Waarden en limieten | Standaard |
| --- | --- | --- | --- | --- |
| Veld`model` | Type`string` | VereisteVereist | Waarden en limieten google/gemini-2.5-flash-lite | Standaard— |
| Veld`messages` | Type`message[]` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`messages[].role` | Type`string` | VereisteVereist | Waarden en limieten user, assistant | Standaard— |
| Veld`messages[].content` | Type`string` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`max_tokens` | Type`integer` | VereisteVereist | Waarden en limieten | Standaard— |
| Veld`stream` | Type`boolean` | VereisteOptioneel | Waarden en limieten | Standaardfalse |

Combinaties van invoermaterialen

**Tekst** · UTF-8-tekst

`messages[].content als tekenreeks`

Methodeparameters en levenscyclus

| Parameter | Contract |
| --- | --- |
| Parameter`content_type` | Contractapplication/json |
| Parameter`required` | Contractmodel, messages, max\_tokens |
| Parameter`optional_controls` | Contractstream |
| Parameter`material_types` | Contracttext |
| Parameter`text_file_material` | ContractLees het werkelijke UTF-8-document en plaats de tekst ervan in de aangegeven invoer of in de inhoudstekenreeks van een bericht. |

Levenscyclus: `synchronous_or_streamed`

### Tarieven

Tariefverwijzingen voegen geen verzoekopties toe. Ondersteunde parameters staan bij de geselecteerde methode.

Snelle modus

Standaardtarief Wanneer de snelle modus is geselecteerd

Flexmodus

Standaardtarief Wanneer de modus flex is geselecteerd

Maximale redeneerinspanning

Standaardtarief Wanneer bij maximale redeneerinspanning de default-aanpassing wordt gebruikt

Tarieven voor expliciete caching

Niet ingeschakeld Wanneer expliciete caching wordt aangevraagd

#### Ailoot-tarieven

#### Prijzen per configuratie

Koppel elke kostenpost aan de getoonde voorwaarden. Gebruik één tarief voor elke groep alternatieve configuraties.

| Configuratie | Tariefstaffel | Contexttokens, meer dan | Contexttokens, tot en met | Kosten |
| --- | --- | --- | --- | --- |
| ConfiguratieBasistarieven voor tokens | TariefstaffelBasistarief | Contexttokens, meer dan— | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |
| ConfiguratieNiveau 1 voor aanvraaglengte | Tariefstaffel— | Contexttokens, meer dan0 | Contexttokens, tot en metGeen bovengrens | Kosten Invoer · Invoertokens **$0.0002** / 1K tokens Uitvoer · Uitvoertokens **$0.0008** / 1K tokens Invoer · Cache lezen **$0.00002** / 1K tokens Invoer · Cache schrijven **$0.0001666666666666666** / 1K tokens Invoer · Cache schrijven, 1 uur **—** / 1K tokens |

Ailoot reserveert vóór een verzoek een geschat bedrag. Na het resultaat worden de uiteindelijke kosten afgerekend op basis van het gemeten verbruik. Bij streaming gebeurt de afrekening op basis van de definitieve verbruiksregistratie. [Zo werken reservering en afrekening →](https://ailoot.ai/docs/nl/billing/reserve/)

### Voorbeeldverzoeken

#### Ailoot Ultra · Anthropic Messages

Volledige minimale JSON-bodycurl · gebruik je UTF-8-documentPython · sla het volledige resultaat op

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

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

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'google/gemini-2.5-flash-lite', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path

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

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

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

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

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

### Resultaten ophalen en opslaan

#### Ailoot Ultra · Anthropic Messages

JSON of SSE

##### Alle voltooide resultaten bewaren

Bewaar elk volledig teruggegeven antwoord, bestand en inhoudsonderdeel.

Bewaar alle inhoudsblokken, handtekeningen van redeneringen en werkelijke toolgebruik-ID’s. Voeg alle SSE-blokdelta’s samen; het eerste tekstblok is niet de volledige uitvoer.

##### Als het oorspronkelijke antwoord moet worden gecontroleerd

Bewaar aanvraag-/antwoord-ID’s en headers. Er wordt geen algemene URL meegeleverd om teksttaken op te halen.

Antwoordvelden

| Veld | Type |
| --- | --- |
| Veld`id` | Typestring |
| Veld`model` | Typestring |
| Veld`content[]` | Typetext\|thinking\|tool\_use\|other content block |
| Veld`stop_reason` | Typestring\|null |
| Veld`usage` | Typeobject |

Fouten en vervolgstappen

| Antwoord | Voorwaarde | Volgende stap |
| --- | --- | --- |
| Antwoord400 · `invalid_request_error` | VoorwaardeVerplichte velden, de materiaalrepresentatie of een parameterwaarde zijn ongeldig | Volgende stapCorrigeer de aangegeven velden vóór een nieuwe aanmaakaanvraag. |

### Aliasnamen

#### Modelaliasnamen

<strong>Ailoot</strong> [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages)
**Ailoot Ultra** [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages), [`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages)

#### Aliasnamen voor methodepaden

`/chat/completions`

#### Gerelateerde aanroeper-ID’s

[`google/gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=google%2Fgemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Core&caller=gemini-2.5-flash-lite&fmt=messages), [`gemini-2.5-flash-lite`](https://ailoot.ai/models/nl/#m=google%2Fgemini-2.5-flash-lite&route=Ultra&caller=gemini-2.5-flash-lite&fmt=messages)

FAQ · Google: Gemini 2.5 Flash Lite

Welke invoer en resultaten zijn beschikbaar?

`POST /v1/messages` · `gemini-2.5-flash-lite`: `text`, `image` → `text` `POST /v1beta/models/{model}:generateContent` · `gemini-2.5-flash-lite`: `text`, `image` → `text` `POST /v1/chat/completions` · `gemini-2.5-flash-lite`: `text` → `text` `POST /v1/messages` · `gemini-2.5-flash-lite`: `text` → `json`, `sse` `POST /v1/chat/completions` · `google/gemini-2.5-flash-lite`: `text` → `text` `POST /v1/messages` · `google/gemini-2.5-flash-lite`: `text` → `json`, `sse`

Welke velden gebruikt het verzoek?

`POST /v1/messages` · `gemini-2.5-flash-lite`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1beta/models/{model}:generateContent` · `gemini-2.5-flash-lite`: `contents`, `systemInstruction`, `sessionId` `POST /v1/chat/completions` · `gemini-2.5-flash-lite`: `model`, `messages`, `stream` `POST /v1/messages` · `gemini-2.5-flash-lite`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `google/gemini-2.5-flash-lite`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `google/gemini-2.5-flash-lite`: `model`, `messages`, `max_tokens`, `stream`

Welke limieten gelden?

`POST /v1/messages` · `gemini-2.5-flash-lite`: `ctx`: `1048576`; `max_out`: `65535`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1beta/models/{model}:generateContent` · `gemini-2.5-flash-lite`: `contents.min_items`: `1` `POST /v1/chat/completions` · `gemini-2.5-flash-lite`: `messages.min_items`: `1` `POST /v1/chat/completions` · `google/gemini-2.5-flash-lite`: `messages.min_items`: `1`

Verbind Ailoot met Claude Code, OpenCode, Hermes of je eigen applicatie.

## Het bedrijf en zijn projectenportefeuille

Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.

## Koop tokens met korting.

Abonnementsvoordeel voor regelmatig gebruik. Promotiecodes geven tot 50% korting op tokens.

Abonnement

Kies een abonnement met korting voor je terugkerende verzoeken.

Promotiecode tot 50%

Vul de code bij aankoop in. De prijs wordt volgens de lopende actie herberekend.

Kosten in de geschiedenis

Model, tokens en bedrag worden per verzoek bewaard.

[Kies een abonnement](https://ailoot.ai/docs/nl/billing/subscriptions/) · [Bekijk modelprijzen](https://ailoot.ai/models/nl/)

## Verbind de API met het product dat je verkoopt.

SaaS, apps en bots volgens de openbare aanbodvoorwaarden en licentieovereenkomst van Ailoot. Vraag voor doorverkoop een resellerlicentie aan.

Commerciële applicatie

Voeg tekst-, beeld-, video- en geluidsgeneratie aan betaalde functies van je service toe.

Resellerlicentie

Stuur een projectbeschrijving en toegangsschema. Vraag schriftelijke voorwaarden voor gebruik en doorverkoop.

Documenten op de site

Aanbodvoorwaarden, licentieovereenkomst en gegevensbeleid zijn vóór het verbinden beschikbaar.

[Vraag een resellerlicentie aan](mailto:support@ailoot.ai) · [Aanbodvoorwaarden en licentieovereenkomst](https://ailoot.ai/legal/offer?lang=nl)

## Ailoot · Het bedrijf en zijn projectenportefeuille





Ailoot bouwt op opgebouwde operationele ervaring, een groot klantenbestand, een stabiele dienst en doorlopende KPI-controle.





Het bedrijf en zijn projectenportefeuille: miljoenen klanten; maandelijkse verkopen in de miljarden.





Ailoot gebruikt die operationele ervaring voor API-toegang tot AI-functies in klantproducten, agents, applicaties en automatiseringen.