Hindi chat ang ilang LLM job. May 50,000 support ticket kang lalagyan ng label, 200,000 product description na isasalin, o isang milyong review na bibigyan ng score. Nagbebenta ang mga provider gaya ng OpenAI at Anthropic ng Batch API para dito. Wala nito ang maraming OpenAI-compatible na API, kasama ang BroadNet Inference. Ipinapakita ng post na ito kung paano ikaw mismo ang magpapatakbo ng job: kuwentahin kung gaano ito katagal, sumulat ng runner na sumusunod sa mga limit, at gawin itong ligtas ihinto at i-restart.
Sariling site ng BroadNet ang BroadRouter, kaya ang mga halimbawang numero ay gumagamit ng mga limit na inilathala ng BroadNet. Gumagana ang pamamaraan sa anumang chat-completions API; ipalit ang mga numero ng provider mo.
May Batch API ba ang BroadNet Inference?
Wala. Ang API reference, na sinuri noong Nobyembre 15, 2026, ay nagdo-dokumento ng POST /v1/chat/completions, POST /v1/audio/transcriptions at GET /v1/models (listahan ng model), pati mga account endpoint sa ilalim ng /portal/. Walang batch o file-upload endpoint at walang batch discount. Loop ng normal na request ang bulk job.
Ito ang ibinibigay ng hosted na Batch API, para alam mo kung ano ang binubuo mo ulit:
| Batch API ng OpenAI | Message Batches ng Anthropic | Sarili mong runner | |
|---|---|---|---|
| Presyo | 50% na mas mura kaysa synchronous | 50% na mas mura | Normal na presyo |
| Turnaround | Sa loob ng 24 oras | Karamihan sa loob ng 1 oras; nag-e-expire pagkalipas ng 24 | Itinatakda ng rate limit mo |
| Laki kada batch | 50,000 request o 200 MB | 100,000 request o 256 MB | Kahit anong laki |
| Rate limit | Hiwalay sa per-model na limit | Naaangkop sa naka-queue na request | Mga limit ng key mo |
| Ayos ng resulta | Puwedeng iba; itugma sa custom_id |
Itugma sa custom_id |
Ikaw ang nagki-key ng resulta sa ID |
Dalawang aral ang dala nito. Pinapalagyan ka ng parehong provider ng ID sa bawat request, dahil hindi bumabalik nang maayos ang pagkakasunod-sunod ng resulta. Walang nangangakong sasagot sa loob ng ilang segundo. Ganoon din dapat gumana ang runner mo: may ID ang lahat, at oras ang sukatan ng plano.
Kung mas mahalaga ang 50% na discount kaysa sa turnaround, at nandoon ang mga model na kailangan mo, baka mas mura ang hosted na Batch API. Presyuhan ang dalawa gamit ang LLM API cost calculator bago ka mag-build.
Gaano katagal ang job?
Kuwentahin ito bago ka magsulat ng code. Dalawang limit ang naglilimita sa throughput, at ang mas mabagal ang nananaig:
- In-flight limit ÷ latency. Kung 4 na request ang in flight at 2 segundo kada request, 2 kada segundo ang matatapos mo.
- Request kada minuto. Sa 30 kada minuto, 0.5 kada segundo ang masisimulan mo, gaano man kabilis ang model.
Pinapayagan ng pay-as-you-go key ng BroadNet ang 4 request na in flight at 30 kada minuto. Sa mga value sa API reference noong sinuri namin (30 kada minuto at 4 in flight, 2026-11-15), ang rate limit ang nananaig maliban kung lumampas sa 8 segundo ang bawat request, at 30 kada minuto ang ginagamit ng table sa ibaba:
| Item | Isang item kada request | 20 item kada request |
|---|---|---|
| 10,000 | 5.6 oras | 17 minuto |
| 100,000 | 2.3 araw | 2.8 oras |
| 1,000,000 | 23 araw | 28 oras |
Sa 30 request kada minuto, 1,800 request kada oras ang kaya ng isang key, o 43,200 kada araw. Kasama rin ang retry: gumagamit ng slot ang bawat 429 na natatamaan mo.
Ang pangalawang column ang pinakamalaking lever. Ang maiikling item, gaya ng review o subject ng ticket, ay puwedeng 10 hanggang 50 kada request bilang numbered list, na may JSON array na bumabalik. Suriin na may isang entry ang array kada input at dala ng bawat isa ang numero nito. Ipinapakita ng post tungkol sa Arabic text classification ang pattern. Hindi napagsasama ang mahahabang item: kailangan pa ring kumasya ng bawat request sa context window ng model, at puwedeng bumaba ang kalidad habang humahaba ang listahan. Subukan ang pagsasama sa 200 item bago ka magtiwala rito.
Huwag hatiin ang isang job sa ilang key para lampasan ang per-key na limit nang hindi nagtatanong. Ipinagbabawal ng Acceptable Use Policy ng BroadNet ang paglusot sa rate, concurrency o budget limit. Kung kailangan mo ng higit pa, tanungin ang BroadNet, o gumamit ng plan session, sa ibaba. Ginagawa ng batch job planner ang kuwentang ito para sa bilang ng item, latency at limit mo.
Ano ang itsura ng resumable na runner?
Binabasa ng runner na ito ang items.jsonl (isang {"id", "text"} na object kada linya) at nag-a-append ng isang result line kada item sa results.jsonl. OpenAI Python SDK lang ang kailangan nito.
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]))
Patakbuhin ito gamit ang python batch_run.py items.jsonl results.jsonl. Sinubukan namin ang eksaktong file na ito sa isang lokal na mock server na nagbabalik ng random na 429 (8%) at 500 (5%) at tumatanggi sa anumang lampas sa 4 in flight o 30 simula kada minuto. Natapos ang 25 item sa 55 segundo sa 28 request (3 retry), at hindi kailanman lumampas sa 30 simula sa anumang 60-segundong window. Nang itaas sa 300 kada minuto ang limit ng mock para makatipid ng oras, ang 120-item na run na pinatay pagkalipas ng 10 segundo ay nag-resume mula sa 39 na naka-save na resulta at natapos na may 120 natatanging ID at walang duplicate.
Bakit worker pool at hindi asyncio.gather?
Gumagamit ang gabay sa 429 ng semaphore sa paligid ng asyncio.gather. Ayos iyon para sa ilang daang call. Para sa malaking job, mas mabuti ang fixed na pool ng worker na kumukuha mula sa queue:
- Memory. Gumagawa ang
gatherng isang task kada item sa simula pa lang. Ang mga item na in flight lang ang hawak ng pool. - Ang concurrency ay ang laki ng pool. Hindi kailanman magkakaroon ng limang bukas na request ang apat na worker.
- Dumadaloy sa disk ang mga resulta habang natatapos, kahit anong ayos, naka-key sa ID.
Ang Pacer ang humahawak sa pangalawang limit. Pinipigilan ka ng semaphore nang mag-isa na lumampas sa 4 in flight, pero kung isang segundo ang bawat request, 240 kada minuto ang sisimulan ng apat na worker at matatamaan ng 429 ang karamihan. Pinaghihiwalay ng pacer ang mga simula nang 2 segundo, sa lahat ng worker, kasama ang retry.
Paano nananatiling ligtas ang retry?
I-retry lang ang puwedeng magtagumpay sa pangalawang subok:
| Response | Gagawin |
|---|---|
| 429 | Mag-back off at i-retry; sinasabi ng docs ng BroadNet na “use response details and bounded backoff” (salin: gamitin ang mga detalye ng response at limitadong backoff) |
| 500, 502, 503, 504, timeout, naputol na koneksyon | I-retry nang may limitadong exponential backoff |
| 400, 422 | Ayusin ang request; parehong error ang ibabalik ng retry |
| 401, 402, 403 | Ihinto ang job; may kailangang ayusin sa key, balance o policy |
| 413 | Paikliin ang item |
Pinapatay ng runner ang sariling retry ng SDK (max_retries=0) para iisa lang ang retry policy, na may nakikitang cap. Exponential ang backoff na may full jitter, naka-cap sa 60 segundo, para hindi sabay-sabay mag-retry ang mga worker na sabay-sabay pumalya. Pagkatapos ng anim na subok, isinusulat ang item bilang "ok": false at nagpapatuloy ang job. Hindi kailanman mapapahinto ng isang masamang item ang isang milyon.
Walang side effect ang model call, kaya at-least-once ang delivery dito: kung mamatay ang process sa gitna ng request, ipapadala ulit ang item na iyon pag-restart, at dalawang beses mo itong babayaran. Iyon lang ang nasasayang. Kung nagsusulat din ang job sa ibang system, gaya ng ticket o email, gawing idempotent ang pagsusulat na iyon ayon sa item ID at gawin ito sa hiwalay na pass sa results.jsonl. Malalim na tinatalakay ng post tungkol sa long-running agent ang idempotent na side effect.
Paano gumagana ang checkpointing?
Ang output file ang checkpoint. Isang na-flush na linya ang bawat natapos na item, kaya pagkatapos ng crash, deploy o Ctrl-C, binabasa ng susunod na run ang file, kinokolekta ang mga ID na may "ok": true at ang iba lang ang inilalagay sa queue. Ire-retry sa susunod na run ang mga item na pumalya dati, at ia-append ang bago nilang linya. Kapag binabasa mo ang mga resulta, kunin ang huling linya kada ID.
Tatlong gawi ang nagpapatibay nito sa loob ng ilang araw:
- Stable na ID. Gumamit ng database key o hash ng input, hindi kailanman ng line number na nauusog kapag nagbago ang input file.
- Suriin ang
finish_reason. Ang reply na naputol samax_tokensay"ok": truepero walang silbi. Nagre-reason muna ang DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B bago sumagot, at kasama ang reasoning sa max_tokens. Itinatakda ng runner angreasoning_effort="low", na naka-dokumento sa BroadNet, at nag-iiwan ng 1,500 token. - I-log ang usage kada linya. Kapag pinagsama ang
usagemula saresults.jsonl, makukuha mo ang totoong token bill na maihahambing sa tantiya mo.
Magkano ang gastos: pay-as-you-go o plan session?
Sa pay-as-you-go, token ang gastos. Halimbawa, 100,000 review, 150-token na system prompt, 150-token na review at 100 output token na may mababang reasoning. 30 milyong input at 10 milyong output token iyan. Sa DeepSeek V4.1 Flash, ang gastos ay 30 × $0.175 + 10 × $0.52. Panatilihing nauuna at byte-identical ang system prompt, at puwedeng masingil ang 15 milyong token nito sa cached input na rate na $0.0055 kada 1M kung saan tumatama ang cache. Ipinapakita ng mga usage line mo kung gaano kadalas ito nangyari.
Sa plan, libre ang token at oras ang gastos. Ang DeepSeek V4.1 Flash plan session ay “runs one request at a time” (salin: isang request sa isang pagkakataon ang tinatakbo), kaya itakda ang IN_FLIGHT=1 kada session. Ang throughput kada session ay 86,400 ÷ segundo kada item, kada araw. Sinasabi ng BroadNet na mga 100 token bawat segundo ang karaniwang bilis, pero nakadepende ang latency mo sa haba ng prompt at sa reasoning, kaya sukatin ito sa 50 item. Kung 3 segundo kada item ang nasukat mo, 28,800 kada araw ang kaya ng isang session:
| Job | Session | Oras sa 3 s/item | Plan |
|---|---|---|---|
| 100,000 item | 1 | Mga 3.5 araw | Isang Orbit week, $15 kada session |
| 100,000 item | 4 | Mga 21 oras | Apat na Orbit week, isa kada session; o mga 21 Meteor hour kada session sa $1 bawat isa |
| 1,000,000 item | 6 | Mga 6 na araw | Anim na Orbit week |
Ibinibigay ang mga plan nang “best effort under fair use” (salin: best effort sa ilalim ng fair use), at hindi naglalathala ang BroadNet ng per-minute na request limit para sa plan key; ipinapakita ng account mo ang mga limit na naaangkop. Itakda ang RPM mula sa mga iyon, hindi sa hula. Ipinapaliwanag ng gabay sa session planner kung paano hatiin ang mga session sa mga key.
Saan pumapasok ang BroadNet Inference
Walang Batch API ang BroadNet Inference, kaya bagay ito sa bulk job kapag mas gusto mong ikaw mismo ang kumontrol sa runner at magbayad ng normal na per-token na presyo, o i-fix ang gastos gamit ang DeepSeek V4.1 Flash plan session. Para sa maliliit na job na may budget, tumatakbo sa $5 na panimulang credit ang Gemma 4 VL 26B sa $0.10 input at $0.22 output kada 1M. Hindi itinatago ang mga prompt at output pagkatapos ng bawat request. Kung puwedeng maghintay ng isang araw ang job mo at nasa provider na may 50% na batch discount ang mga model na kailangan mo, baka mas mura iyon; maghambing bago mag-commit. Nasa inference.broadnet.ai/plans ang mga plan at limit.
