Documentação da API
Última atualização: novembro de 2026
Comece com sua primeira solicitação e explore os exemplos de API e a resolução de problemas.
Nesta página
- Registre-se e verifique seu e-mail ou faça login no Google.Não é necessário cartão ou recarga.
- Crie uma chave que permita Auto e salve o segredo exibido uma única vez.Abrir API Keys
- Escolha Bash (cURL e Python 3), Python 3 ou JavaScript (Node.js 18+). Substitua your-api-key pela sua chave. Bash salva response.json localmente.
export ITERACOMPUTE_API_KEY="your-api-key"
curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/chat/completions \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"Auto","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"max_tokens":512,"reasoning":false}' \
-o response.json && python3 -c 'import json; r=json.load(open("response.json")); text=r["choices"][0]["message"]["content"]; assert text and text.strip(), "Empty model reply: activation is incomplete"; print(text)'import json
from urllib.request import Request, urlopen
api_key = "your-api-key"
payload = {
"model": "Auto",
"messages": [{"role": "user", "content": "Reply with exactly: Hello!"}],
"max_tokens": 512,
"reasoning": False,
}
request = Request(
"https://api.iteracompute.com/v1/chat/completions",
data=json.dumps(payload).encode(),
headers={"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"},
method="POST",
)
with urlopen(request, timeout=180) as response:
result = json.load(response)
text = result["choices"][0]["message"]["content"]
if not text or not text.strip():
raise RuntimeError("Empty model reply: activation is incomplete")
print(text)const apiKey = "your-api-key";
const response = await fetch(
"https://api.iteracompute.com/v1/chat/completions",
{
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
"model": "Auto",
"messages": [{"role": "user", "content": "Reply with exactly: Hello!"}],
"max_tokens": 512,
"reasoning": false,
}),
signal: AbortSignal.timeout(180000),
},
);
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
const text = result.choices[0].message.content;
if (!text?.trim()) throw new Error("Empty model reply: activation is incomplete");
console.log(text);O sucesso exige choices[0].message.content não vazio. Cada exemplo imprime a resposta e falha se estiver vazia. Saída esperada: Hello! (o texto pode variar).
Os três exemplos usam Qwen gratuito com o raciocínio desativado. Para 401/403, confira a chave e a permissão do modelo. Para 429, siga as instruções de recuperação abaixo.
A API da IteraCompute é compatível com OpenAI. Se seu aplicativo já usa a API da OpenAI, para migrar basta alterar base_url e a chave de API. Chat Completions, Responses, streaming e chamadas de ferramentas seguem formatos compatíveis quando o modelo selecionado oferece suporte.
As solicitações de API são enviadas para https://api.iteracompute.com/v1. As solicitações de Chat Completions e Responses são autenticadas com a chave de API no cabeçalho Authorization .
export ITERACOMPUTE_API_KEY="your-api-key"
curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/chat/completions \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"deepseek/deepseek-v4.1-flash-1017","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"temperature":0,"max_tokens":128}'Use exatamente o identificador provider/model retornado pelo endpoint Models; não adicione o prefixo iteracompute/ . Consulte os modelos publicados atualmente pelo gateway:
curl --fail-with-body https://api.iteracompute.com/v1/modelsO endpoint Models é público e retorna o catálogo atual do gateway. Use os valores de id exatamente como retornados. O acesso comercial a cada modelo continua sujeito à sua chave de API e ao contrato aplicável.
Suporte e custos do modelo
Os exemplos de Chat Completions, Responses, streaming e chamadas de ferramentas usam o modelo pago DeepSeek V4.1 Flash 1017 e descontam o uso do saldo da API. Consulte os preços atuais de entrada, entrada em cache e saída em Modelos. O Qwen3.8-27B gratuito aceita Chat Completions, streaming e ferramentas; este guia não verifica seu suporte à Responses API. IDs e parâmetros de raciocínio não são intercambiáveis. Confirme as interfaces e opções do modelo antes de adaptar um exemplo.
As três abas de linguagem chamam o mesmo endpoint HTTP. Defina ITERACOMPUTE_API_KEY no ambiente antes de executar um exemplo. Os exemplos de JavaScript usam Node.js 18 ou posterior.
Estes exemplos desativam tentativas automáticas. Em um 429, verifique o corpo do erro e Retry-After. Interrompa as tentativas se a cota mensal acabar. Após timeout, desconexão ou 5xx, salve o ID e confirme o resultado antes de enviar outra solicitação faturável.
Todos os modelos de conversação publicados oferecem suporte a OpenAI Chat Completions e Anthropic Messages. O suporte a Responses e os recursos seguem os limites documentados de cada modelo.
4. Chat Completions
POST /v1/chat/completions segue o formato de solicitação e resposta OpenAI:
POSThttps://api.iteracompute.com/v1/chat/completions
curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/chat/completions \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"deepseek/deepseek-v4.1-flash-1017","messages":[{"role":"user","content":"Reply with exactly: Hello!"}],"temperature":0,"max_tokens":128}'# Install once: python -m pip install openai
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.iteracompute.com/v1",
api_key=os.environ["ITERACOMPUTE_API_KEY"],
max_retries=0,
timeout=180.0,
)
resp = client.chat.completions.create(
model="deepseek/deepseek-v4.1-flash-1017",
messages=[{"role": "user", "content": "Reply with exactly: Hello!"}],
temperature=0,
max_tokens=128,
)
print(resp.choices[0].message.content)
print(resp.usage) # prompt_tokens / completion_tokens / total_tokensconst response = await fetch("https://api.iteracompute.com/v1/chat/completions", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "deepseek/deepseek-v4.1-flash-1017",
messages: [{role: "user", content: "Reply with exactly: Hello!"}],
temperature: 0,
max_tokens: 128,
}),
signal: AbortSignal.timeout(180000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
console.log(result.choices[0].message.content);Anthropic Messages
Este exemplo usa DeepSeek V4.1 Flash 1017. Você pode escolher qualquer modelo de conversação publicado permitido pela sua chave. O exemplo de Python usa apenas a biblioteca padrão. Messages preserva as respostas e os erros nativos da Anthropic; os fluxos terminam com message_stop em vez de [DONE].
POSThttps://api.iteracompute.com/v1/messages
curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/messages \
-H "x-api-key: $ITERACOMPUTE_API_KEY" \
-H "anthropic-version: 2023-06-01" \
-H "Content-Type: application/json" \
-d @- <<JSON
{
"model": "deepseek/deepseek-v4.1-flash-1017",
"max_tokens": 128,
"messages": [{"role": "user", "content": "Hello!"}]
}
JSONimport json
import os
from urllib.request import Request, urlopen
request = Request(
"https://api.iteracompute.com/v1/messages",
data=json.dumps({
"model": "deepseek/deepseek-v4.1-flash-1017",
"max_tokens": 128,
"messages": [{"role": "user", "content": "Hello!"}],
}).encode(),
headers={
"x-api-key": os.environ["ITERACOMPUTE_API_KEY"],
"anthropic-version": "2023-06-01",
"Content-Type": "application/json",
},
method="POST",
)
with urlopen(request, timeout=180) as response:
result = json.load(response)
print("".join(block["text"] for block in result["content"] if block["type"] == "text"))const response = await fetch("https://api.iteracompute.com/v1/messages", {
method: "POST",
headers: {
"x-api-key": process.env.ITERACOMPUTE_API_KEY,
"anthropic-version": "2023-06-01",
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "deepseek/deepseek-v4.1-flash-1017",
max_tokens: 128,
messages: [{role: "user", content: "Hello!"}],
}),
signal: AbortSignal.timeout(180000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
console.log(result.content.filter(block => block.type === "text").map(block => block.text).join(""));5. Responses API
POST /v1/responses suporta a API OpenAI Responses usada por clientes como Codex:
POSThttps://api.iteracompute.com/v1/responses
curl --fail-with-body --max-time 180 https://api.iteracompute.com/v1/responses \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"deepseek/deepseek-v4.1-flash-1017","input":"Reply with exactly: Hello!","max_output_tokens":128}'# Install once: python -m pip install openai
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.iteracompute.com/v1",
api_key=os.environ["ITERACOMPUTE_API_KEY"],
max_retries=0,
timeout=180.0,
)
response = client.responses.create(
model="deepseek/deepseek-v4.1-flash-1017",
input="Reply with exactly: Hello!",
max_output_tokens=128,
)
print(response.output_text)const response = await fetch("https://api.iteracompute.com/v1/responses", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "deepseek/deepseek-v4.1-flash-1017",
input: "Reply with exactly: Hello!",
max_output_tokens: 128,
}),
signal: AbortSignal.timeout(180000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
console.log(result.output.filter(item => item.type === "message").flatMap(item => item.content || [])
.filter(block => block.type === "output_text").map(block => block.text).join(""));Use a API de imagens com um modelo de imagem publicado e uma chave API autorizada. Confirme a disponibilidade atual no catálogo de modelos antes de fazer a chamada.
Gere imagens com um ID de modelo e um prompt ou contents nativo. Use apenas os campos aceitos pelo modelo escolhido. Autentique com sua chave e salve a imagem base64 localmente.
POSThttps://api.iteracompute.com/v1/images/generations
Estes exemplos pagos criam uma imagem e a salvam localmente. Defina ITERACOMPUTE_API_KEY primeiro. cURL requer Bash e Python 3; Python usa httpx; JavaScript usa Node.js 18+.
| ID do modelo | Geração | Edição com referência |
|---|---|---|
openai/gpt-image-2.6-flare | /v1/images/generations | /v1/images/edits · multipart |
openai/gpt-image-2.6-sunburst | /v1/images/generations | /v1/images/edits · multipart |
gemini/gemini-nano-banana-2.1 | /v1/images/generations | /v1/images/generations · contents |
OpenAI Image 2.6
Flare e Sunburst usam os mesmos campos. Para usar Sunburst, troque o ID por openai/gpt-image-2.6-sunburst. Os exemplos solicitam qualidade low em 1024x1024.
POSThttps://api.iteracompute.com/v1/images/generations
set -e
curl --fail-with-body --max-time 1800 https://api.iteracompute.com/v1/images/generations \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"openai/gpt-image-2.6-flare","prompt":"A blue ceramic cup on a white background. No text, no people.","n":1,"size":"1024x1024","quality":"low","output_format":"png"}' \
-o generation-response.json && python3 - <<'PY'
import base64, json
from pathlib import Path
result = json.loads(Path("generation-response.json").read_text())
Path("generated.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])
PY# Install once: python -m pip install httpx
import base64
import os
from pathlib import Path
import httpx
payload = {'model': 'openai/gpt-image-2.6-flare',
'prompt': 'A blue ceramic cup on a white background. No text, no people.',
'n': 1,
'size': '1024x1024',
'quality': 'low',
'output_format': 'png'}
headers = {"Authorization": f"Bearer {os.environ['ITERACOMPUTE_API_KEY']}"}
with httpx.Client(timeout=1800.0, transport=httpx.HTTPTransport(retries=0)) as client:
response = client.post("https://api.iteracompute.com/v1/images/generations", headers=headers, json=payload)
response.raise_for_status()
result = response.json()
Path("generated.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])import { writeFile } from "node:fs/promises";
const payload = {
"model": "openai/gpt-image-2.6-flare",
"prompt": "A blue ceramic cup on a white background. No text, no people.",
"n": 1,
"size": "1024x1024",
"quality": "low",
"output_format": "png"
};
const response = await fetch("https://api.iteracompute.com/v1/images/generations", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify(payload),
signal: AbortSignal.timeout(1800000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
await writeFile("generated.png", Buffer.from(result.data[0].b64_json, "base64"));
console.log(result.usage);Gemini Nano Banana 2.1
O Gemini usa contents e generationConfig em vez de size e quality da OpenAI. Os exemplos solicitam um PNG quadrado de 1K com limite de saída de 3000 tokens.
set -e
curl --fail-with-body --max-time 1800 https://api.iteracompute.com/v1/images/generations \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"gemini/gemini-nano-banana-2.1","contents":[{"role":"user","parts":[{"text":"A blue ceramic cup on a white background. No text, no people."}]}],"generationConfig":{"maxOutputTokens":3000,"thinkingConfig":{"thinkingLevel":"MINIMAL","includeThoughts":false},"imageConfig":{"imageSize":"1K","aspectRatio":"1:1"}}}' \
-o generation-response.json && python3 - <<'PY'
import base64, json
from pathlib import Path
result = json.loads(Path("generation-response.json").read_text())
Path("generated.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])
PY# Install once: python -m pip install httpx
import base64
import os
from pathlib import Path
import httpx
payload = {'model': 'gemini/gemini-nano-banana-2.1',
'contents': [{'role': 'user',
'parts': [{'text': 'A blue ceramic cup on a white background. '
'No text, no people.'}]}],
'generationConfig': {'maxOutputTokens': 3000,
'thinkingConfig': {'thinkingLevel': 'MINIMAL',
'includeThoughts': False},
'imageConfig': {'imageSize': '1K',
'aspectRatio': '1:1'}}}
headers = {"Authorization": f"Bearer {os.environ['ITERACOMPUTE_API_KEY']}"}
with httpx.Client(timeout=1800.0, transport=httpx.HTTPTransport(retries=0)) as client:
response = client.post("https://api.iteracompute.com/v1/images/generations", headers=headers, json=payload)
response.raise_for_status()
result = response.json()
Path("generated.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])import { writeFile } from "node:fs/promises";
const payload = {
"model": "gemini/gemini-nano-banana-2.1",
"contents": [
{
"role": "user",
"parts": [
{
"text": "A blue ceramic cup on a white background. No text, no people."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 3000,
"thinkingConfig": {
"thinkingLevel": "MINIMAL",
"includeThoughts": false
},
"imageConfig": {
"imageSize": "1K",
"aspectRatio": "1:1"
}
}
};
const response = await fetch("https://api.iteracompute.com/v1/images/generations", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify(payload),
signal: AbortSignal.timeout(1800000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
await writeFile("generated.png", Buffer.from(result.data[0].b64_json, "base64"));
console.log(result.usage);Antes de editar, salve uma referência PNG como reference.png. A imagem e o prompt são entradas cobradas. O resultado é salvo como edited.png.
Use o formato de edição declarado pelo modelo: arquivos multipart em /v1/images/edits ou referências base64 inlineData em /v1/images/generations. O tipo MIME deve corresponder ao conteúdo.
OpenAI Image 2.6
Envie arquivos como formulário multipart. Deixe o cliente HTTP definir Content-Type com seu boundary. A edição aceita qualidade low, medium ou high e uma mask PNG opcional.
POSThttps://api.iteracompute.com/v1/images/edits
set -e
curl --fail-with-body --max-time 1800 https://api.iteracompute.com/v1/images/edits \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-F 'model=openai/gpt-image-2.6-flare' \
-F 'prompt=Change the cup to matte green. Keep its silhouette and white background.' \
-F 'n=1' \
-F 'size=1024x1024' \
-F 'quality=low' \
-F 'output_format=png' \
-F 'image[]=@reference.png;type=image/png' \
-o edit-response.json && python3 - <<'PY'
import base64, json
from pathlib import Path
result = json.loads(Path("edit-response.json").read_text())
Path("edited.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])
PY# Install once: python -m pip install httpx
import base64
import os
from pathlib import Path
import httpx
payload = {'model': 'openai/gpt-image-2.6-flare',
'prompt': 'Change the cup to matte green. Keep its silhouette and white '
'background.',
'n': 1,
'size': '1024x1024',
'quality': 'low',
'output_format': 'png'}
headers = {"Authorization": f"Bearer {os.environ['ITERACOMPUTE_API_KEY']}"}
with httpx.Client(timeout=1800.0, transport=httpx.HTTPTransport(retries=0)) as client:
with open("reference.png", "rb") as image:
response = client.post("https://api.iteracompute.com/v1/images/edits", headers=headers,
data=payload, files=[("image[]", ("reference.png", image, "image/png"))])
response.raise_for_status()
result = response.json()
Path("edited.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])import { readFile, writeFile } from "node:fs/promises";
const payload = {
"model": "openai/gpt-image-2.6-flare",
"prompt": "Change the cup to matte green. Keep its silhouette and white background.",
"n": 1,
"size": "1024x1024",
"quality": "low",
"output_format": "png"
};
const form = new FormData();
for (const [key, value] of Object.entries(payload)) form.append(key, String(value));
form.append("image[]", new Blob([await readFile("reference.png")], { type: "image/png" }), "reference.png");
const response = await fetch("https://api.iteracompute.com/v1/images/edits", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
},
body: form,
signal: AbortSignal.timeout(1800000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
await writeFile("edited.png", Buffer.from(result.data[0].b64_json, "base64"));
console.log(result.usage);Gemini Nano Banana 2.1
A edição no Gemini usa o endpoint de geração com referências inlineData em contents. mimeType deve corresponder ao arquivo; codifique os bytes em base64.
POSThttps://api.iteracompute.com/v1/images/generations
set -e
python3 - <<'PY'
import base64, json
from pathlib import Path
payload = {'model': 'gemini/gemini-nano-banana-2.1',
'contents': [{'role': 'user',
'parts': [{'inlineData': {'mimeType': 'image/png',
'data': 'REFERENCE_BASE64'}},
{'text': 'Change the cup to matte green. Keep its '
'silhouette and white background.'}]}],
'generationConfig': {'maxOutputTokens': 3000,
'thinkingConfig': {'thinkingLevel': 'MINIMAL',
'includeThoughts': False},
'imageConfig': {'imageSize': '1K',
'aspectRatio': '1:1'}}}
payload["contents"][0]["parts"][0]["inlineData"]["data"] = base64.b64encode(Path("reference.png").read_bytes()).decode()
Path("image-request.json").write_text(json.dumps(payload))
PY
curl --fail-with-body --max-time 1800 https://api.iteracompute.com/v1/images/generations \
-H "Authorization: Bearer $ITERACOMPUTE_API_KEY" \
-H "Content-Type: application/json" \
--data-binary @image-request.json \
-o edit-response.json && python3 - <<'PY'
import base64, json
from pathlib import Path
result = json.loads(Path("edit-response.json").read_text())
Path("edited.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])
PY# Install once: python -m pip install httpx
import base64
import os
from pathlib import Path
import httpx
payload = {'model': 'gemini/gemini-nano-banana-2.1',
'contents': [{'role': 'user',
'parts': [{'inlineData': {'mimeType': 'image/png',
'data': 'REFERENCE_BASE64'}},
{'text': 'Change the cup to matte green. Keep its '
'silhouette and white background.'}]}],
'generationConfig': {'maxOutputTokens': 3000,
'thinkingConfig': {'thinkingLevel': 'MINIMAL',
'includeThoughts': False},
'imageConfig': {'imageSize': '1K',
'aspectRatio': '1:1'}}}
payload["contents"][0]["parts"][0]["inlineData"]["data"] = base64.b64encode(Path("reference.png").read_bytes()).decode()
headers = {"Authorization": f"Bearer {os.environ['ITERACOMPUTE_API_KEY']}"}
with httpx.Client(timeout=1800.0, transport=httpx.HTTPTransport(retries=0)) as client:
response = client.post("https://api.iteracompute.com/v1/images/generations", headers=headers, json=payload)
response.raise_for_status()
result = response.json()
Path("edited.png").write_bytes(base64.b64decode(result["data"][0]["b64_json"]))
print(result["usage"])import { readFile, writeFile } from "node:fs/promises";
const payload = {
"model": "gemini/gemini-nano-banana-2.1",
"contents": [
{
"role": "user",
"parts": [
{
"inlineData": {
"mimeType": "image/png",
"data": "REFERENCE_BASE64"
}
},
{
"text": "Change the cup to matte green. Keep its silhouette and white background."
}
]
}
],
"generationConfig": {
"maxOutputTokens": 3000,
"thinkingConfig": {
"thinkingLevel": "MINIMAL",
"includeThoughts": false
},
"imageConfig": {
"imageSize": "1K",
"aspectRatio": "1:1"
}
}
};
payload.contents[0].parts[0].inlineData.data = (await readFile("reference.png")).toString("base64");
const response = await fetch("https://api.iteracompute.com/v1/images/generations", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.ITERACOMPUTE_API_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify(payload),
signal: AbortSignal.timeout(1800000),
});
if (!response.ok) throw new Error(`HTTP ${response.status}: ${await response.text()}`);
const result = await response.json();
await writeFile("edited.png", Buffer.from(result.data[0].b64_json, "base64"));
console.log(result.usage);As respostas incluem data[].b64_json, mime_type e usage.cost em USD. Os exemplos decodificam a imagem em vez de tratar base64 como URL. O uso real de tokens de texto, imagem e raciocínio determina a cobrança aos preços atuais do modelo.
- Imagens são cobradas separadamente da franquia gratuita de chat. Cada imagem é admitida e cobrada individualmente; o valor é arredondado para cima em microdólares USD. Consulte os preços atuais em Modelos.
- Comece com n=1; cada solicitação aceita de 1 a 4 imagens. As referências aceitam PNG, JPEG ou WebP, até quatro arquivos e 8 MiB decodificados no total, incluindo a mask. O limite da solicitação completa é 12 MiB.
- Image 2.6 usa dimensões explícitas em pixels e não oferece streaming. O Gemini aceita 1K, 2K ou 4K e aspectRatio em imageConfig; seus eventos SSE opcionais diferem do streaming de chat. Estes exemplos não usam streaming.
A estimativa não gera imagens. reservation_cost_micros da OpenAI é uma reserva conservadora de saldo, não um limite de saída do provedor nem a cobrança final. maximum_cost_micros do Gemini usa o limite de saída da solicitação. A liquidação usa o consumo real.
POSThttps://api.iteracompute.com/v1/images/price-estimate
curl --fail-with-body https://api.iteracompute.com/v1/images/price-estimate \
-H "Content-Type: application/json" \
-d '{"model":"openai/gpt-image-2.6-flare","prompt":"A blue ceramic cup","n":1,"size":"1024x1024","quality":"low"}'Em HTTP 207, verifique cada resultado e salve as imagens concluídas: as anteriores podem já ter sido cobradas. HTTP 422 pode incluir uso cobrável sem entregar uma imagem completa. A ausência de uso ou um timeout não prova gratuidade. Salve o ID e confirme o resultado antes de enviar outra solicitação paga.
6. Transmissão (SSE)
Defina "stream": true para receber eventos do servidor. Os fragmentos chegam conforme são gerados; o uso de tokens está incluído no último fragmento que contém usage, antes do evento final [DONE] . Trate todo o fluxo como uma única solicitação lógica: depois que tokens forem emitidos, a solicitação não será repetida de forma transparente.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.iteracompute.com/v1",
api_key=os.environ["ITERACOMPUTE_API_KEY"],
max_retries=0,
timeout=180.0,
)
stream = client.chat.completions.create(
model="deepseek/deepseek-v4.1-flash-1017",
messages=[{"role": "user", "content": "Reply with exactly: Hello!"}],
stream=True,
stream_options={"include_usage": True},
temperature=0,
max_tokens=128,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="")
if chunk.usage: # final chunk: token usage
print("\n", chunk.usage)7. Chamada de ferramenta
Os resultados das ferramentas são enviados em uma nova solicitação e também contam para os limites de taxa e concorrência da chave. Em um 429, verifique Retry-After e interrompa esta tentativa; não envie cópias em paralelo.
As ferramentas são declaradas no tools seguindo o formato de chamadas de funções da OpenAI. Quando o modelo decide chamar uma ferramenta, a resposta contém tool_calls; devolva os resultados da ferramenta com o papel "tool" para continuar a conversa.
import json
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.iteracompute.com/v1",
api_key=os.environ["ITERACOMPUTE_API_KEY"],
max_retries=0,
timeout=180.0,
)
messages = [{"role": "user", "content": "What is the weather in Singapore?"}]
tools = [{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {"city": {"type": "string"}},
"required": ["city"],
},
},
}]
resp = client.chat.completions.create(
model="deepseek/deepseek-v4.1-flash-1017",
messages=messages,
tools=tools,
tool_choice={"type": "function", "function": {"name": "get_weather"}},
max_tokens=512,
)
assistant_message = resp.choices[0].message
messages.append(assistant_message)
for call in assistant_message.tool_calls or []:
arguments = json.loads(call.function.arguments)
result = {"city": arguments["city"], "temperature_c": 29}
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(
model="deepseek/deepseek-v4.1-flash-1017",
messages=messages,
tools=tools,
max_tokens=512,
)
print(final.choices[0].message.content)8. Códigos de erro
Os erros de Chat Completions e Responses usam o formato de erro da OpenAI com um corpo JSON de {"error": {"message", "type", "code"}}:
| Estado | Significado |
|---|---|
| 400 | Solicitação inválida – JSON malformado ou parâmetros obrigatórios ausentes |
| 401 | Falha na autenticação – chave de API ausente ou inválida |
| 403 | A chave não tem permissão para este modelo ou ação. Se houver restrição por modelo, adicione o novo Model ID à lista de modelos permitidos no console, salve e tente novamente. |
| 404 | Modelo ou endpoint desconhecido |
| 429 | Limite de taxa ou capacidade: confira error.code e as instruções de recuperação abaixo |
| 500 | Erro interno: salve o ID da solicitação e confirme o resultado antes de tentar novamente |
| 503 | Modelo temporariamente indisponível. Tente novamente com espera |
As cotas gratuitas do Auto são compartilhadas entre todas as chaves API da conta. Free / Starter / Pro oferecem 30M / 100M / 300M tokens por mês civil UTC e contexto de 128K / 128K / 256K. Cada nível permite uma solicitação na fila ou em geração por conta, sem limite de TPM ou tokens diários. Uma recarga líquida concluída acumulada de $10 ou $50 libera Starter ou Pro, com prioridade na fila da capacidade compartilhada. Pode haver espera ou lentidão; velocidade e latência não são garantidas. As cotas Auto compradas seguem seus próprios limites contratuais. Os demais modelos mantêm os limites das chaves API, incluindo os limites de RPM ou TPM configurados.
Resolver erros 429 por causa
Verifique error.code antes de tentar novamente. Recusas por cota mensal usam free_model_monthly_limit. Uma solicitação gratuita pendente, fila cheia, tempo de espera esgotado e outras recusas de capacidade compartilham provider_rate_limit; a resposta pública não os distingue. Confira os limites da conta em Console → Free e se uma solicitação anterior continua ativa.
- Cota mensal usada ou reservada
free_model_monthly_limit Interrompa as tentativas automáticas. Confira os tokens usados e reservados e a data de renovação em Console → Free. Retome após a renovação do mês UTC, uma mudança de nível com cota suficiente ou a liberação de reservas existentes. Repetir tentativas não aumenta a cota; a mudança mantém o uso do mês e não há cobrança automática por excedente.
- Já existe uma solicitação gratuita na fila ou em geração
provider_rate_limit Espere a solicitação na fila ou em geração terminar antes de tentar novamente e respeite Retry-After. Free, Starter e Pro compartilham uma solicitação gratuita pendente entre todas as chaves e rotas gratuitas da conta; trocar a chave ou o Model ID não adiciona outra vaga. Não envie cópias em paralelo. Confira o uso e as reservas em Console → Free. O código público provider_rate_limit também pode indicar outros limites de capacidade.
- Capacidade: fila cheia
provider_rate_limit A fila não comporta novas requisições. Tente somente após Retry-After, com espera exponencial e aleatória; reduza o paralelismo. Pare ao atingir o limite de tentativas ou o prazo da aplicação. O código compartilhado também pode indicar outros limites de capacidade, não uma posição na fila. Confira os limites em Console → Free; se persistir, contate o suporte com o ID da requisição.
- Capacidade: espera na fila esgotada
provider_rate_limit A requisição não obteve capacidade em 120 segundos. Uma nova tentativa reinicia a espera; tente somente se houver tempo restante, após Retry-After e a espera progressiva. Pare ao atingir o prazo ou limite de tentativas e nunca envie cópias paralelas. O código público é o mesmo de fila cheia. Se ocorrer repetidamente, contate o suporte com o ID e o horário.
Ver cota, reservas e limites de solicitações · Contatar o suporte
Perguntas sobre modelos gratuitos antes de recarregar
A promoção gratuita termina em 24 de novembro de 2026 às 00:00, horário do Pacífico dos EUA. Usuários com recarga líquida positiva creditada antes do prazo mantêm seu nível gratuito. Após o prazo, o Auto gratuito compartilhado fica limitado a esses usuários e a assinantes com plano vigente. Recargas posteriores não concedem nem ampliam os benefícios gratuitos. Os tokens Auto do plano e os benefícios gratuitos mensais compartilhados são cotas independentes.
Como o acesso gratuito é liberado para novas contas?
Antes do fim da promoção, aplicam-se estas regras. A verificação do e-mail libera imediatamente a franquia Free completa de 30M tokens por mês. Free, Starter e Pro permitem uma solicitação em fila ou execução por conta. Todas as chaves e o Auto usam capacidade compartilhada, que pode ser lenta. Não há limites de tokens diários, nem requisitos de chamadas ou datas UTC para subir de nível. O uso mensal inclui entrada e saída; limites de contexto, filas de capacidade compartilhada e análises de abuso continuam aplicáveis. Após o prazo, apenas usuários que já haviam recarregado e atendem aos requisitos, e assinantes de planos, podem usar o Auto grátis.
O que acontece se várias contas parecerem relacionadas?
Relações entre dispositivos, densidade de cadastros, horários das solicitações e resultados de verificação podem exigir verificações adicionais. Compartilhar um IP não confirma uma relação: empresas, instituições de ensino e famílias podem compartilhar a rede. Passar em uma verificação humana também não comprova titulares distintos. Somente quando a análise confirma um mesmo titular acumulando vários testes, essas contas compartilham uma franquia mensal gratuita e uma solicitação em fila ou execução entre todas as chaves e o Auto. A capacidade compartilhada pode ser lenta. Contate o suporte para revisão ou recurso.
Os tokens Auto do plano e os benefícios gratuitos compartilhados são a mesma cota?
Não. Os tokens Auto comprados e os benefícios gratuitos mensais compartilhados têm cotas e registros de uso independentes. O Auto do plano usa agendamento prioritário e segue o período comprado e os limites do contrato. As solicitações usam primeiro o Auto do plano; as não cobertas só podem usar benefícios gratuitos compartilhados enquanto a conta for elegível, com possíveis filas e respostas lentas. Comprar ou renovar um plano não zera o uso gratuito compartilhado. Após o vencimento, apenas quem atende ao requisito de recarga anterior ao prazo mantém o acesso gratuito compartilhado.
Por que as solicitações gratuitas podem entrar na fila ou ficar lentas?
O Auto usa capacidade de GPU ociosa compartilhada. A demanda atual supera os recursos disponíveis, podendo causar filas, respostas lentas ou indisponibilidade temporária. Os níveis com recarga têm prioridade na fila, sem reservar GPUs nem garantir vazão, latência ou SLA. Agradecemos a compreensão.
O modelo gratuito é sempre servido com a mesma precisão?
A precisão e a quantização do modelo dependem da implantação real e podem mudar. O nome do modelo não garante precisão completa nem resultados idênticos entre implantações. Teste suas tarefas representativas antes de recarregar e confira a correção, as chamadas de ferramentas e o tempo de resposta conforme suas necessidades.
Uma recarga maior oferece mais benefícios de modelos gratuitos?
Estes benefícios são mantidos para quem recarregou antes do prazo. Uma recarga líquida acumulada de $10 libera o Starter: 100M tokens/mês e contexto de 128K. Com $50, o Pro oferece 300M tokens/mês e contexto de 256K. Ambos têm prioridade na fila. Recarregar acima de $50 não acrescenta automaticamente benefícios de modelos gratuitos. A recarga permanece como saldo utilizável na API; esses limites não são mensalidades. Só conta o principal de recargas creditadas antes do prazo; as posteriores não ampliam esses níveis. Reembolsos reduzem o principal líquido elegível.
O que os benefícios vitalícios incluem?
O seguinte só se aplica a usuários que atendem ao requisito de recarga anterior ao prazo. Para usuários com recarga, benefícios vitalícios significam manter a franquia mensal de tokens, limite de contexto e prioridade na fila do nível Starter ou Pro alcançado, inclusive após atualização ou substituição do modelo gratuito. Gastar o saldo não reduz o nível; reembolsos podem alterá-lo e as regras contra abuso continuam válidas. Isso não fixa o nome, os pesos ou a precisão do modelo, nem promete uso ilimitado, capacidade dedicada ou disponibilidade permanente do serviço.
O modelo gratuito vai mudar? E o Qwen4-27B?
Os modelos gratuitos podem ser atualizados, substituídos ou sofrer outras alterações. Planejamos oferecer o Qwen4-27B, aguardando o lançamento oficial do modelo de código aberto; ainda não há data confirmada nem especificações publicadas. Usuários com recarga mantêm os benefícios de nível descritos acima. Para quem não recarregou, o acesso, as franquias e os limites futuros não são garantidos.
Perguntas de integração: support@iteracompute.com