Documentación API
Última actualización: noviembre de 2026
Empieza con tu primera solicitud y consulta los ejemplos de API y la solución de problemas.
En esta página
- Regístrate y verifica tu correo electrónico, o inicia sesión con Google.No se requiere tarjeta ni recarga.
- Crea una clave que permita Auto y guarda el secreto que se muestra una sola vez.Abrir API Keys
- Elige Bash (cURL y Python 3), Python 3 o JavaScript (Node.js 18+). Sustituye your-api-key por tu clave. Bash guarda 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);El éxito requiere choices[0].message.content no vacío. Cada ejemplo imprime la respuesta y falla si está vacía. Salida esperada: Hello! (el texto puede variar).
Los tres ejemplos usan Qwen gratuito con el razonamiento desactivado. Para 401/403, revisa la clave y los permisos del modelo. Para 429, sigue los pasos de recuperación de abajo.
La API de IteraCompute es compatible con OpenAI. Si tu aplicación ya utiliza la API de OpenAI, para migrar debes cambiar base_url y la clave API. Chat Completions, Responses, streaming y las llamadas a herramientas siguen formatos compatibles cuando el modelo seleccionado los admite.
Las solicitudes API se envían a https://api.iteracompute.com/v1. Las solicitudes de Chat Completions y Responses se autentican mediante la clave API en la cabecera 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}'Utiliza exactamente el identificador provider/model devuelto por el endpoint Models; no añadas el prefijo iteracompute/ . Consulta los modelos que publica actualmente la pasarela:
curl --fail-with-body https://api.iteracompute.com/v1/modelsEl endpoint Models es público y devuelve el catálogo actual de la pasarela. Utiliza los valores de id exactamente como se devuelven. El acceso comercial a cada modelo sigue estando sujeto a tu clave API y al acuerdo aplicable.
Soporte y costos del modelo.
Los ejemplos de Chat Completions, Responses, streaming y llamadas a herramientas usan el modelo de pago DeepSeek V4.1 Flash 1017 y descuentan el uso del saldo API. Consulta los precios actuales de entrada, entrada en caché y salida en Modelos. Qwen3.8-27B gratuito admite Chat Completions, streaming y herramientas; esta guía no verifica su compatibilidad con Responses API. Los IDs y parámetros de razonamiento no son intercambiables. Confirma las interfaces y opciones del modelo antes de adaptar un ejemplo.
Las tres pestañas de lenguaje llaman al mismo endpoint HTTP. Configura ITERACOMPUTE_API_KEY en el entorno antes de ejecutar un ejemplo. Los ejemplos de JavaScript usan Node.js 18 o posterior.
Estos ejemplos desactivan los reintentos automáticos. Ante un 429, revisa el cuerpo del error y Retry-After. Detén los reintentos si se agota la cuota mensual. Tras un tiempo de espera agotado, una desconexión o un 5xx, guarda el ID y confirma el resultado antes de enviar otra solicitud facturable.
Todos los modelos de conversación publicados admiten OpenAI Chat Completions y Anthropic Messages. La compatibilidad con Responses y las funciones dependen de los límites documentados de cada modelo.
4. Chat Completions
POST /v1/chat/completions Sigue el formato de solicitud y respuesta de 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 ejemplo usa DeepSeek V4.1 Flash 1017. Puedes elegir cualquier modelo de conversación publicado que permita tu clave. El ejemplo de Python usa solo la biblioteca estándar. Messages conserva las respuestas y errores nativos de Anthropic; sus flujos terminan con message_stop en lugar 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 admite la API OpenAI Responses utilizada 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(""));Usa la API de imágenes con un modelo de imagen publicado y una clave API autorizada. Consulta su disponibilidad actual en el catálogo de modelos antes de llamar a la API.
Genere imágenes con un ID de modelo y un prompt o contents nativo. Use solo los campos compatibles con el modelo elegido. Autentíquese con su clave y guarde la imagen base64 localmente.
POSThttps://api.iteracompute.com/v1/images/generations
Estos ejemplos de pago crean una imagen y la guardan localmente. Configure primero ITERACOMPUTE_API_KEY. cURL requiere Bash y Python 3; Python usa httpx; JavaScript usa Node.js 18+.
| ID del modelo | Generación | Edición con referencia |
|---|---|---|
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 y Sunburst usan los mismos campos. Para usar Sunburst, sustituya el ID por openai/gpt-image-2.6-sunburst. Los ejemplos solicitan calidad low a 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
Gemini usa contents y generationConfig en lugar de size y quality de OpenAI. Los ejemplos solicitan un PNG cuadrado de 1K con un límite de salida 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, guarde una referencia PNG como reference.png. La imagen y el prompt son entrada facturable. El resultado se guarda como edited.png.
Use el formato de edición del modelo: archivos multipart en /v1/images/edits o referencias base64 inlineData en /v1/images/generations. El tipo MIME debe coincidir con el contenido.
OpenAI Image 2.6
Suba los archivos como formulario multipart. Deje que el cliente HTTP establezca Content-Type con su boundary. La edición acepta calidad low, medium o high y una 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
La edición con Gemini usa el endpoint de generación con referencias inlineData dentro de contents. mimeType debe coincidir con el archivo; codifique los bytes en 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);Las respuestas incluyen data[].b64_json, mime_type y usage.cost en USD. Los ejemplos decodifican la imagen en vez de tratar base64 como URL. El uso real de tokens de texto, imagen y razonamiento determina el importe según los precios vigentes del modelo.
- Las imágenes se cobran aparte de la cuota gratuita de chat. Cada imagen se admite y factura por separado; el importe se redondea hacia arriba a microdólares USD. Consulte los precios actuales en Modelos.
- Empiece con n=1; cada solicitud acepta de 1 a 4 imágenes. Las referencias admiten PNG, JPEG o WebP, hasta cuatro archivos y 8 MiB decodificados en total, incluida la mask. La solicitud completa se limita a 12 MiB.
- Image 2.6 usa dimensiones explícitas en píxeles y no admite streaming. Gemini acepta 1K, 2K o 4K y aspectRatio en imageConfig; sus eventos SSE opcionales son distintos del streaming de chat. Estos ejemplos no usan streaming.
La estimación no genera imágenes. reservation_cost_micros de OpenAI es una reserva conservadora de saldo, no un límite de salida del proveedor ni el importe final. maximum_cost_micros de Gemini usa el límite de salida de la solicitud. La liquidación se basa en el uso 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"}'Con HTTP 207, revise cada resultado y conserve las imágenes completadas: las anteriores pueden haberse facturado. HTTP 422 puede incluir uso facturable sin entregar una imagen completa. La ausencia de uso o un timeout no implica gratuidad. Guarde el ID y confirme el resultado antes de enviar otra solicitud de pago.
6. Transmisión (SSE)
Establece "stream": true para recibir eventos del servidor. Los fragmentos llegan a medida que se generan; el uso de tokens se incluye en el último fragmento que contiene usage, antes del evento final [DONE] . Trata todo el flujo como una única solicitud lógica: una vez emitidos los tokens, la solicitud no se reintenta 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. Llamada de herramientas
Los resultados de herramientas se envían en una nueva solicitud y también cuentan para los límites de frecuencia y concurrencia de la clave. Ante un 429, revisa Retry-After y detén este intento; no envíes copias en paralelo.
Las herramientas están declaradas en el tools siguiendo el formato de llamadas a funciones de OpenAI. Cuando el modelo decide llamar a una herramienta, la respuesta contiene tool_calls; devuelve los resultados de la herramienta con el rol "tool" para continuar la conversación.
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 error
Los errores de Chat Completions y Responses usan el formato de error de OpenAI con un cuerpo JSON de {"error": {"message", "type", "code"}}:
| Estado | Significado |
|---|---|
| 400 | Solicitud no válida: JSON con formato incorrecto o faltan parámetros requeridos |
| 401 | Error de autenticación: clave API faltante o no válida |
| 403 | La clave no tiene permiso para este modelo o acción. Si está restringida por modelo, añade el nuevo Model ID a su lista de modelos permitidos en la consola, guarda y reintenta. |
| 404 | Modelo o punto final desconocido |
| 429 | Límite de tasa o capacidad: revisa error.code y los pasos de recuperación de abajo |
| 500 | Error interno: guarda el ID de la solicitud y confirma el resultado antes de reintentar |
| 503 | Modelo no disponible temporalmente: vuelva a intentarlo con retroceso |
Las cuotas gratuitas de Auto se comparten entre todas las claves API de la cuenta. Free / Starter / Pro ofrecen 30M / 100M / 300M tokens por mes natural UTC y un contexto de 128K / 128K / 256K. Cada nivel permite una solicitud en cola o en generación por cuenta, sin límite de TPM ni tokens diarios. Una recarga neta completada acumulada de $10 o $50 desbloquea Starter o Pro, con prioridad en la cola de capacidad compartida. Puede haber esperas o lentitud; no se garantizan velocidad ni latencia. Las cuotas Auto compradas siguen sus propios límites contractuales. Los demás modelos conservan los límites de sus claves API, incluidos los topes de RPM o TPM configurados.
Resolver errores 429 por causa
Revise error.code antes de reintentar. Los rechazos por cuota mensual usan free_model_monthly_limit. Una solicitud gratuita pendiente, una cola llena, los tiempos de espera agotados y otros rechazos de capacidad comparten provider_rate_limit; la respuesta pública no los distingue. Revise los límites de la cuenta en Consola → Free y si una solicitud anterior sigue activa.
- Cuota mensual usada o reservada
free_model_monthly_limit Detén los reintentos automáticos. Consulta los tokens usados y reservados y la fecha de reinicio en Consola → Free. Reanuda tras el reinicio del mes UTC, una mejora de nivel con cuota suficiente o la liberación de reservas existentes. Reintentar no añade cuota; la mejora conserva el uso del mes y no hay sobreconsumo de pago automático.
- Ya hay una solicitud gratuita en cola o en generación
provider_rate_limit Espere a que termine la solicitud en cola o en generación antes de reintentar y respete Retry-After. Free, Starter y Pro comparten una solicitud gratuita pendiente entre todas las claves y rutas gratuitas de la cuenta; cambiar de clave o Model ID no añade otra plaza. No envíe copias en paralelo. Revise el uso y las reservas en Consola → Free. El código público provider_rate_limit también puede indicar otros límites de capacidad.
- Capacidad: cola llena
provider_rate_limit La cola no admite nuevas solicitudes. Reintenta solo tras Retry-After, con espera exponencial y aleatoria; reduce el paralelismo. Detente al agotar tus reintentos o el plazo de la aplicación. El código compartido también puede indicar otros límites de capacidad, no una posición en cola. Consulta los límites en Consola → Free; si persiste, contacta con soporte con el ID de solicitud.
- Capacidad: espera en cola agotada
provider_rate_limit La solicitud no obtuvo capacidad en 120 segundos. Un nuevo intento inicia otra espera; reintenta solo si queda tiempo suficiente, tras Retry-After y la espera progresiva. Detente al alcanzar tu plazo o límite de reintentos y nunca envíes copias paralelas. El código público es el mismo que para una cola llena. Si se repite, contacta con soporte con el ID y la hora.
Ver cuota, reservas y límites de solicitudes · Contactar con soporte
Preguntas sobre modelos gratuitos antes de recargar
La promoción gratuita termina el 24 de noviembre de 2026 a las 00:00, hora del Pacífico de EE. UU. Quienes tengan una recarga neta positiva acreditada antes del cierre conservan su nivel gratuito. Después, el Auto gratuito compartido queda limitado a estos usuarios y a quienes tengan un plan vigente. Las recargas posteriores no otorgan ni mejoran los beneficios gratuitos. Los tokens Auto del plan y los beneficios gratuitos mensuales compartidos son cuotas independientes.
¿Cómo se habilita el acceso gratuito para las cuentas nuevas?
Antes del cierre de la promoción se aplican estas reglas. Verificar el correo habilita inmediatamente la cuota Free completa de 30M tokens al mes. Free, Starter y Pro permiten una solicitud en cola o en ejecución por cuenta. Todas las claves y Auto usan capacidad compartida que puede ser lenta. No hay límites de tokens diarios, ni requisitos de llamadas o fechas UTC para subir de nivel. El uso mensual incluye entrada y salida; siguen vigentes los límites de contexto, las colas de capacidad compartida y las revisiones por abuso. Después del cierre, solo los usuarios que ya habían recargado y cumplen los requisitos, y los suscriptores de planes, pueden usar Auto gratis.
¿Qué sucede si varias cuentas parecen estar relacionadas?
La relación entre dispositivos, la densidad de registros, los horarios de las solicitudes y los resultados de verificación pueden requerir comprobaciones adicionales. Compartir una IP no confirma una relación: empresas, centros educativos y hogares pueden compartir red. Superar una comprobación humana tampoco demuestra titulares distintos. Solo cuando una revisión confirma que un mismo titular reúne varias pruebas, esas cuentas comparten una cuota mensual gratuita y una solicitud en cola o en ejecución entre todas las claves y Auto. La capacidad compartida puede ser lenta. Contacta con soporte para una revisión o apelación.
¿Los tokens Auto del plan y los beneficios gratuitos compartidos son la misma cuota?
No. Los tokens Auto comprados y los beneficios gratuitos mensuales compartidos tienen cuotas y registros de uso independientes. Auto del plan usa programación prioritaria y está sujeto al período comprado y a los límites del contrato. Las solicitudes usan primero Auto del plan; las no cubiertas solo pueden usar beneficios gratuitos compartidos mientras la cuenta sea elegible, con posibles colas y respuestas lentas. Comprar o renovar un plan no reinicia el uso gratuito compartido. Al vencer el plan, solo quienes cumplen el requisito de recarga anterior al cierre conservan el acceso gratuito compartido.
¿Por qué las solicitudes gratuitas pueden esperar o ralentizarse?
Auto usa capacidad GPU libre compartida. La demanda actual supera los recursos disponibles, por lo que puede haber colas, respuestas lentas o indisponibilidad temporal. Los niveles con recarga tienen prioridad en la cola, sin reservar GPU ni garantizar rendimiento, latencia o un SLA. Gracias por tu comprensión.
¿El modelo gratuito se sirve siempre con la misma precisión?
La precisión y cuantización del modelo dependen del despliegue real y pueden cambiar. El nombre del modelo no garantiza precisión completa ni resultados idénticos entre despliegues. Prueba tus tareas representativas antes de recargar y comprueba la exactitud, las llamadas a herramientas y el tiempo de respuesta según tus necesidades.
¿Una recarga mayor da más beneficios para modelos gratuitos?
Estos beneficios se conservan para quienes recargaron antes del cierre. Una recarga neta acumulada de $10 desbloquea Starter: 100M tokens/mes y contexto de 128K. Con $50, Pro ofrece 300M tokens/mes y contexto de 256K. Ambos tienen prioridad en la cola. Recargar más de $50 no añade automáticamente beneficios de modelos gratuitos. La recarga sigue siendo saldo utilizable para la API; estos umbrales no son cuotas mensuales. Solo cuenta el principal de recargas acreditadas antes del cierre; las posteriores no mejoran estos niveles. Los reembolsos reducen el principal neto elegible.
¿Qué cubren los beneficios de por vida?
Lo siguiente solo se aplica a usuarios que cumplen el requisito de recarga anterior al cierre. Para los usuarios con recarga, los beneficios de por vida significan conservar la cuota mensual de tokens, límite de contexto y prioridad en la cola del nivel Starter o Pro alcanzado, incluso tras actualizar o sustituir el modelo gratuito. Gastar el saldo no reduce el nivel; los reembolsos pueden cambiarlo y las normas contra abusos siguen vigentes. Esto no fija el nombre, los pesos ni la precisión del modelo, ni promete uso ilimitado, capacidad dedicada o disponibilidad permanente del servicio.
¿Cambiará el modelo gratuito? ¿Qué ocurre con Qwen4-27B?
Los modelos gratuitos pueden actualizarse, sustituirse o cambiar de otro modo. Planeamos ofrecer Qwen4-27B, pendiente de la publicación oficial del modelo de código abierto; aún no hay fecha de lanzamiento confirmada ni especificaciones publicadas. Los usuarios con recarga conservan los beneficios de nivel descritos arriba. Para quienes no han recargado, el acceso, las cuotas y los límites futuros no están garantizados.
Preguntas de integración: support@iteracompute.com