Algunos trabajos con LLM no son chats. Tiene 50,000 tickets de soporte que etiquetar, 200,000 descripciones de productos que traducir o un millón de reseñas que puntuar. Proveedores como OpenAI y Anthropic venden una Batch API para esto. Muchas APIs compatibles con OpenAI, entre ellas BroadNet Inference, no la tienen. Este artículo muestra cómo ejecutar el trabajo usted mismo: calcular cuánto tardará, escribir un runner que respete los límites y hacer que sea seguro detenerlo y reiniciarlo.
BroadRouter es el sitio de BroadNet, así que los ejemplos numéricos usan los límites publicados por BroadNet. El método funciona con cualquier API de chat completions; sustituya las cifras por las de su proveedor.
¿BroadNet Inference tiene Batch API?
No. La referencia de la API, consultada el 15 de noviembre de 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions y GET /v1/models (una lista de modelos), además de endpoints de cuenta en /portal/. No hay endpoint de lotes ni de carga de archivos, ni descuento por lotes. Un trabajo masivo es un bucle de solicitudes normales.
Esto es lo que ofrece una Batch API gestionada, para que sepa qué está reconstruyendo:
| Batch API de OpenAI | Message Batches de Anthropic | Su propio runner | |
|---|---|---|---|
| Precio | 50 % menos que en modo síncrono | 50 % de descuento | Precio normal |
| Tiempo de entrega | En 24 horas | La mayoría en 1 hora; caduca a las 24 | Lo fijan sus rate limits |
| Tamaño por lote | 50,000 solicitudes o 200 MB | 100,000 solicitudes o 256 MB | Cualquier tamaño |
| Rate limits | Separados de los límites por modelo | Aplican a las solicitudes en cola | Los límites de su clave |
| Orden de resultados | Puede variar; empareje por custom_id |
Empareje por custom_id |
Usted asocia los resultados por ID |
Hay dos lecciones que se trasladan. Ambos proveedores le obligan a etiquetar cada solicitud con un ID, porque los resultados no vuelven en orden. Ninguno promete una respuesta en segundos. Su runner debe funcionar igual: ID en todo y un plan medido en horas.
Si un descuento del 50 % importa más que el tiempo de entrega, y los modelos que necesita están ahí, una Batch API gestionada puede ser la herramienta más barata. Calcule el costo de ambas opciones con la calculadora de costos de API de LLM antes de construir.
¿Cuánto tardará el trabajo?
Calcúlelo antes de escribir código. Dos límites restringen el rendimiento, y manda el más lento:
- Límite de solicitudes en curso ÷ latencia. Con 4 solicitudes en curso y 2 segundos por solicitud, puede terminar 2 por segundo.
- Solicitudes por minuto. A 30 por minuto, puede iniciar 0.5 por segundo, por rápido que sea el modelo.
Una clave de pago por uso de BroadNet permite 4 solicitudes en curso y 30 por minuto. Con los valores de la referencia de la API cuando la consultamos (30 por minuto y 4 en curso, 2026-11-15), el rate limit es el que manda salvo que cada solicitud tarde más de 8 segundos, y la tabla siguiente usa 30 por minuto:
| Elementos | Un elemento por solicitud | 20 elementos por solicitud |
|---|---|---|
| 10,000 | 5.6 horas | 17 minutos |
| 100,000 | 2.3 días | 2.8 horas |
| 1,000,000 | 23 días | 28 horas |
A 30 solicitudes por minuto, una clave hace 1,800 solicitudes por hora, o 43,200 al día. Los reintentos también cuentan: cada 429 que provoque consume un hueco.
La segunda columna es la palanca más grande. Los elementos cortos, como reseñas o asuntos de tickets, pueden ir de 10 a 50 por solicitud como lista numerada, con un array JSON de vuelta. Compruebe que el array tenga una entrada por elemento y que cada una lleve su número. El artículo de clasificación de texto en árabe muestra el patrón. Los elementos largos no se agrupan: cada solicitud tiene que caber en la ventana de contexto del modelo, y la calidad puede bajar a medida que crece la lista. Pruebe la agrupación con 200 elementos antes de confiar en ella.
No reparta un trabajo entre varias claves para superar un límite por clave sin preguntar. La Política de Uso Aceptable de BroadNet prohíbe eludir límites de tasa, de concurrencia o de presupuesto. Si necesita más, pregunte a BroadNet o use sesiones de plan, más abajo. El planificador de trabajos por lotes hace este cálculo para su número de elementos, su latencia y sus límites.
¿Cómo es un runner reanudable?
Este runner lee items.jsonl (un objeto {"id", "text"} por línea) y anexa una línea de resultado por elemento a results.jsonl. Solo necesita el SDK de OpenAI para Python.
import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError
client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
api_key=os.environ["BROADNET_API_KEY"],
max_retries=0, # we retry ourselves, with a cap we can see
timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4")) # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30")) # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6
class Pacer:
"""Spaces request starts at least 60/RPM seconds apart, across all workers."""
def __init__(self, rpm):
self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
async def wait(self):
async with self.lock:
now = time.monotonic()
delay = max(0.0, self.next - now)
self.next = max(now, self.next) + self.gap
await asyncio.sleep(delay)
def retryable(e):
if isinstance(e, (APIConnectionError, APITimeoutError)):
return True
return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)
async def call(item, pacer):
for attempt in range(MAX_ATTEMPTS):
await pacer.wait() # every attempt counts against the rate limit
try:
r = await client.chat.completions.create(
model=MODEL, max_tokens=1500, reasoning_effort="low",
messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
{"role": "user", "content": item["text"]}])
c = r.choices[0]
return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
"output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
except Exception as e:
if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt))) # full jitter, capped
async def run(in_path, out_path):
done = set()
if os.path.exists(out_path): # resume: skip ids that already succeeded
with open(out_path) as f:
done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
print(f"{len(done)} done, {len(todo)} to go")
pacer, queue = Pacer(RPM), asyncio.Queue()
for it in todo:
queue.put_nowait(it)
with open(out_path, "a") as out:
async def worker():
while True:
try:
it = queue.get_nowait()
except asyncio.QueueEmpty:
return
res = await call(it, pacer)
out.write(json.dumps(res, ensure_ascii=False) + "\n")
out.flush() # one line per finished item = the checkpoint
await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))
if __name__ == "__main__":
import sys
asyncio.run(run(sys.argv[1], sys.argv[2]))
Ejecútelo con python batch_run.py items.jsonl results.jsonl. Probamos exactamente este archivo contra un servidor simulado local que devolvía 429 aleatorios (8 %) y 500 (5 %) y rechazaba cualquier cosa por encima de 4 en curso o 30 inicios por minuto. 25 elementos terminaron en 55 segundos con 28 solicitudes (3 reintentos), y nunca hubo más de 30 inicios en ninguna ventana de 60 segundos. Con el límite del simulador elevado a 300 por minuto para ahorrar tiempo, una ejecución de 120 elementos interrumpida a los 10 segundos se reanudó desde 39 resultados guardados y terminó con 120 ID únicos y sin duplicados.
¿Por qué un pool de workers y no asyncio.gather?
La guía del error 429 usa un semáforo alrededor de asyncio.gather. Eso está bien para unos cientos de llamadas. Para un trabajo grande, es mejor un pool fijo de workers que toman elementos de una cola:
- Memoria.
gathercrea una tarea por elemento desde el principio. Un pool solo mantiene los elementos en curso. - La concurrencia es el tamaño del pool. Cuatro workers nunca pueden tener cinco solicitudes abiertas.
- Los resultados se escriben en disco a medida que terminan, en cualquier orden, asociados por ID.
El Pacer se ocupa del segundo límite. Un semáforo por sí solo evita superar 4 en curso, pero si las solicitudes tardan un segundo, cuatro workers iniciarían 240 por minuto y recibirían 429 en la mayoría. El pacer espacia los inicios 2 segundos entre todos los workers, reintentos incluidos.
¿Cómo se mantienen seguros los reintentos?
Reintente solo lo que puede funcionar en un segundo intento:
| Respuesta | Acción |
|---|---|
| 429 | Espere y reintente; la documentación de BroadNet dice “use response details and bounded backoff” (Traducción: use los detalles de la respuesta y un backoff acotado) |
| 500, 502, 503, 504, timeouts, conexiones caídas | Reintente con backoff exponencial acotado |
| 400, 422 | Corrija la solicitud; reintentar envía el mismo error |
| 401, 402, 403 | Detenga el trabajo; la clave, el saldo o la política requieren atención |
| 413 | Acorte el elemento |
El runner desactiva los reintentos propios del SDK (max_retries=0) para que haya exactamente una política de reintentos, con un tope visible. El backoff es exponencial con full jitter, con un tope de 60 segundos, para que los workers que fallaron juntos no reintenten juntos. Tras seis intentos, el elemento se escribe con "ok": false y el trabajo sigue. Un elemento defectuoso nunca detiene un millón.
Una llamada al modelo no tiene efectos secundarios, así que aquí la entrega es “al menos una vez”: si el proceso muere a mitad de una solicitud, ese elemento se envía de nuevo al reiniciar, y lo paga dos veces. Ese es el único desperdicio. Si el trabajo también escribe en otro sistema, como tickets o correos, haga esa escritura idempotente por ID de elemento y hágala en una pasada aparte sobre results.jsonl. El artículo sobre agentes de larga duración trata a fondo los efectos secundarios idempotentes.
¿Cómo funciona el checkpointing?
El archivo de salida es el checkpoint. Cada elemento terminado es una línea vaciada a disco, así que tras una caída, un despliegue o un Ctrl-C, la siguiente ejecución lee el archivo, reúne los ID con "ok": true y encola solo el resto. Los elementos que fallaron antes se reintentan en la siguiente ejecución y su nueva línea se anexa. Al leer los resultados, quédese con la última línea de cada ID.
Tres hábitos hacen que esto aguante durante días:
- ID estables. Use una clave de base de datos o un hash de la entrada, nunca un número de línea que cambia cuando cambia el archivo de entrada.
- Revise
finish_reason. Una respuesta cortada enmax_tokenses"ok": truepero inútil. DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder, y el razonamiento cuenta dentro de max_tokens. El runner fijareasoning_effort="low", que BroadNet documenta, y deja 1,500 tokens. - Registre el uso en cada línea. Sumar
usagederesults.jsonlle da la factura real de tokens para compararla con su estimación.
¿Cuánto cuesta: pago por uso o una sesión de plan?
En pago por uso, el costo son los tokens. Tome 100,000 reseñas, un prompt de sistema de 150 tokens, una reseña de 150 tokens y 100 tokens de salida con razonamiento bajo. Eso son 30 millones de tokens de entrada y 10 millones de salida. En DeepSeek V4.1 Flash cuesta 30 × $0.175 + 10 × $0.52. Mantenga el prompt de sistema al principio e idéntico byte a byte, y sus 15 millones de tokens pueden cobrarse a la tarifa de entrada en caché de $0.0055 por 1M cuando la caché acierta. Sus líneas de usage muestran con qué frecuencia lo hizo.
En un plan, los tokens son gratis y el costo es el tiempo. Una sesión de plan de DeepSeek V4.1 Flash “runs one request at a time” (Traducción: ejecuta una solicitud a la vez), así que fije IN_FLIGHT=1 por sesión. El rendimiento por sesión es 86,400 ÷ segundos por elemento, al día. BroadNet indica una velocidad típica de unos 100 tokens por segundo, pero su latencia depende de la longitud del prompt y del razonamiento, así que mídala con 50 elementos. Si mide 3 segundos por elemento, una sesión procesa 28,800 al día:
| Trabajo | Sesiones | Tiempo a 3 s/elemento | Plan |
|---|---|---|---|
| 100,000 elementos | 1 | Unos 3.5 días | Una semana de Órbita (Orbit), $15 por sesión |
| 100,000 elementos | 4 | Unas 21 horas | Cuatro semanas de Órbita, una por sesión; o unas 21 horas de Meteoro (Meteor) por sesión, a $1 cada una |
| 1,000,000 elementos | 6 | Unos 6 días | Seis semanas de Órbita |
Los planes se ofrecen “best effort under fair use” (Traducción: con el mejor esfuerzo bajo uso justo), y BroadNet no publica un límite de solicitudes por minuto para las claves de plan; su cuenta muestra los límites que aplican. Configure RPM a partir de ellos, no a ojo. La guía de planificación de sesiones explica cómo repartir las sesiones entre claves.
Dónde encaja BroadNet Inference
BroadNet Inference no tiene Batch API, así que encaja en trabajos masivos cuando usted prefiere controlar el runner y pagar precios normales por token, o fijar el costo con sesiones de plan de DeepSeek V4.1 Flash. Para trabajos pequeños con presupuesto ajustado, Gemma 4 VL 26B, a $0.10 de entrada y $0.22 de salida por 1M, funciona con el crédito inicial de $5. Los prompts y las salidas no se conservan después de cada solicitud. Si su trabajo puede esperar un día y los modelos que necesita están en un proveedor con un descuento por lotes del 50 %, eso puede costar menos; compare antes de comprometerse. Los planes y límites están en inference.broadnet.ai/plans.
