Source: https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/
Canonical: https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/
Language: pt-pt
# Google: Gemini 3.1 Pro Preview
[Markdown](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/index.md) · [JSON](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/facts.json)
## [Google: Gemini 3.1 Pro Preview](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/)
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-0)
- [**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-1)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-2)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-3)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-4)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/gemini-3-1-pro-preview/#method-5)
Sobre o modelo
Esta descrição apresenta as capacidades do modelo. As entradas, saídas e opções disponíveis no Ailoot para o método selecionado estão indicadas abaixo.
Gemini 3.1 Pro Preview é o modelo textual da Google orientado para raciocínio, para tarefas complexas que exigem engenharia de software, desenvolvimento algorítmico ou síntese de provas multimodais. Baseia-se no Gemini 3 Pro, destacando a utilização precisa de ferramentas, raciocínio mais eficiente e execução fiável em várias etapas. Texto, imagens, áudio, vídeo e PDF podem contribuir para uma resposta escrita, um artefacto de código ou um resultado estruturado.
Para uma tarefa exigente de programação, forneça o objetivo, o material relevante do repositório, o comportamento observado e as restrições a preservar. Repositórios de código completos podem fornecer contexto para a tarefa. Para uma revisão de contrato de código, peça ao modelo que compare o tratamento de um contrato de dados partilhado em dois módulos, identifique a discrepância e proponha uma correção focada com referências de código que a sustentem. A saída útil distingue a análise, a revisão proposta e as provas de qualquer validação efetuada pela aplicação ligada.
O material de lançamento demonstra explicações visuais baseadas em código e projetos interativos, incluindo saída SVG animada a partir de um pedido textual. Estes são artefactos de código, e não geração de imagens rasterizadas. Um pedido claro pode definir o que deve ser explicado, como o elemento visual deve comportar-se e os dados que deve representar. Reveja o código e a renderização resultantes face a esses requisitos. Para uma tarefa de síntese de dados, forneça as fontes reais e peça uma vista que preserve as relações e as ressalvas nelas encontradas.
Os níveis de pensamento documentados são low, medium e high, sendo high a predefinição para 3.1 Pro Preview. O pensamento não pode ser completamente desativado neste perfil Pro. Escolha um esforço inferior para uma resposta delimitada e mais raciocínio para trabalho difícil de várias etapas, deixando margem de saída suficiente para o artefacto final. Um limite de saída pequeno pode interromper o raciocínio antes de surgir uma resposta final utilizável. O guia de pensamento distingue um resumo do raciocínio do processo interno completo e explica por que razão importa o contexto de assinaturas de pensamento da conversação.
A tabela exata Preview apresenta chamadas de funções, execução de código, fundamentação por pesquisa, fundamentação com Maps, contexto de URL e saídas estruturadas. Delimita File Search ao AI Studio. Forneça as finalidades das funções e as definições dos parâmetros e continue a partir do resultado real devolvido. O perfil separado Custom Tools Preview está otimizado para dar prioridade a ferramentas personalizadas e bash; é um endpoint distinto e identificado do produtor, pelo que essa especialização não deve ser tratada silenciosamente como propriedade de todos os pedidos 3.1 Pro. Selecione um esquema de resultado estruturado quando uma tarefa precisar de registos definidos em vez de prosa livre.
Para análise multimodal, identifique a página, o elemento visual, o intervalo de gravação ou o acontecimento no vídeo relevantes. Para análise documental, compare um diagrama com a sua especificação escrita e devolva cada discrepância com a passagem que a sustenta. Uma fonte falada pode contribuir com uma transcrição ou uma interpretação em texto. Preserve referências às fontes para as conclusões que precisam de verificação e distinga o que é visível ou declarado do que é inferido. A saída deste perfil continua a ser texto, incluindo código; a geração nativa de imagens ou voz não faz parte da sua tabela exata de capacidades.
A ficha nativa de 3.1 Pro especifica contexto de até 1M e saída textual de 64K, e a tabela exata da API Preview indica 1 048 576 tokens de entrada e 65 536 tokens de saída. Inclua instruções, histórico de conversação e suportes multimédia no orçamento de entrada. A cache e o processamento em lote estão documentados, com opções Flex e Priority também apresentadas para o perfil do produtor. Para vários itens independentes, defina a saída exigida e preserve o identificador de cada fonte, em vez de combinar provas sem relação numa única resposta sem rastreabilidade.
A edição identificada Preview mantém-se distinta do perfil Custom Tools do Pro e de lançamentos Flash ou Pro posteriores. Os seus pontos fortes dizem respeito a raciocínio complexo, programação e síntese de provas; o artefacto final continua a precisar de ser verificado face à fonte e aos resultados reais das ferramentas. Preserve a ambiguidade por resolver quando a informação fornecida não sustentar uma conclusão definitiva. Um artefacto útil é a resposta, o código ou o registo sustentados que a tarefa pediu, com provas suficientes para avaliar os seus limites práticos.
Tarefa prática
### Tarefa prática
Exemplo técnico em inglês
```
Review a cross-module date contract
Review this contract mismatch. Producer emits {due_date: "2026-11-03"}; consumer reads record.dueDate and displays "No date" when missing. Existing stored records use due_date. Propose the smallest compatible correction and tests for both present and absent dates. Preserve the producer field and do not add a second stored field.
```
#### Resultado esperado
```
A short mismatch analysis, a focused consumer patch and tests covering the stored field and missing-value behavior.
```
#### Verificar o resultado
```
Check that the patch reads due_date without changing persisted records or treating an absent date as a valid one.
```
**Ailoot · Anthropic Messages** `POST /v1/messages` `gemini-3.1-pro-preview`
[`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages)
Google /`gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto · Imagens
Resultados
Texto
### Disponível no Ailoot · entradas e métodos
**Ailoot · Anthropic Messages** `POST /v1/messages`
Entrada
`text`, `image`
Saída
`text`
Contexto
1 048 576 tokens
Saída máxima
65 536 tokens
Formato de saída
json ou SSE
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites gemini-3.1-pro-preview | Predefinição— |
| Campo`messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites Número mínimo de elementos: 1 | Predefinição— |
| Campo`messages[].role` | Tipo`string` | RequisitoObrigatório | Valores e limites user, assistant | Predefinição— |
| Campo`messages[].content` | Tipo`string\|content_block[]` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`system` | Tipo`string\|content_block[]` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObrigatório | Valores e limites Mínimo: 1 O limite aplica-se a: Limite exato do modelo ou da ficha selecionados | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites | Predefiniçãofalse |
| Campo`temperature` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`top_p` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`stop_sequences` | Tipo`string[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`tools` | Tipo`tool[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`tools[].name` | Tipo`string` | RequisitoOpcional | Valores e limites Aplica-se quando: Ferramenta fornecida | Predefinição— |
| Campo`tools[].description` | Tipo`string` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`tools[].input_schema` | Tipo`JSON_schema` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`tool_choice` | Tipo`object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`thinking.type` | Tipo`string` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`thinking.budget_tokens` | Tipo`integer` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`output_config.effort` | Tipo`string` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`metadata` | Tipo`object` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`cache_control` | Tipo`object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
Combinações de materiais de entrada
**Texto** · Texto UTF8
`messages[].content ou bloco type=text`
**Texto + imagem**
`{type:image,source:{type:base64,media_type,data}} ou origem type=url`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`material_types` | Contratotext, image |
| Parâmetro`required` | Contratomodel, messages, max\_tokens |
| Parâmetro`optional_controls` | Contratonull |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`text_file_material` | ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato |
Ciclo de vida: `exact retained published method`
As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.
### Tarifários
#### Tarifas dos métodos Ailoot
Entrada
0,002 US$ */ 1K*
Saída
0,012 US$ */ 1K*
Leitura da cache
0,0002 US$ */ 1K*
#### Preços por comprimento do pedido · Anthropic Messages
| Tamanho do pedido, em tokens | Entrada | Saída | Leitura da cache | Escrita na cache | Cache de 5 min | Cache de 1 hora |
| --- | --- | --- | --- | --- | --- | --- |
| Tamanho do pedido, em tokens(0; 200 000\] | Entrada0,002 US$ | Saída0,012 US$ | Leitura da cache0,0002 US$ | Escrita na cacheBase: — | Cache de 5 minBase: — | Cache de 1 horaBase: — |
| Tamanho do pedido, em tokens(200 000; ∞) | Entrada0,004 US$ | Saída0,018 US$ | Leitura da cache0,0004 US$ | Escrita na cacheBase: — | Cache de 5 minBase: — | Cache de 1 horaBase: — |
Tarifas em USD por 1K tokens. Se não estiver definida nenhuma tarifa, é herdada a tarifa base deste método; «—» significa que não está definida nenhuma tarifa base.
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
#### Detalhes da tarifa de referência
As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.
Tabelas de referência do modelo
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoOpenAI Chat · Tarifas de base por token | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoOpenAI Chat · Escalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoOpenAI Chat · Escalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Tarifas de base por token | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Escalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Escalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
### Exemplos de pedidos
#### Ailoot · Anthropic Messages
Exemplo de textoEntrada, imagemPython SDKNode.js SDKStreaming em Python
```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.1-pro-preview", "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.1-pro-preview", "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.1-pro-preview",
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.1-pro-preview",
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.1-pro-preview',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")
```
### Receber e guardar os resultados
#### Ailoot · Anthropic Messages
json ou SSE
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve todos os blocos de conteúdo, as assinaturas de raciocínio e os ID reais de utilização de ferramentas. Junte todos os deltas de blocos SSE; o primeiro bloco de texto não é a saída completa.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages)
**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent` `gemini-3.1-pro-preview`
[`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=gemini)
Google /`gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto · Imagens
Resultados
Texto
### Disponível no Ailoot · entradas e métodos
**Ailoot · Gemini generateContent** `POST /v1beta/models/{model}:generateContent`
Entrada
`text`, `image`
Saída
`text`
Contexto
1 048 576 tokens
Saída máxima
65 536 tokens
Formato de saída
json ou streaming suportado
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`path.model` | Tipo`string` | RequisitoObrigatório | Valores e limites gemini-3.1-pro-preview | Predefinição— |
| Campo`contents` | Tipo`content[]` | RequisitoObrigatório | Valores e limites Número mínimo de elementos: 1 | Predefinição— |
| Campo`contents[].role` | Tipo`string` | RequisitoOpcional | Valores e limites user, model | Predefinição— |
| Campo`contents[].parts` | Tipo`part[]` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`systemInstruction` | Tipo`content` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`generationConfig.maxOutputTokens` | Tipo`integer` | RequisitoOpcional | Valores e limites Mínimo: 1 Depende do modelo | Predefinição— |
| Campo`generationConfig.temperature` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`generationConfig.topP` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`generationConfig.topK` | Tipo`integer` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`generationConfig.stopSequences` | Tipo`string[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`generationConfig.thinkingConfig.includeThoughts` | Tipo`boolean` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`generationConfig.thinkingConfig.thinkingBudget` | Tipo`integer` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`tools[].functionDeclarations` | Tipo`function_declaration[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`toolConfig.functionCallingConfig.mode` | Tipo`string` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`safetySettings` | Tipo`object[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`sessionId` | Tipo`string` | RequisitoOpcional | Valores e limites | Predefinição— |
Combinações de materiais de entrada
**Texto** · Texto UTF8
`contents[].parts[].text`
**Texto + imagem**
`parts[].inlineData={mimeType,data}`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`material_types` | Contratotext, image |
| Parâmetro`required` | Contratocontents |
| Parâmetro`optional_controls` | Contratonull |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`text_file_material` | ContratoConteúdo UTF-8 real inserido como texto; ID de ficheiros/URLs precisam de suporte separado e exato |
Ciclo de vida: `exact retained published method`
As estruturas dos métodos e os ID são exatos; a capacidade do fornecedor é distinta da admissão dos pedidos.
### Tarifários
#### Tarifas dos métodos Ailoot
Entrada
0,002 US$ */ 1K*
Saída
0,012 US$ */ 1K*
Leitura da cache
0,0002 US$ */ 1K*
#### Preços por comprimento do pedido · Gemini generateContent
| Tamanho do pedido, em tokens | Entrada | Saída | Leitura da cache | Escrita na cache | Cache de 5 min | Cache de 1 hora |
| --- | --- | --- | --- | --- | --- | --- |
| Tamanho do pedido, em tokens(0; 200 000\] | Entrada0,002 US$ | Saída0,012 US$ | Leitura da cache0,0002 US$ | Escrita na cacheBase: — | Cache de 5 minBase: — | Cache de 1 horaBase: — |
| Tamanho do pedido, em tokens(200 000; ∞) | Entrada0,004 US$ | Saída0,018 US$ | Leitura da cache0,0004 US$ | Escrita na cacheBase: — | Cache de 5 minBase: — | Cache de 1 horaBase: — |
Tarifas em USD por 1K tokens. Se não estiver definida nenhuma tarifa, é herdada a tarifa base deste método; «—» significa que não está definida nenhuma tarifa base.
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
#### Detalhes da tarifa de referência
As tabelas de referência do modelo não alteram a seleção do método, as cotações ou os custos. Os custos ativos usam as tarifas do método Ailoot selecionado.
Tabelas de referência do modelo
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoOpenAI Chat · Tarifas de base por token | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoOpenAI Chat · Escalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoOpenAI Chat · Escalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Tarifas de base por token | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Escalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoAnthropic Messages · Escalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
### Exemplos de pedidos
#### Ailoot · Gemini generateContent
Exemplo de textoEntrada, imagemPython SDKNode.js SDKStreaming em Python
```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.1-pro-preview: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.1-pro-preview: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.1-pro-preview", 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.1-pro-preview", 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.1-pro-preview',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
```
### Receber e guardar os resultados
#### Ailoot · Gemini generateContent
json ou streaming suportado
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve todos os candidatos e partes, incluindo chamadas de funções, assinaturas de raciocínio e dados de utilização; junte os fragmentos do fluxo pela ordem.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`responseId` | Tipostring |
| Campo`modelVersion` | Tipostring |
| Campo`candidates[].content.parts[]` | Tipotext\|inlineData\|functionCall\|other part |
| Campo`candidates[].finishReason` | Tipostring |
| Campo`usageMetadata` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=gemini)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=gemini), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `gemini-3.1-pro-preview`
[`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=chat)
Google /`gemini-3.1-pro-preview`
ID do modelo
- `gemini-3.1-pro-preview`
- `google/gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto
Resultados
Texto
### Disponível no Ailoot · entradas e métodos
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Entrada
`text`
Saída
`text`
Formato de saída
json ou SSE
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites gemini-3.1-pro-preview | Predefinição— |
| Campo`messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites Número mínimo de elementos: 1 | Predefinição— |
| Campo`messages[].role` | Tipo`string` | RequisitoObrigatório | Valores e limites Depende do modelo | Predefinição— |
| Campo`messages[].content` | Tipo`string` | RequisitoOpcional | Valores e limites Aplica-se quando: Conversação textual | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites | Predefiniçãofalse |
Combinações de materiais de entrada
**Texto** · Texto UTF8
`messages[].content`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratomodel, messages |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`messages` | ContratoLista de mensagens com estrutura role/content |
| Parâmetro`file_material` | ContratoDocumento UTF-8 real inserido como texto literal; nenhum ID de ficheiro inferido |
| Parâmetro`optional_controls` | Contratostream |
| Parâmetro`control_scope` | ContratoConversação textual; stream é um booleano e tem false como predefinição. |
| Parâmetro`output_modalities` | Contratotext |
| Parâmetro`hosted_operations` | Contratofalse |
| Parâmetro`multimodal_input_binding` | Contratonull |
Aliases do método: `/chat/completions`
Ciclo de vida: `synchronous_or_streamed`
Envie o ID exato do modelo com messages.
O comprimento do contexto não é um limite de saída.
Um ficheiro de texto pode fornecer texto literal; as entradas de imagem/áudio/objeto de ficheiro exigem uma associação exata.
### Tarifários
As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.
Modo rápido
Tarifa normal Quando o modo rápido está selecionado
Modo flex
Tarifa normal Quando o modo flex está selecionado
Esforço máximo de raciocínio
Tarifa normal Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)
Esforço de raciocínio · elevado
Tarifa normal Quando o esforço de raciocínio é elevado
Esforço de raciocínio · baixo
Tarifa normal Quando o esforço de raciocínio é baixo
Esforço de raciocínio · médio
Tarifa normal Quando o esforço de raciocínio é médio
Preços da cache explícita
Não ativado Quando é pedida cache explícita
Saída de raciocínio
O raciocínio utiliza a tarifa indicada para esse subconjunto dentro da saída agregada; não contabilize esses tokens duas vezes. Quando a saída inclui tokens de raciocínio
#### Tarifas Ailoot
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base dos tokens | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoEscalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoEscalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
### Exemplos de pedidos
#### 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-3.1-pro-preview","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-3.1-pro-preview", 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"))
```
### Receber e guardar os resultados
#### Ailoot Ultra · OpenAI Chat
json ou SSE
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve cada opção com o conteúdo, as chamadas de ferramentas e o raciocínio. Em SSE, junte os deltas por índice de opção e ferramenta e mantenha o motivo final de conclusão e os dados de utilização.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`choices[].index` | Tipointeger |
| Campo`choices[].message.content` | Tipostring\|null |
| Campo`choices[].message.tool_calls` | Tipotool\_call\[\] |
| Campo`choices[].message.reasoning_content` | Tipostring |
| Campo`choices[].message.reasoning_details` | Tipoobject\|array |
| Campo`choices[].finish_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=chat), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=chat)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=chat), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `gemini-3.1-pro-preview`
[`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages)
Google /`gemini-3.1-pro-preview`
ID do modelo
- `gemini-3.1-pro-preview`
- `google/gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto
Resultados
json · sse
### Disponível no Ailoot · entradas e métodos
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Entrada
`text`
Saída
`json`, `sse`
Formato de saída
JSON ou SSE
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites gemini-3.1-pro-preview | Predefinição— |
| Campo`messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`messages[].role` | Tipo`string` | RequisitoObrigatório | Valores e limites user, assistant | Predefinição— |
| Campo`messages[].content` | Tipo`string` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites | Predefiniçãofalse |
Combinações de materiais de entrada
**Texto** · Texto UTF-8
`Cadeia de caracteres messages[].content`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratomodel, messages, max\_tokens |
| Parâmetro`optional_controls` | Contratostream |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`text_file_material` | ContratoLeia o documento UTF-8 real e coloque o texto na entrada indicada ou na cadeia de conteúdo da mensagem. |
Ciclo de vida: `synchronous_or_streamed`
### Tarifários
As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.
Modo rápido
Tarifa normal Quando o modo rápido está selecionado
Modo flex
Tarifa normal Quando o modo flex está selecionado
Esforço máximo de raciocínio
Tarifa normal Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)
Esforço de raciocínio · elevado
Tarifa normal Quando o esforço de raciocínio é elevado
Esforço de raciocínio · baixo
Tarifa normal Quando o esforço de raciocínio é baixo
Esforço de raciocínio · médio
Tarifa normal Quando o esforço de raciocínio é médio
Preços da cache explícita
Não ativado Quando é pedida cache explícita
Saída de raciocínio
O raciocínio utiliza a tarifa indicada para esse subconjunto dentro da saída agregada; não contabilize esses tokens duas vezes. Quando a saída inclui tokens de raciocínio
#### Tarifas Ailoot
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base dos tokens | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoEscalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoEscalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
### Exemplos de pedidos
#### Ailoot Ultra · Anthropic Messages
Corpo JSON mínimo completocurl · use o seu documento UTF-8Python · guarde o resultado completo
```json
{
"model": "gemini-3.1-pro-preview",
"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-3.1-pro-preview', '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-3.1-pro-preview', '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))
```
### Receber e guardar os resultados
#### Ailoot Ultra · Anthropic Messages
JSON ou SSE
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve todos os blocos de conteúdo, as assinaturas de raciocínio e os ID reais de utilização de ferramentas. Junte todos os deltas de blocos SSE; o primeiro bloco de texto não é a saída completa.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `google/gemini-3.1-pro-preview`
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=chat)
Google /`google/gemini-3.1-pro-preview`
ID do modelo
- `gemini-3.1-pro-preview`
- `google/gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto
Resultados
Texto
### Disponível no Ailoot · entradas e métodos
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Entrada
`text`
Saída
`text`
Formato de saída
json ou SSE
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites google/gemini-3.1-pro-preview | Predefinição— |
| Campo`messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites Número mínimo de elementos: 1 | Predefinição— |
| Campo`messages[].role` | Tipo`string` | RequisitoObrigatório | Valores e limites Exemplos: system, user, assistant, tool, function Condições: Estes papéis são representados explicitamente pelos tipos de compatibilidade do código-fonte; o conjunto exato de papéis continua específico do modelo. Depende do modelo | Predefinição— |
| Campo`messages[].content` | Tipo`string\|content_part[]\|null` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`messages[].tool_calls` | Tipo`tool_call[]` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`messages[].tool_call_id` | Tipo`string` | RequisitoOpcional | Valores e limites Aplica-se quando: role=tool; use o ID realmente devolvido | Predefinição— |
| Campo`messages[].name` | Tipo`string` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`messages[].reasoning_content` | Tipo`string` | RequisitoOpcional | Valores e limites Aplica-se quando: Reintroduza o raciocínio realmente devolvido quando este modelo o utiliza | Predefinição— |
| Campo`messages[].reasoning_details` | Tipo`object\|array` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`max_tokens` | Tipo`integer` | RequisitoOpcional | Valores e limites Mínimo: 1 Depende do modelo | Predefinição— |
| Campo`max_completion_tokens` | Tipo`integer` | RequisitoOpcional | Valores e limites Mínimo: 1 Depende do modelo | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites | Predefiniçãofalse |
| Campo`stream_options.include_usage` | Tipo`boolean` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`temperature` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`top_p` | Tipo`number` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`stop` | Tipo`string\|string[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`tools` | Tipo`function_tool[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`tools[].type` | Tipo`string` | RequisitoOpcional | Valores e limites function Depende do modelo | Predefinição— |
| Campo`tools[].function.name` | Tipo`string` | RequisitoObrigatório | Valores e limites Aplica-se quando: Função fornecida como ferramenta | Predefinição— |
| Campo`tools[].function.description` | Tipo`string` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`tools[].function.parameters` | Tipo`JSON_schema` | RequisitoOpcional | Valores e limites | Predefinição— |
| Campo`tool_choice` | Tipo`string\|object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`parallel_tool_calls` | Tipo`boolean` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`response_format` | Tipo`object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`reasoning_effort` | Tipo`string` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`reasoning` | Tipo`object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`service_tier` | Tipo`string` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`instructions` | Tipo`string` | RequisitoOpcional | Valores e limites Campo de compatibilidade | Predefinição— |
| Campo`functions` | Tipo`function[]` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`function_call` | Tipo`string\|object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`prompt_cache_options` | Tipo`object` | RequisitoOpcional | Valores e limites Depende do modelo | Predefinição— |
| Campo`modalities` | Tipo`string[]` | RequisitoOpcional | Valores e limites text | Predefinição— |
| Campo`provider` | Tipo`object` | RequisitoOpcional | Valores e limites Condições: provider.options é rejeitado nesta rota textual Ultra | Predefinição— |
| Campo`cache_control.ttl` | Tipo`string` | RequisitoOpcional | Valores e limites Condições: 1h é rejeitado nos locais efetivos da cache de prompts | Predefinição— |
Combinações de materiais de entrada
**Texto** · Texto UTF8
`messages[].content`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratomodel, messages |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`messages` | ContratoLista de mensagens com estrutura role/content |
| Parâmetro`file_material` | ContratoDocumento UTF-8 real inserido como texto literal; nenhum ID de ficheiro inferido |
| Parâmetro`optional_controls` | Contratostream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parâmetro`control_scope` | ContratoEspecífico do modelo; as ferramentas de funções do utilizador diferem das ferramentas alojadas |
| Parâmetro`output_modalities` | Contratotext |
| Parâmetro`hosted_operations` | Contratofalse |
| Parâmetro`multimodal_input_binding` | Contratonull |
Ciclo de vida: `synchronous_or_streamed`
Envie o ID exato do modelo com messages.
O comprimento do contexto não é um limite de saída.
Um ficheiro de texto pode fornecer texto literal; as entradas de imagem/áudio/objeto de ficheiro exigem uma associação exata.
### Tarifários
As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.
Modo rápido
Tarifa normal Quando o modo rápido está selecionado
Modo flex
Tarifa normal Quando o modo flex está selecionado
Esforço máximo de raciocínio
Tarifa normal Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)
Esforço de raciocínio · elevado
Tarifa normal Quando o esforço de raciocínio é elevado
Esforço de raciocínio · baixo
Tarifa normal Quando o esforço de raciocínio é baixo
Esforço de raciocínio · médio
Tarifa normal Quando o esforço de raciocínio é médio
Preços da cache explícita
Não ativado Quando é pedida cache explícita
Saída de raciocínio
O raciocínio utiliza a tarifa indicada para esse subconjunto dentro da saída agregada; não contabilize esses tokens duas vezes. Quando a saída inclui tokens de raciocínio
#### Tarifas Ailoot
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base dos tokens | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoEscalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoEscalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
### Exemplos de pedidos
#### Ailoot Ultra · OpenAI Chat
curlPython SDKStreaming em Python
```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-3.1-pro-preview", "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-3.1-pro-preview',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-3.1-pro-preview',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")
```
### Receber e guardar os resultados
#### Ailoot Ultra · OpenAI Chat
json ou SSE
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve cada opção com o conteúdo, as chamadas de ferramentas e o raciocínio. Em SSE, junte os deltas por índice de opção e ferramenta e mantenha o motivo final de conclusão e os dados de utilização.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`choices[].index` | Tipointeger |
| Campo`choices[].message.content` | Tipostring\|null |
| Campo`choices[].message.tool_calls` | Tipotool\_call\[\] |
| Campo`choices[].message.reasoning_content` | Tipostring |
| Campo`choices[].message.reasoning_details` | Tipoobject\|array |
| Campo`choices[].finish_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=chat), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=chat)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=chat), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `google/gemini-3.1-pro-preview`
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages)
Google /`google/gemini-3.1-pro-preview`
ID do modelo
- `gemini-3.1-pro-preview`
- `google/gemini-3.1-pro-preview`
### Introdução
Gemini 3.1 Pro Preview é o modelo de raciocínio multimodal da Google para tarefas complexas de software, algoritmos e conhecimento. Aceita texto, imagens, áudio, vídeo e PDF e devolve texto ou código, com ferramentas e saída estruturada. Os níveis de raciocínio low, medium e high orientam o esforço; high é a predefinição documentada.
Entradas aceites
Texto
Resultados
json · sse
### Disponível no Ailoot · entradas e métodos
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Entrada
`text`
Saída
`json`, `sse`
Formato de saída
JSON ou SSE
| Campo | Tipo | Requisito | Valores e limites | Predefinição |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObrigatório | Valores e limites google/gemini-3.1-pro-preview | Predefinição— |
| Campo`messages` | Tipo`message[]` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`messages[].role` | Tipo`string` | RequisitoObrigatório | Valores e limites user, assistant | Predefinição— |
| Campo`messages[].content` | Tipo`string` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObrigatório | Valores e limites | Predefinição— |
| Campo`stream` | Tipo`boolean` | RequisitoOpcional | Valores e limites | Predefiniçãofalse |
Combinações de materiais de entrada
**Texto** · Texto UTF-8
`Cadeia de caracteres messages[].content`
Parâmetros e ciclo de vida do método
| Parâmetro | Contrato |
| --- | --- |
| Parâmetro`content_type` | Contratoapplication/json |
| Parâmetro`required` | Contratomodel, messages, max\_tokens |
| Parâmetro`optional_controls` | Contratostream |
| Parâmetro`material_types` | Contratotext |
| Parâmetro`text_file_material` | ContratoLeia o documento UTF-8 real e coloque o texto na entrada indicada ou na cadeia de conteúdo da mensagem. |
Ciclo de vida: `synchronous_or_streamed`
### Tarifários
As referências tarifárias não acrescentam opções ao pedido. Os parâmetros suportados constam do método selecionado.
Modo rápido
Tarifa normal Quando o modo rápido está selecionado
Modo flex
Tarifa normal Quando o modo flex está selecionado
Esforço máximo de raciocínio
Tarifa normal Quando o esforço máximo de raciocínio usa o ajuste predefinido (default)
Esforço de raciocínio · elevado
Tarifa normal Quando o esforço de raciocínio é elevado
Esforço de raciocínio · baixo
Tarifa normal Quando o esforço de raciocínio é baixo
Esforço de raciocínio · médio
Tarifa normal Quando o esforço de raciocínio é médio
Preços da cache explícita
Não ativado Quando é pedida cache explícita
Saída de raciocínio
O raciocínio utiliza a tarifa indicada para esse subconjunto dentro da saída agregada; não contabilize esses tokens duas vezes. Quando a saída inclui tokens de raciocínio
#### Tarifas Ailoot
#### Preços por configuração
Associe cada custo às condições apresentadas. Use uma única tarifa para cada conjunto de configurações alternativas.
| Configuração | Tabela de tarifas | Tokens de contexto, mais de | Tokens de contexto, até ao limite inclusive | Custo |
| --- | --- | --- | --- | --- |
| ConfiguraçãoTarifas base dos tokens | Tabela de tarifasTarifa base | Tokens de contexto, mais de— | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens Saída · Tokens de saída de raciocínio **$0.024** / 1K tokens |
| ConfiguraçãoEscalão 1 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de0 | Tokens de contexto, até ao limite inclusive200 000 | Custo Entrada · Tokens de entrada **$0.004** / 1K tokens Saída · Tokens de saída **$0.024** / 1K tokens Entrada · Leitura da cache **$0.0004** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
| ConfiguraçãoEscalão 2 por comprimento do pedido | Tabela de tarifas— | Tokens de contexto, mais de200 000 | Tokens de contexto, até ao limite inclusiveSem limite superior | Custo Entrada · Tokens de entrada **$0.008** / 1K tokens Saída · Tokens de saída **$0.036** / 1K tokens Entrada · Leitura da cache **$0.0008** / 1K tokens Entrada · Escrita na cache **$0.00075** / 1K tokens Entrada · Escrita na cache, 1 hora **—** / 1K tokens |
O Ailoot reserva um montante estimado antes de um pedido. Após o resultado, liquida o custo final com base na utilização medida. No streaming, a liquidação usa o registo final de utilização. [Como funcionam a reserva e a liquidação →](https://ailoot.ai/docs/pt-pt/billing/reserve/)
### Exemplos de pedidos
#### Ailoot Ultra · Anthropic Messages
Corpo JSON mínimo completocurl · use o seu documento UTF-8Python · guarde o resultado completo
```json
{
"model": "google/gemini-3.1-pro-preview",
"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-3.1-pro-preview', '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-3.1-pro-preview', '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))
```
### Receber e guardar os resultados
#### Ailoot Ultra · Anthropic Messages
JSON ou SSE
##### Guardar todos os resultados concluídos
Guarde cada resposta, ficheiro e parte de conteúdo devolvidos na íntegra.
Conserve todos os blocos de conteúdo, as assinaturas de raciocínio e os ID reais de utilização de ferramentas. Junte todos os deltas de blocos SSE; o primeiro bloco de texto não é a saída completa.
##### Se for necessário verificar a resposta original
Conserve os ID e cabeçalhos de pedido/resposta. Não é fornecido um URL genérico para obter uma tarefa textual.
Campos da resposta
| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |
Erros e passos seguintes
| Resposta | Condição | Passo seguinte |
| --- | --- | --- |
| Resposta400 · `invalid_request_error` | CondiçãoCampos obrigatórios, representação do material ou valor do parâmetro inválidos | Passo seguinteCorrija os campos indicados antes de um novo pedido de criação. |
### Aliases
#### Aliases do modelo
Ailoot [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages)
**Ailoot Ultra** [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages), [`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages)
[`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest)
#### Aliases dos caminhos dos métodos
`/chat/completions`
#### IDs de chamada relacionados
[`google/gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=google%2Fgemini-3.1-pro-preview&fmt=messages), [`~google/gemini-pro-latest`](https://ailoot.ai/models/pt-pt/#m=~google%2Fgemini-pro-latest), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Core&caller=gemini-3.1-pro-preview&fmt=messages), [`gemini-3.1-pro-preview`](https://ailoot.ai/models/pt-pt/#m=google%2Fgemini-3.1-pro-preview&route=Ultra&caller=gemini-3.1-pro-preview&fmt=messages)
FAQ · Google: Gemini 3.1 Pro Preview
Que entradas e resultados estão disponíveis?
`POST /v1/messages` · `gemini-3.1-pro-preview`: `text`, `image` → `text` `POST /v1beta/models/{model}:generateContent` · `gemini-3.1-pro-preview`: `text`, `image` → `text` `POST /v1/chat/completions` · `gemini-3.1-pro-preview`: `text` → `text` `POST /v1/messages` · `gemini-3.1-pro-preview`: `text` → `json`, `sse` `POST /v1/chat/completions` · `google/gemini-3.1-pro-preview`: `text` → `text` `POST /v1/messages` · `google/gemini-3.1-pro-preview`: `text` → `json`, `sse`
Que campos utiliza o pedido?
`POST /v1/messages` · `gemini-3.1-pro-preview`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1beta/models/{model}:generateContent` · `gemini-3.1-pro-preview`: `contents`, `systemInstruction`, `sessionId` `POST /v1/chat/completions` · `gemini-3.1-pro-preview`: `model`, `messages`, `stream` `POST /v1/messages` · `gemini-3.1-pro-preview`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/chat/completions` · `google/gemini-3.1-pro-preview`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `google/gemini-3.1-pro-preview`: `model`, `messages`, `max_tokens`, `stream`
Que limites se aplicam?
`POST /v1/messages` · `gemini-3.1-pro-preview`: `ctx`: `1048576`; `max_out`: `65536`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1beta/models/{model}:generateContent` · `gemini-3.1-pro-preview`: `ctx`: `1048576`; `max_out`: `65536`; `contents.min_items`: `1` `POST /v1/chat/completions` · `gemini-3.1-pro-preview`: `messages.min_items`: `1` `POST /v1/chat/completions` · `google/gemini-3.1-pro-preview`: `messages.min_items`: `1`
Ligue o Ailoot ao Claude Code, OpenCode, Hermes ou à sua aplicação.
## A empresa e a sua carteira de projetos
A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.
## Compre tokens com desconto.
Desconto por subscrição para trabalho regular. Códigos promocionais — até 50% na compra de tokens.
Subscrição
Escolha um plano com desconto para os pedidos regulares.
Código promocional até 50%
Introduza o código na compra. O preço é recalculado conforme a campanha em vigor.
Custos no histórico
O modelo, os tokens e o montante são guardados para cada pedido.
[Escolher subscrição](https://ailoot.ai/docs/pt-pt/billing/subscriptions/) · [Ver preços dos modelos](https://ailoot.ai/models/pt-pt/)
## Ligue a API ao produto que vende.
SaaS, aplicações e bots — ao abrigo da oferta e do contrato de licença Ailoot. Para revenda, peça uma licença de revendedor.
Aplicação comercial
Integre geração de texto, imagens, vídeo e som nas funcionalidades pagas do seu serviço.
Licença de revendedor
Envie uma descrição do projeto e do modelo de acesso. Peça condições escritas de utilização e revenda.
Documentos no site
A oferta, o contrato de licença e a política de tratamento de dados estão disponíveis antes da ligação.
[Pedir licença de revendedor](mailto:support@ailoot.ai) · [Oferta e contrato de licença](https://ailoot.ai/legal/offer?lang=pt-pt)
## Ailoot · A empresa e a sua carteira de projetos
A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.
A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.
A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.