---
title: "LLM batch processing nang walang Batch API: runner at oras"
description: "Magpatakbo ng 10,000 hanggang 1,000,000 prompt sa chat-completions API nang walang Batch API: concurrency cap, rate pacing, retry, checkpoint at kuwenta ng oras."
url: https://broadrouter.com/fil/blog/llm-batch-processing-without-batch-api/
lang: fil
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Isinalin mula sa Ingles sa tulong ng AI. [Basahin ang orihinal sa Ingles](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (na-update noong 2026-11-16).

# LLM batch processing nang walang Batch API: resumable na runner

Ng BroadNet Inference team · 8 minutong basa · Nailathala 2026-11-15 · Na-update 2026-11-16

Kung walang Batch API, ikaw mismo ang magpatakbo ng job: basahin ang mga item mula sa JSONL file, limitahan ang request na in flight sa limit ng key, i-pace ang pagsisimula ng request sa ilalim ng per-minute na limit, i-retry ang 429 at 5xx nang may limitadong backoff, at i-append ang bawat resulta kasama ang ID. Pag-restart, laktawan ang mga tapos na. Kadalasang ang rate limit, hindi ang model, ang nagtatakda kung kailan ito matatapos.

## Mga pangunahing punto

-   Chat completions at transcriptions lang ang naka-dokumento sa BroadNet Inference. Walang Batch API at walang batch discount, kaya loop ng ordinaryong request ang bulk job.
-   Ang oras ng pagtatapos ay items ÷ ang mas mabagal sa dalawang rate: in-flight limit ÷ latency, o request kada minuto. Pinapayagan ng pay-as-you-go key ang 4 in flight at 30 kada minuto, kaya 43,200 kada araw ang pinakamarami kung isang item kada request.
-   Magsulat ng isang result line kada item, naka-key sa ID, at i-flush ito. Ang linyang iyon ang checkpoint: ang mawawala lang sa crash ay ang mga request na in flight noon.
-   Isang request sa isang pagkakataon ang tinatakbo ng plan session. Ang throughput nito ay 86,400 ÷ ang nasukat mong segundo kada item, kada araw, kada session.
-   Kung puwedeng maghintay ng isang araw ang trabaho at mahalaga ang 50% na batch discount, baka mas mura ang Batch API ng OpenAI at Anthropic. Presyuhan ang dalawa.

**Sa page na ito**

1.  May Batch API ba ang BroadNet Inference?
2.  Gaano katagal ang job?
3.  Ano ang itsura ng resumable na runner?
4.  Bakit worker pool at hindi asyncio.gather?
5.  Paano nananatiling ligtas ang retry?
6.  Paano gumagana ang checkpointing?
7.  Magkano ang gastos: pay-as-you-go o plan session?
8.  Saan pumapasok ang BroadNet Inference

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](https://broadrouter.com/fil/glossary/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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-batch-processing-without-batch-api&utm_content=body), 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](https://broadrouter.com/tools/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](https://broadrouter.com/fil/glossary/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](https://broadrouter.com/fil/glossary/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](https://broadrouter.com/fil/blog/arabic-text-classification-llm/) ang pattern. Hindi napagsasama ang mahahabang item: kailangan pa ring kumasya ng bawat request sa [context window](https://broadrouter.com/fil/glossary/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](https://www.broadnet.ai/aup) 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](https://broadrouter.com/tools/llm-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.

```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]))
```

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](https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/) 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 `gather` ng 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](https://broadrouter.com/fil/glossary/exponential-backoff/) 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](https://broadrouter.com/fil/glossary/idempotency-key/) 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](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/) 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:

1.  **Stable na ID.** Gumamit ng database key o hash ng input, hindi kailanman ng line number na nauusog kapag nagbago ang input file.
2.  **Suriin ang `finish_reason`.** Ang reply na naputol sa `max_tokens` ay `"ok": true` pero 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](https://broadrouter.com/fil/guides/reasoning-tokens-empty-response/). Itinatakda ng runner ang `reasoning_effort="low"`, na naka-dokumento sa BroadNet, at nag-iiwan ng 1,500 token.
3.  **I-log ang usage kada linya.** Kapag pinagsama ang `usage` mula sa `results.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](https://broadrouter.com/fil/models/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](https://broadrouter.com/fil/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/fil/guides/unlimited-llm-api-sessions/) 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](https://broadrouter.com/fil/models/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](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-batch-processing-without-batch-api&utm_content=body) ang mga plan at limit.

Mga libreng tool para rito (Ingles)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Libreng tools (Ingles)](https://broadrouter.com/tools/)

## Mga termino sa artikulong ito

[Token](https://broadrouter.com/fil/glossary/token/)

Ang token ay ang yunit ng text na binabasa at isinusulat ng isang language model: isang salita, bahagi ng salita, bantas o byte sequence na ginawa ng tokenizer ng model. Sa token binibilang, nililimitahan at kadalasang sinisingil ng mga LLM API ang paggamit.

[API key](https://broadrouter.com/fil/glossary/api-key/)

Ang API key ay isang lihim na string na kumikilala at nagpapahintulot sa client na tumatawag sa isang API. Kadalasang hinihingi ito ng mga LLM API sa Authorization: Bearer header, at ang sinumang may hawak ng key ay makakagawa ng mga request na sisingilin sa account na may-ari nito.

[Batch API](https://broadrouter.com/fil/glossary/batch-api/)

Ang batch API ay asynchronous na LLM endpoint na tumatanggap ng maraming request nang sabay, kadalasan bilang file, pinoproseso ang mga ito sa loob ng nakatakdang window sa halip na agad-agad, at ibinabalik nang sabay-sabay ang mga resulta. May discount ang presyo ng batch request ng mga provider gaya ng OpenAI at Anthropic kumpara sa standard API nila.

[Pay-as-you-go](https://broadrouter.com/fil/glossary/pay-as-you-go/)

Ang pay-as-you-go ay paraan ng pagpepresyo kung saan ang nagamit mo lang ang binabayaran mo, sinusukat kada yunit gaya ng token, request o minuto ng audio, nang walang subscription o minimum na commitment. Ganito naniningil ang karamihan ng LLM API, mula sa prepaid na balance o sa pana-panahong invoice.

[Rate limit](https://broadrouter.com/fil/glossary/rate-limit/)

Ang rate limit ay hangganang itinatakda ng API sa dami ng paggamit ng isang client sa isang yugto ng oras, gaya ng request kada minuto o token kada minuto. Tinatanggihan ang mga request na lampas sa limit, kadalasan na may HTTP 429 Too Many Requests, hanggang bumaba ulit ang paggamit.

[Concurrency](https://broadrouter.com/fil/glossary/concurrency/)

Ang concurrency ay ang bilang ng request na sabay-sabay na in flight mula sa isang client. Madalas itong nililimitahan ng mga LLM API kada key o plan, hiwalay sa requests per minute, dahil humahawak ng GPU capacity ang bawat bukas na request hanggang matapos ang response nito.

[Context window](https://broadrouter.com/fil/glossary/context-window/)

Ang context window ay ang pinakamaraming token na kayang hawakan ng isang language model sa iisang request. Sakop nito ang prompt, history ng usapan, tool definitions, mga larawan at ang nabuong output, kasama ang anumang reasoning tokens. Ang hindi kasya ay kailangang bawasan, ibuod o hatiin sa ilang request.

[Latency](https://broadrouter.com/fil/glossary/latency/)

Ang latency, para sa isang language model API, ay ang tagal ng isang request mula sa pagpapadala hanggang matanggap ang huling output token. Kabuuan ito ng time to first token at ng generation time, at kadalasang iniuulat bilang percentile gaya ng p50 at p95 sa halip na average.

## Mga tanong

### May Batch API ba ang BroadNet Inference?

Wala. Ang API reference nito, na sinuri noong Nobyembre 15, 2026, ay nagdo-dokumento ng POST /v1/chat/completions, POST /v1/audio/transcriptions at GET /v1/models, na walang batch o file-upload endpoint at walang batch discount. Patakbuhin ang bulk job bilang ordinaryong request sa loob ng limit ng key mo.

### Paano ko ipoproseso ang 100,000 prompt gamit ang LLM API?

Ilagay ang mga item sa JSONL file na may ID ang bawat isa. Magpatakbo ng fixed na bilang ng worker na katumbas ng in-flight limit ng key, i-pace ang pagsisimula ng request sa ilalim ng per-minute na limit, i-retry ang 429 at 5xx nang may limitadong backoff, at i-append ang bawat resulta sa output file na naka-key sa ID para maipagpatuloy ang job.

### Gaano katagal ang batch na may isang milyong request?

Hatiin ang mga item sa totoong rate mo. Sa 30 request kada minuto at isang item kada request, 43,200 kada araw ang kaya ng isang key, kaya mga 23 araw ang isang milyon. Kapag pinagsama ang 20 maikling item kada request, nagiging mga 28 oras ito, kung kaya ng model nang maayos ang mas mahabang prompt.

### asyncio.gather ba o worker pool ang dapat kong gamitin sa batch na LLM call?

Para sa sampu-sampung libong item, gumamit ng fixed na pool ng worker na kumukuha mula sa queue. Gumagana ang gather na may semaphore sa maliliit na job, pero ginagawa nito ang bawat task sa simula pa lang at pinapahirap ang pag-resume at pag-track ng progress.

### Puwede ba akong gumamit ng ilang API key para bumilis?

Magtanong muna. Ipinagbabawal ng Acceptable Use Policy ng BroadNet ang paglusot sa rate o concurrency limit, kaya tanungin ang BroadNet bago mo hatiin ang isang job sa ilang key para lampasan ang per-key na limit. Ang pagsasama ng mas maraming item kada request at ang mga plan session ang naka-dokumentong paraan para dagdagan ang throughput.

### Maganda ba ang flat na plan para sa batch job?

Puwede, para sa DeepSeek V4.1 Flash. Isang request sa isang pagkakataon ang tinatakbo ng session nang walang token meter, kaya fixed ang gastos at oras ang tanong. Sukatin ang segundo kada item, saka bumili ng sapat na session para matapos sa loob ng period.

## Magbasa pa

-   [Paano ayusin ang 429 error sa LLM API: backoff, jitter at limiter](https://broadrouter.com/fil/blog/handle-llm-api-429-rate-limits/)
-   [Matagal na tumatakbong agent: timeout, retry at checkpoint na matibay](https://broadrouter.com/fil/blog/long-running-agents-timeouts-retries/)
-   [Arabic text classification gamit ang LLM: sentiment, intent, triage](https://broadrouter.com/fil/blog/arabic-text-classification-llm/)
-   [Paano magpatakbo ng sabay-sabay na coding agent sa flat-rate LLM API](https://broadrouter.com/fil/blog/run-parallel-coding-agents-flat-rate/)
-   [Lingguhang LLM plan para sa maiikling proyekto: Orbit vs oras vs buwan](https://broadrouter.com/fil/blog/weekly-llm-plan-short-projects/)
-   [Paano tantiyahin ang gastos sa LLM API bago mag-launch ng feature](https://broadrouter.com/fil/blog/estimate-llm-api-cost-before-launch/)
-   [GPU hardware at paraan ng serving ng BroadNet, ayon sa BroadNet](https://broadrouter.com/fil/blog/broadnet-gpu-fleet-and-serving/)
-   [I-cache ang LLM API response, makatipid: exact-match cache sa Python](https://broadrouter.com/fil/blog/cache-llm-responses-cut-cost/)
-   [Gabay: Mga error code ng BroadNet Inference at kailan dapat mag-retry](https://broadrouter.com/fil/guides/errors-and-retries/)
-   [Gabay: Paano gamitin ang OpenAI Python SDK sa BroadNet Inference](https://broadrouter.com/fil/guides/openai-python-sdk/)
-   [Gabay: Paano gumagana ang unlimited LLM API plans para sa mga agent](https://broadrouter.com/fil/guides/unlimited-llm-api-sessions/)

Subukan ito sa totoong workload mo. May US$5 na panimulang credit ang mga bagong account para sa Gemma at transcription. Kailangan ng top-up para sa DeepSeek, GLM, at Qwen3.8.

[Magsimula](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-batch-processing-without-batch-api&utm_content=page-cta) ·

**Mga source**

-   [API reference ng BroadNet Inference: mga endpoint, limit ng pay-as-you-go (30 kada minuto, 4 in flight), limit ng hourly key, gabay sa retry ng 429 at 5xx, reasoning\_effort (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Pahina ng mga plan ng BroadNet Inference: isang request sa isang pagkakataon kada session, karaniwang bilis, presyo ng plan (sinuri noong 2026-11-15) (Ingles)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fil-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Acceptable Use Policy ng BroadNet, section 3 at 4: bawal lusutan ang rate o concurrency limit; best effort sa ilalim ng fair use ang mga plan (sinuri noong 2026-11-15) (Ingles)](https://www.broadnet.ai/aup)
-   [Gabay sa Batch API ng OpenAI: 50% discount, 24h na window, 50,000 request o 200 MB kada batch, puwedeng iba ang ayos ng output, custom\_id (sinuri noong 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Docs ng Message Batches API ng Anthropic: 50% discount, 100,000 request o 256 MB, karamihan ng batch sa loob ng 1 oras, nag-e-expire pagkalipas ng 24 oras (sinuri noong 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
