Source: https://ailoot.ai/models/en/gemini-3-7-flash-tiered/ Canonical: https://ailoot.ai/models/en/gemini-3-7-flash-tiered/ Language: en # Gemini 3.7 Flash Tiered [Markdown](https://ailoot.ai/models/en/gemini-3-7-flash-tiered/index.md) · [JSON](https://ailoot.ai/models/en/gemini-3-7-flash-tiered/facts.json) ## [Gemini 3.7 Flash Tiered](https://ailoot.ai/models/en/gemini-3-7-flash-tiered/) A multimodal Google model with configurable reasoning for coding, video understanding and multi-step workflows. - [**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/gemini-3-7-flash-tiered/#method-0) - [**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/gemini-3-7-flash-tiered/#method-1) About the model This description covers the model’s capabilities. Available in Ailoot inputs, outputs and options are listed for the selected method below. Gemini 3.7 Flash develops the line of multimodal reasoning models. It is based on Gemini 3.6 Flash and includes changes to the reasoning foundation as well as support for agentic video understanding. Workflows include coding, complex video analysis and processes with several stages. #### Input and text results According to Google's specifications, the model understands **text, images, video, audio and PDF**. In Ailoot API's current catalogue, text methods declare **text and images** as input and text as output. Video, audio and PDF are not included in this input set. The maximum request size is **1,048,576 input tokens**, and response **65,536 output tokens**. The response remains text; independent image or audio generation is not supported for this version. #### Controlling reasoning Thinking has three supported levels: **`low`, `medium` and `high`**. In Google's described base-model mode, the default level is `medium`. These values describe Google's base model; the mode and availability of control through Ailoot API depend on the selected method and model variant. They allow the intensity of additional reasoning to be selected. Gemini 3.7 Flash **does not support** `minimal`: that setting causes an error. Reasoning settings affect the model's operating mode but do not change its supported output modality. Function calling, code execution and structured responses are provided for sequential task execution. The model can use context caching, file search, search grounding, Google Maps and URL contents. Batch processing is supported. Computer interface control is designated as a preview capability; using it requires support in the selected method. #### Where the boundary lies The stable `gemini-3.7-flash` version was published in August 2026. The manufacturer specifies March 2026 as the built-in knowledge cutoff, with a qualification: knowledge in some areas may remain at January 2025 levels. Working with external data and understanding supplied material differ from information the model already knows. The model can fabricate facts, execute some requests slowly or time out. It is intended for complex workflows, but the ability to complete an individual action does not replace verification of the full workflow's result. When multimodal inputs are used, the outcome is textual conclusions about the material's contents, not a new media file. Practical task ### Trace a multi-stage processing failure Technical example in English ``` Trace a multi-stage processing failure Analyze this supplied event log: 09:00 file accepted; 09:01 parse completed with 14 rows; 09:02 validation rejected row 8; 09:03 export skipped because validation failed. The user reports that no export exists. Identify the first failed stage, distinguish successful stages and propose the next diagnostic using only the log. ``` #### Expected result ``` A stage-status table, the earliest failure and one targeted next diagnostic. ``` #### Check the result ``` Check that the answer attributes the missing export to the recorded validation failure without inventing the reason row 8 failed. ``` **Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-3.7-flash-tiered` [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=messages) Google /`gemini-3.7-flash-tiered` ### Overview A multimodal Google model with configurable reasoning for coding, video understanding and multi-step workflows. Accepted inputs Text · Images Results Text ### Available in Ailoot · inputs & methods **Ailoot · Anthropic Messages** `POST /v1/messages` Input types `text`, `image` Output types `text` Context 1,048,576 tokens Maximum output 65,536 tokens Output format json or SSE | Field | Type | Requirement | Values & limits | Default | | --- | --- | --- | --- | --- | | Field`model` | Type`string` | RequirementRequired | Values & limits gemini-3.7-flash-tiered | Default— | | Field`messages` | Type`message[]` | RequirementRequired | Values & limits Minimum items: 1 | Default— | | Field`messages[].role` | Type`string` | RequirementRequired | Values & limits user, assistant | Default— | | Field`messages[].content` | Type`string\|content_block[]` | RequirementRequired | Values & limits | Default— | | Field`system` | Type`string\|content_block[]` | RequirementOptional | Values & limits | Default— | | Field`max_tokens` | Type`integer` | RequirementRequired | Values & limits Minimum: 1 Limit applies to: exact selected model/card ceiling | Default— | | Field`stream` | Type`boolean` | RequirementOptional | Values & limits | Defaultfalse | | Field`temperature` | Type`number` | RequirementOptional | Values & limits Model-specific | Default— | | Field`top_p` | Type`number` | RequirementOptional | Values & limits Model-specific | Default— | | Field`stop_sequences` | Type`string[]` | RequirementOptional | Values & limits Model-specific | Default— | | Field`tools` | Type`tool[]` | RequirementOptional | Values & limits Model-specific | Default— | | Field`tools[].name` | Type`string` | RequirementOptional | Values & limits Applies when: tool supplied | Default— | | Field`tools[].description` | Type`string` | RequirementOptional | Values & limits | Default— | | Field`tools[].input_schema` | Type`JSON_schema` | RequirementOptional | Values & limits | Default— | | Field`tool_choice` | Type`object` | RequirementOptional | Values & limits Model-specific | Default— | | Field`thinking.type` | Type`string` | RequirementOptional | Values & limits Model-specific | Default— | | Field`thinking.budget_tokens` | Type`integer` | RequirementOptional | Values & limits Model-specific | Default— | | Field`output_config.effort` | Type`string` | RequirementOptional | Values & limits Model-specific | Default— | | Field`metadata` | Type`object` | RequirementOptional | Values & limits | Default— | | Field`cache_control` | Type`object` | RequirementOptional | Values & limits Model-specific | Default— | Input material combinations **Text** · UTF8 text `messages[].content or type=text block` **Text + image** `{type:image,source:{type:base64,media_type,data}} or source type=url` Method parameters and lifecycle | 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` | Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support | Lifecycle: `exact retained published method` Method shapes and IDs are exact; supplier capability is separate from admission. ### Pricing #### Ailoot method rates Input $0.00075 */ 1K* Output $0.00375 */ 1K* Cache read $0.000075 */ 1K* Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. [How reservation and settlement work →](https://ailoot.ai/docs/en/billing/reserve/) ### Example requests #### Ailoot · Anthropic Messages Text exampleImage inputPython 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-3.7-flash-tiered", "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-3.7-flash-tiered", "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-3.7-flash-tiered", 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-3.7-flash-tiered", 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-3.7-flash-tiered',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") ``` ### Receive and save results #### Ailoot · Anthropic Messages json or SSE ##### Keep all completed results Keep every complete returned response, file and content part. Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output. ##### If the original response needs checking Keep request/response IDs and headers. No generic text job retrieval URL is supplied. Response fields | Field | Type | | --- | --- | | Field`id` | Typestring | | Field`model` | Typestring | | Field`content[]` | Typetext\|thinking\|tool\_use\|other content block | | Field`stop_reason` | Typestring\|null | | Field`usage` | Typeobject | Errors and next steps | Response | Condition | Next step | | --- | --- | --- | | Response400 · `invalid_request_error` | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. | ### Aliases #### Model aliases **Ailoot** [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=messages) #### Method path aliases Use the method paths shown above. #### Related caller IDs [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=messages) **Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-3.7-flash-tiered` [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=gemini) Google /`gemini-3.7-flash-tiered` ### Overview A multimodal Google model with configurable reasoning for coding, video understanding and multi-step workflows. Accepted inputs Text · Images Results Text ### Available in Ailoot · inputs & methods **Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` Input types `text`, `image` Output types `text` Context 1,048,576 tokens Maximum output 65,536 tokens Output format json or supported streaming | Field | Type | Requirement | Values & limits | Default | | --- | --- | --- | --- | --- | | Field`path.model` | Type`string` | RequirementRequired | Values & limits gemini-3.7-flash-tiered | Default— | | Field`contents` | Type`content[]` | RequirementRequired | Values & limits Minimum items: 1 | Default— | | Field`contents[].role` | Type`string` | RequirementOptional | Values & limits user, model | Default— | | Field`contents[].parts` | Type`part[]` | RequirementRequired | Values & limits | Default— | | Field`systemInstruction` | Type`content` | RequirementOptional | Values & limits | Default— | | Field`generationConfig.maxOutputTokens` | Type`integer` | RequirementOptional | Values & limits Minimum: 1 Model-specific | Default— | | Field`generationConfig.temperature` | Type`number` | RequirementOptional | Values & limits Model-specific | Default— | | Field`generationConfig.topP` | Type`number` | RequirementOptional | Values & limits Model-specific | Default— | | Field`generationConfig.topK` | Type`integer` | RequirementOptional | Values & limits Model-specific | Default— | | Field`generationConfig.stopSequences` | Type`string[]` | RequirementOptional | Values & limits Model-specific | Default— | | Field`generationConfig.thinkingConfig.includeThoughts` | Type`boolean` | RequirementOptional | Values & limits Model-specific | Default— | | Field`generationConfig.thinkingConfig.thinkingBudget` | Type`integer` | RequirementOptional | Values & limits Model-specific | Default— | | Field`tools[].functionDeclarations` | Type`function_declaration[]` | RequirementOptional | Values & limits Model-specific | Default— | | Field`toolConfig.functionCallingConfig.mode` | Type`string` | RequirementOptional | Values & limits Model-specific | Default— | | Field`safetySettings` | Type`object[]` | RequirementOptional | Values & limits Model-specific | Default— | | Field`sessionId` | Type`string` | RequirementOptional | Values & limits | Default— | Input material combinations **Text** · UTF8 text `contents[].parts[].text` **Text + image** `parts[].inlineData={mimeType,data}` Method parameters and lifecycle | Parameter | Contract | | --- | --- | | Parameter`material_types` | Contracttext, image | | Parameter`required` | Contractcontents | | Parameter`optional_controls` | Contractnull | | Parameter`content_type` | Contractapplication/json | | Parameter`text_file_material` | Contractactual UTF-8 content inserted as text; file IDs/URLs need separate exact support | Lifecycle: `exact retained published method` Method shapes and IDs are exact; supplier capability is separate from admission. ### Pricing #### Ailoot method rates Input $0.00075 */ 1K* Output $0.00375 */ 1K* Cache read $0.000075 */ 1K* Ailoot reserves an estimated amount before a request. After the result, it settles the final charge from measured usage. Streaming settlement uses the final usage record. [How reservation and settlement work →](https://ailoot.ai/docs/en/billing/reserve/) ### Example requests #### Ailoot · Gemini generateContent Text exampleImage inputPython 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-3.7-flash-tiered: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-3.7-flash-tiered: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-3.7-flash-tiered", 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-3.7-flash-tiered", 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-3.7-flash-tiered',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 ``` ### Receive and save results #### Ailoot · Gemini generateContent json or supported streaming ##### Keep all completed results Keep every complete returned response, file and content part. Keep all candidates and parts, including function calls, thought signatures and usage; assemble stream chunks in order. ##### If the original response needs checking Keep request/response IDs and headers. No generic text job retrieval URL is supplied. Response fields | Field | Type | | --- | --- | | Field`responseId` | Typestring | | Field`modelVersion` | Typestring | | Field`candidates[].content.parts[]` | Typetext\|inlineData\|functionCall\|other part | | Field`candidates[].finishReason` | Typestring | | Field`usageMetadata` | Typeobject | Errors and next steps | Response | Condition | Next step | | --- | --- | --- | | Response400 · `invalid_request_error` | ConditionInvalid required fields, material representation or parameter value | Next stepCorrect the indicated fields before a new creation request. | ### Aliases #### Model aliases **Ailoot** [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=gemini) #### Method path aliases Use the method paths shown above. #### Related caller IDs [`gemini-3.7-flash-tiered`](https://ailoot.ai/models/en/#m=gemini-3.7-flash-tiered&route=Core&caller=gemini-3.7-flash-tiered&fmt=gemini) FAQ · Gemini 3.7 Flash Tiered What inputs and results are available? `POST /v1/messages` · `gemini-3.7-flash-tiered`: `text`, `image` → `text` `POST /v1beta/models/{model}:generateContent` · `gemini-3.7-flash-tiered`: `text`, `image` → `text` Which fields does the request use? `POST /v1/messages` · `gemini-3.7-flash-tiered`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1beta/models/{model}:generateContent` · `gemini-3.7-flash-tiered`: `contents`, `systemInstruction`, `sessionId` What limits apply? `POST /v1/messages` · `gemini-3.7-flash-tiered`: `ctx`: `1048576`; `max_out`: `65536`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1beta/models/{model}:generateContent` · `gemini-3.7-flash-tiered`: `ctx`: `1048576`; `max_out`: `65536`; `contents.min_items`: `1` Connect Ailoot to Claude Code, OpenCode, Hermes or your own app. ## The company and its project portfolio The company and its project portfolio: millions of customers; monthly sales in the billions. ## Buy tokens at a discount. Subscription discounts for regular use. Promo codes offer up to 50% off token purchases. Subscription Choose a discounted plan for your regular requests. Promo code: up to 50% off Enter your code at checkout. The price updates to reflect the current promotion. Spending in your history The model, tokens and amount are recorded for each request. [Choose a subscription](https://ailoot.ai/docs/en/billing/subscriptions/) · [View model prices](https://ailoot.ai/models/en/) ## Connect the API to a product you sell. Use Ailoot in SaaS, apps and bots under its official service offer and licence agreement. Request a reseller licence for resale. Commercial application Add text, image, video and audio generation to paid features in your service. Reseller licence Send a description of your project and how you provide access. Request written terms for use and resale. Documents on the website The service offer, licence agreement and data processing policy are available before you connect. [Request a reseller licence](mailto:support@ailoot.ai) · [Service offer and licence agreement](https://ailoot.ai/legal/offer?lang=en) ## Ailoot · The company and its project portfolio Ailoot combines established operating experience, a large client base, stable service and ongoing KPI control. The company and its project portfolio: millions of customers; monthly sales in the billions. Ailoot brings that operating experience to API access for AI features in customer products, agents, applications and automations.