Alguns jobs de LLM não são chats. Você tem 50.000 chamados de suporte para rotular, 200.000 descrições de produto para traduzir ou um milhão de avaliações para pontuar. Provedores como OpenAI e Anthropic vendem uma Batch API para isso. Muitas APIs compatíveis com a OpenAI, a BroadNet Inference entre elas, não têm. Este post mostra como rodar o job você mesmo: calcular quanto tempo ele vai levar, escrever um runner que respeite os limites e torná-lo seguro para parar e reiniciar.
O BroadRouter é o site da própria BroadNet, então os números dos exemplos usam os limites publicados pela BroadNet. O método funciona em qualquer API de chat completions; troque pelos números do seu provedor.
A BroadNet Inference tem Batch API?
Não. A referência da API, verificada em 15 de novembro de 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions e GET /v1/models (uma lista de modelos), além de endpoints de conta em /portal/. Não há endpoint de lote nem de upload de arquivos, nem desconto de lote. Um job em massa é um loop de requisições normais.
Veja o que uma Batch API gerenciada oferece, para saber o que você está reconstruindo:
| Batch API da OpenAI | Message Batches da Anthropic | O seu próprio runner | |
|---|---|---|---|
| Preço | 50% abaixo do síncrono | 50% de desconto | Preço normal |
| Prazo de entrega | Em até 24 horas | A maioria em até 1 hora; expira após 24 | Definido pelos seus rate limits |
| Tamanho por lote | 50.000 requisições ou 200 MB | 100.000 requisições ou 256 MB | Qualquer tamanho |
| Rate limits | Separados dos limites por modelo | Valem para as requisições na fila | Os limites da sua chave |
| Ordem dos resultados | Pode variar; associe pelo custom_id |
Associe pelo custom_id |
Você indexa os resultados por ID |
Duas lições valem para você também. Os dois provedores exigem que cada requisição tenha um ID, porque os resultados não voltam em ordem. Nenhum promete resposta em segundos. O seu runner deve funcionar do mesmo jeito: IDs em tudo e um planejamento medido em horas.
Se um desconto de 50% importa mais que o prazo, e os modelos de que você precisa estão lá, uma Batch API gerenciada pode ser a ferramenta mais barata. Faça as contas dos dois caminhos na calculadora de custo de API de LLM antes de construir.
Quanto tempo o job vai levar?
Calcule isso antes de escrever código. Dois limites definem a vazão, e o mais lento vence:
- Limite de requisições em andamento ÷ latência. Com 4 requisições em andamento e 2 segundos por requisição, você conclui 2 por segundo.
- Requisições por minuto. A 30 por minuto, você consegue iniciar 0,5 por segundo, por mais rápido que o modelo seja.
Uma chave de pagamento por uso da BroadNet permite 4 requisições em andamento e 30 por minuto. Com os valores da referência da API quando conferimos (30 por minuto e 4 em andamento, 2026-11-15), o rate limit é o gargalo, a menos que cada requisição leve mais de 8 segundos, e a tabela abaixo usa 30 por minuto:
| Itens | Um item por requisição | 20 itens por requisição |
|---|---|---|
| 10.000 | 5,6 horas | 17 minutos |
| 100.000 | 2,3 dias | 2,8 horas |
| 1.000.000 | 23 dias | 28 horas |
A 30 requisições por minuto, uma chave faz 1.800 requisições por hora, ou 43.200 por dia. Novas tentativas também contam: cada 429 que você provoca gasta uma vaga.
A segunda coluna é a maior alavanca. Itens curtos, como avaliações ou assuntos de chamados, podem ir de 10 a 50 por requisição numa lista numerada, com um array JSON de volta. Confira se o array tem uma entrada por item e se cada uma traz o seu número. O post sobre classificação de textos em árabe mostra o padrão. Itens longos não dá para agrupar: cada requisição ainda precisa caber na janela de contexto do modelo, e a qualidade pode cair à medida que a lista cresce. Teste o agrupamento em 200 itens antes de confiar nele.
Não espalhe um job por várias chaves para driblar um limite por chave sem perguntar. A Política de Uso Aceitável da BroadNet proíbe contornar limites de taxa, de concorrência ou de orçamento. Se você precisa de mais, pergunte à BroadNet ou use sessões de plano, mais abaixo. O planejador de jobs em lote faz essa conta para a sua quantidade de itens, latência e limites.
Como é um runner retomável?
Este runner lê items.jsonl (um objeto {"id", "text"} por linha) e acrescenta uma linha de resultado por item em results.jsonl. Ele só precisa do SDK Python da OpenAI.
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]))
Rode com python batch_run.py items.jsonl results.jsonl. Testamos exatamente este arquivo contra um servidor mock local que devolvia 429 (8%) e 500 (5%) aleatórios e recusava qualquer coisa acima de 4 em andamento ou 30 inícios por minuto. 25 itens terminaram em 55 segundos com 28 requisições (3 novas tentativas), e nunca houve mais de 30 inícios em qualquer janela de 60 segundos. Com o limite do mock elevado para 300 por minuto para poupar tempo, uma execução de 120 itens interrompida após 10 segundos retomou a partir de 39 resultados salvos e terminou com 120 IDs únicos e nenhuma duplicata.
Por que um pool de workers e não asyncio.gather?
O guia do 429 usa um semaphore em volta de asyncio.gather. Isso serve para algumas centenas de chamadas. Para um job grande, um pool fixo de workers puxando de uma fila é melhor:
- Memória.
gathercria uma tarefa por item logo de início. Um pool guarda só os itens em andamento. - A concorrência é o tamanho do pool. Quatro workers nunca terão cinco requisições abertas.
- Os resultados vão para o disco em streaming à medida que terminam, em qualquer ordem, com o ID como chave.
O Pacer cuida do segundo limite. Um semaphore sozinho impede passar de 4 em andamento, mas, se as requisições levarem um segundo, quatro workers iniciariam 240 por minuto e receberiam 429 na maioria delas. O pacer espaça os inícios em 2 segundos, entre todos os workers, incluindo as novas tentativas.
Como as novas tentativas continuam seguras?
Repita só o que pode dar certo numa segunda tentativa:
| Resposta | Ação |
|---|---|
| 429 | Espere e tente de novo; a documentação da BroadNet diz “use response details and bounded backoff” (tradução: use os detalhes da resposta e um backoff limitado) |
| 500, 502, 503, 504, timeouts, conexões interrompidas | Tente de novo com backoff exponencial limitado |
| 400, 422 | Corrija a requisição; repetir devolve o mesmo erro |
| 401, 402, 403 | Pare o job; a chave, o saldo ou a política precisa de atenção |
| 413 | Encurte o item |
O runner desliga as novas tentativas do próprio SDK (max_retries=0) para que haja exatamente uma política de novas tentativas, com um teto visível. O backoff é exponencial com full jitter, limitado a 60 segundos, para que workers que falharam juntos não tentem de novo juntos. Depois de seis tentativas o item é gravado como "ok": false e o job segue. Um item ruim nunca trava um milhão.
Uma chamada ao modelo não tem efeitos colaterais, então a entrega aqui é pelo menos uma vez: se o processo morrer no meio de uma requisição, esse item é enviado de novo ao reiniciar, e você paga por ele duas vezes. É o único desperdício. Se o job também grava em outro sistema, como chamados ou e-mails, torne essa gravação idempotente pelo ID do item e faça-a numa passada separada sobre results.jsonl. O post sobre agentes de longa duração aprofunda os efeitos colaterais idempotentes.
Como funciona o checkpoint?
O arquivo de saída é o checkpoint. Cada item concluído é uma linha gravada com flush, então depois de uma queda, um deploy ou um Ctrl-C, a próxima execução lê o arquivo, junta os IDs com "ok": true e coloca na fila só o resto. Itens que falharam antes são tentados de novo na próxima execução, e a nova linha deles é acrescentada. Ao ler os resultados, fique com a última linha de cada ID.
Três hábitos fazem isso aguentar dias de execução:
- IDs estáveis. Use uma chave do banco de dados ou um hash da entrada, nunca um número de linha que muda quando o arquivo de entrada muda.
- Verifique
finish_reason. Uma resposta cortada emmax_tokensé"ok": true, mas inútil. DeepSeek V4.1 Flash, GLM 5.3 e Qwen3.8 27B raciocinam antes de responder, e o raciocínio conta em max_tokens. O runner definereasoning_effort="low", documentado pela BroadNet, e reserva 1.500 tokens. - Registre o uso em cada linha. Somar o
usagederesults.jsonldá a conta real de tokens para comparar com a sua estimativa.
Quanto custa: pagamento por uso ou sessão de plano?
No pagamento por uso, o custo são tokens. Considere 100.000 avaliações, um system prompt de 150 tokens, uma avaliação de 150 tokens e 100 tokens de saída com raciocínio baixo. Dá 30 milhões de tokens de entrada e 10 milhões de saída. No DeepSeek V4.1 Flash, isso custa 30 × $0.175 + 10 × $0.52. Mantenha o system prompt em primeiro lugar e idêntico byte a byte, e os 15 milhões de tokens dele podem ser cobrados pela tarifa de entrada em cache de $0.0055 por 1M quando o cache acertar. As suas linhas de usage mostram com que frequência isso aconteceu.
Num plano, os tokens são de graça e o custo é o tempo. Uma sessão de plano do DeepSeek V4.1 Flash “runs one request at a time” (tradução: roda uma requisição por vez), então defina IN_FLIGHT=1 por sessão. A vazão por sessão é 86.400 ÷ segundos por item, por dia. A BroadNet informa como velocidade típica cerca de 100 tokens por segundo, mas a sua latência depende do tamanho do prompt e do raciocínio, então meça em 50 itens. Se você medir 3 segundos por item, uma sessão faz 28.800 por dia:
| Job | Sessões | Tempo a 3 s/item | Plano |
|---|---|---|---|
| 100.000 itens | 1 | Cerca de 3,5 dias | Uma semana Orbit, $15 por sessão |
| 100.000 itens | 4 | Cerca de 21 horas | Quatro semanas Orbit, uma por sessão; ou cerca de 21 horas Meteor por sessão a $1 cada |
| 1.000.000 de itens | 6 | Cerca de 6 dias | Seis semanas Orbit |
Os planos são entregues “best effort under fair use” (tradução: em regime de melhor esforço, sob uso justo), e a BroadNet não publica um limite de requisições por minuto para chaves de plano; a sua conta mostra os limites que se aplicam. Configure RPM com base neles, não no chute. O guia do planejador de sessões explica como dividir sessões entre chaves.
Onde entra a BroadNet Inference
A BroadNet Inference não tem Batch API, então ela serve para jobs em massa quando você prefere controlar o runner e pagar os preços normais por token, ou fixar o custo com sessões de plano do DeepSeek V4.1 Flash. Para jobs pequenos com pouco orçamento, o Gemma 4 VL 26B, a $0.10 de entrada e $0.22 de saída por 1M, roda com o crédito inicial de $5. Prompts e saídas não são retidos depois de cada requisição. Se o seu job pode esperar um dia e os modelos de que você precisa estão num provedor com desconto de lote de 50%, isso pode sair mais barato; compare antes de se comprometer. Planos e limites estão em inference.broadnet.ai/plans.
