---
title: "Batch processing LLM tanpa Batch API: runner dan hitungan"
description: "Jalankan 10.000 hingga 1.000.000 prompt lewat API chat completions tanpa Batch API: batas concurrency, pengaturan laju, retry, checkpoint, dan hitungan waktu."
url: https://broadrouter.com/id/blog/llm-batch-processing-without-batch-api/
lang: id
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Diterjemahkan dari bahasa Inggris dengan bantuan AI. [Baca versi asli bahasa Inggris](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (diperbarui 2026-11-16).

# Batch processing LLM tanpa Batch API: runner yang bisa dilanjutkan

Oleh tim BroadNet Inference · 8 menit baca · Dipublikasikan 2026-11-15 · Diperbarui 2026-11-16

Tanpa Batch API, jalankan job-nya sendiri: baca item dari file JSONL, batasi permintaan yang berjalan bersamaan sesuai limit kunci, atur laju awal permintaan di bawah limit per menit, lakukan retry untuk 429 dan 5xx dengan backoff terbatas, dan tambahkan setiap hasil beserta ID-nya. Saat restart, lewati ID yang sudah selesai. Yang biasanya menentukan waktu selesai adalah rate limit, bukan modelnya.

## Poin penting

-   BroadNet Inference hanya mendokumentasikan chat completions dan transkripsi. Tidak ada Batch API dan tidak ada diskon batch, jadi job massal adalah loop permintaan biasa.
-   Waktu selesai = jumlah item ÷ yang lebih lambat dari dua laju: limit permintaan bersamaan ÷ latensi, atau permintaan per menit. Kunci bayar sesuai pemakaian mengizinkan 4 permintaan bersamaan dan 30 per menit, jadi satu item per permintaan mentok di 43.200 per hari.
-   Tulis satu baris hasil per item, dengan ID sebagai kunci, lalu flush. Baris itulah checkpoint-nya: crash paling banyak hanya merugikan permintaan yang sedang berjalan.
-   Sesi paket menjalankan satu permintaan pada satu waktu. Throughput-nya adalah 86.400 ÷ detik per item hasil ukur Anda, per hari, per sesi.
-   Jika pekerjaannya bisa menunggu sehari dan diskon batch 50% penting, Batch API OpenAI dan Anthropic mungkin lebih murah. Hitung harga keduanya.

**Di halaman ini**

1.  Apakah BroadNet Inference punya Batch API?
2.  Berapa lama job-nya akan berjalan?
3.  Seperti apa runner yang bisa dilanjutkan?
4.  Kenapa worker pool dan bukan asyncio.gather?
5.  Bagaimana agar retry tetap aman?
6.  Bagaimana checkpoint bekerja?
7.  Berapa biayanya: bayar sesuai pemakaian atau sesi paket?
8.  Posisi BroadNet Inference

Sebagian pekerjaan LLM bukan chat. Anda punya 50.000 tiket support untuk diberi label, 200.000 deskripsi produk untuk diterjemahkan, atau sejuta ulasan untuk dinilai. Penyedia seperti OpenAI dan Anthropic menjual [Batch API](https://broadrouter.com/id/glossary/batch-api/) untuk keperluan ini. Banyak API yang kompatibel dengan OpenAI, termasuk BroadNet Inference, tidak menyediakannya. Tulisan ini menunjukkan cara menjalankan job-nya sendiri: hitung berapa lama waktunya, tulis runner yang mematuhi limit, dan buat agar aman dihentikan lalu dijalankan ulang.

BroadRouter adalah situs milik BroadNet sendiri, jadi angka contoh memakai limit yang dipublikasikan BroadNet. Metodenya berlaku di API chat completions mana pun; ganti dengan angka penyedia Anda.

## Apakah BroadNet Inference punya Batch API?

Tidak. [Referensi API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-batch-processing-without-batch-api&utm_content=body), dicek pada 15 November 2026, mendokumentasikan `POST /v1/chat/completions`, `POST /v1/audio/transcriptions`, dan `GET /v1/models` (daftar model), plus endpoint akun di bawah `/portal/`. Tidak ada endpoint batch atau upload file dan tidak ada diskon batch. Job massal adalah loop permintaan biasa.

Inilah yang diberikan Batch API terkelola, supaya Anda tahu apa yang sedang Anda bangun ulang:

|  | OpenAI Batch API | Anthropic Message Batches | Runner Anda sendiri |
| --- | --- | --- | --- |
| Harga | Diskon 50% dari sinkron | Diskon 50% | Harga normal |
| Waktu selesai | Dalam 24 jam | Sebagian besar dalam 1 jam; kedaluwarsa setelah 24 jam | Ditentukan rate limit Anda |
| Ukuran per batch | 50.000 permintaan atau 200 MB | 100.000 permintaan atau 256 MB | Berapa pun |
| Rate limit | Terpisah dari limit per model | Berlaku untuk permintaan dalam antrean | Limit kunci Anda |
| Urutan hasil | Bisa berbeda; cocokkan dengan `custom_id` | Cocokkan dengan `custom_id` | Anda memberi kunci hasil berdasarkan ID |

Dua pelajaran tetap berlaku. Kedua penyedia mengharuskan Anda menandai setiap permintaan dengan ID, karena hasil tidak kembali secara berurutan. Tidak ada yang menjanjikan jawaban dalam hitungan detik. Runner Anda sebaiknya bekerja dengan cara yang sama: ID di semua hal, dan rencana yang diukur dalam jam.

Jika diskon 50% lebih penting daripada waktu selesai, dan model yang Anda butuhkan tersedia di sana, Batch API terkelola mungkin pilihan yang lebih murah. Hitung keduanya dengan [kalkulator biaya API LLM](https://broadrouter.com/tools/llm-api-cost-calculator/) sebelum mulai membangun.

## Berapa lama job-nya akan berjalan?

Hitung ini sebelum menulis kode. Dua limit membatasi throughput, dan yang lebih lambat yang menang:

-   **Limit permintaan bersamaan ÷ latensi.** Dengan 4 permintaan bersamaan dan 2 detik per permintaan, Anda bisa menyelesaikan 2 per detik.
-   **Permintaan per menit.** Pada 30 per menit, Anda hanya bisa memulai 0,5 per detik, secepat apa pun modelnya.

Kunci [bayar sesuai pemakaian](https://broadrouter.com/id/glossary/pay-as-you-go/) BroadNet mengizinkan 4 permintaan bersamaan dan 30 per menit. Dengan nilai di referensi API saat kami mengeceknya (30 per menit dan 4 bersamaan, 2026-11-15), [rate limit](https://broadrouter.com/id/glossary/rate-limit/) yang menjadi pembatas kecuali setiap permintaan butuh lebih dari 8 detik, dan tabel di bawah memakai 30 per menit:

| Item | Satu item per permintaan | 20 item per permintaan |
| --- | --- | --- |
| 10.000 | 5,6 jam | 17 menit |
| 100.000 | 2,3 hari | 2,8 jam |
| 1.000.000 | 23 hari | 28 jam |

Pada 30 permintaan per menit, satu kunci memproses 1.800 permintaan per jam, atau 43.200 per hari. Retry juga dihitung: setiap 429 yang Anda picu menghabiskan satu slot.

Kolom kedua adalah tuas terbesar. Item pendek, seperti ulasan atau subjek tiket, bisa dikirim 10 sampai 50 per permintaan sebagai daftar bernomor, dengan array JSON sebagai balasan. Pastikan array punya satu entri per input dan masing-masing membawa nomornya. [Tulisan klasifikasi teks Arab](https://broadrouter.com/id/blog/arabic-text-classification-llm/) menunjukkan polanya. Item panjang tidak bisa dikemas: setiap permintaan tetap harus muat di [context window](https://broadrouter.com/id/glossary/context-window/) model, dan kualitas bisa turun saat daftar makin panjang. Uji pengemasan pada 200 item sebelum mengandalkannya.

Jangan menyebar satu job ke beberapa kunci untuk mengalahkan limit per kunci tanpa bertanya. [Kebijakan Penggunaan yang Dapat Diterima](https://www.broadnet.ai/aup) BroadNet melarang mengakali rate limit, limit concurrency, atau limit anggaran. Jika butuh lebih, tanyakan ke BroadNet, atau pakai sesi paket di bawah. [Perencana batch job](https://broadrouter.com/tools/llm-batch-job-planner/) melakukan hitungan ini untuk jumlah item, latensi, dan limit Anda.

## Seperti apa runner yang bisa dilanjutkan?

Runner ini membaca `items.jsonl` (satu objek `{"id", "text"}` per baris) dan menambahkan satu baris hasil per item ke `results.jsonl`. Yang dibutuhkan hanya OpenAI Python SDK.

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

Jalankan dengan `python batch_run.py items.jsonl results.jsonl`. Kami menguji file yang persis sama ini terhadap mock server lokal yang mengembalikan 429 (8%) dan 500 (5%) secara acak serta menolak lebih dari 4 permintaan bersamaan atau 30 permintaan baru per menit. 25 item selesai dalam 55 detik dengan 28 permintaan (3 retry), dan tidak pernah lebih dari 30 permintaan baru dalam jendela 60 detik mana pun. Dengan limit mock dinaikkan ke 300 per menit untuk menghemat waktu, run 120 item yang dihentikan setelah 10 detik berlanjut dari 39 hasil tersimpan dan selesai dengan 120 ID unik tanpa duplikat.

## Kenapa worker pool dan bukan asyncio.gather?

[Panduan 429](https://broadrouter.com/id/blog/handle-llm-api-429-rate-limits/) memakai semaphore di sekitar `asyncio.gather`. Itu cukup untuk beberapa ratus panggilan. Untuk job besar, worker pool tetap yang mengambil dari antrean lebih baik:

-   **Memori.** `gather` membuat satu task per item di awal. Pool hanya menyimpan item yang sedang berjalan.
-   **Concurrency sama dengan ukuran pool.** Empat worker tidak akan pernah punya lima permintaan terbuka.
-   **Hasil mengalir ke disk** saat selesai, dalam urutan apa pun, dengan ID sebagai kunci.

`Pacer` menangani limit kedua. Semaphore saja mencegah Anda melebihi 4 permintaan bersamaan, tetapi jika permintaan butuh satu detik, empat worker akan memulai 240 per menit dan kena 429 di sebagian besarnya. Pacer memberi jarak 2 detik antar-permintaan baru, di semua worker, termasuk retry.

## Bagaimana agar retry tetap aman?

Lakukan retry hanya untuk yang bisa berhasil pada percobaan kedua:

| Respons | Tindakan |
| --- | --- |
| 429 | Backoff lalu retry; dokumentasi BroadNet menyebut “use response details and bounded backoff” (Terjemahan BroadRouter: gunakan detail respons dan backoff terbatas) |
| 500, 502, 503, 504, timeout, koneksi terputus | Retry dengan exponential backoff terbatas |
| 400, 422 | Perbaiki permintaannya; retry hanya mengirim error yang sama |
| 401, 402, 403 | Hentikan job; kunci, saldo, atau kebijakan perlu ditangani |
| 413 | Perpendek item-nya |

Runner mematikan retry bawaan SDK (`max_retries=0`) sehingga hanya ada satu kebijakan retry, dengan batas yang terlihat. Backoff bersifat [eksponensial](https://broadrouter.com/id/glossary/exponential-backoff/) dengan full jitter, dibatasi 60 detik, sehingga worker yang gagal bersamaan tidak melakukan retry bersamaan. Setelah enam percobaan, item ditulis sebagai `"ok": false` dan job berlanjut. Satu item bermasalah tidak akan pernah menghentikan sejuta item.

Panggilan model tidak punya efek samping, jadi pengirimannya di sini bersifat at-least-once: jika proses mati di tengah permintaan, item itu dikirim lagi saat restart, dan Anda membayarnya dua kali. Hanya itu pemborosannya. Jika job juga menulis ke sistem lain, seperti tiket atau email, buat penulisan itu [idempoten](https://broadrouter.com/id/glossary/idempotency-key/) berdasarkan ID item dan lakukan di tahap terpisah atas `results.jsonl`. [Tulisan agent yang berjalan lama](https://broadrouter.com/id/blog/long-running-agents-timeouts-retries/) membahas efek samping idempoten secara mendalam.

## Bagaimana checkpoint bekerja?

File output adalah checkpoint-nya. Setiap item yang selesai adalah satu baris yang sudah di-flush, jadi setelah crash, deploy, atau Ctrl-C, run berikutnya membaca file itu, mengumpulkan ID dengan `"ok": true`, dan hanya mengantrekan sisanya. Item yang sebelumnya gagal di-retry di run berikutnya, dan baris barunya ditambahkan. Saat membaca hasil, ambil baris terakhir per ID.

Tiga kebiasaan yang membuat ini bertahan berhari-hari:

1.  **ID yang stabil.** Gunakan kunci database atau hash dari input, jangan nomor baris yang bergeser saat file input berubah.
2.  **Cek `finish_reason`.** Balasan yang terpotong di `max_tokens` bernilai `"ok": true` tetapi tidak berguna. DeepSeek V4.1 Flash, GLM 5.3, dan Qwen3.8 27B melakukan penalaran sebelum menjawab, dan [penalaran dihitung dalam max\_tokens](https://broadrouter.com/id/guides/reasoning-tokens-empty-response/). Runner ini memakai `reasoning_effort="low"`, yang didokumentasikan BroadNet, dan menyisakan 1.500 token.
3.  **Catat usage per baris.** Menjumlahkan `usage` dari `results.jsonl` memberi tagihan token sebenarnya untuk dibandingkan dengan estimasi Anda.

## Berapa biayanya: bayar sesuai pemakaian atau sesi paket?

Pada bayar sesuai pemakaian, biaya adalah token. Ambil 100.000 ulasan, system prompt 150 token, ulasan 150 token, dan 100 token output dengan penalaran rendah. Totalnya 30 juta token input dan 10 juta token output. Di [DeepSeek V4.1 Flash](https://broadrouter.com/id/models/deepseek-v4.1-flash/) biayanya 30 × $0.175 + 10 × $0.52. Taruh system prompt di depan dan biarkan identik byte demi byte, maka 15 juta token-nya bisa ditagih dengan tarif [input cache](https://broadrouter.com/id/blog/cached-input-tokens-explained/) $0.0055 per 1M saat cache kena. Baris `usage` Anda menunjukkan seberapa sering itu terjadi.

Pada paket, token gratis dan waktu adalah biayanya. Sesi paket DeepSeek V4.1 Flash “runs one request at a time” (Terjemahan BroadRouter: menjalankan satu permintaan pada satu waktu), jadi set `IN_FLIGHT=1` per sesi. Throughput per sesi adalah 86.400 ÷ detik per item, per hari. BroadNet menyebut kecepatan tipikal sekitar 100 token per detik, tetapi latensi Anda bergantung pada panjang prompt dan penalaran, jadi ukur pada 50 item. Jika hasil ukur Anda 3 detik per item, satu sesi memproses 28.800 per hari:

| Job | Sesi | Waktu pada 3 dtk/item | Paket |
| --- | --- | --- | --- |
| 100.000 item | 1 | Sekitar 3,5 hari | Satu minggu Orbit, $15 per sesi |
| 100.000 item | 4 | Sekitar 21 jam | Empat minggu Orbit, satu per sesi; atau sekitar 21 jam Meteor per sesi seharga $1 per jam |
| 1.000.000 item | 6 | Sekitar 6 hari | Enam minggu Orbit |

Paket diberikan secara “best effort under fair use” (Terjemahan BroadRouter: upaya terbaik di bawah penggunaan wajar), dan BroadNet tidak memublikasikan limit permintaan per menit untuk kunci paket; akun Anda menunjukkan limit yang berlaku. Set `RPM` dari sana, bukan dari tebakan. [Panduan perencana sesi](https://broadrouter.com/id/guides/unlimited-llm-api-sessions/) menjelaskan cara membagi sesi ke beberapa kunci.

## Posisi BroadNet Inference

BroadNet Inference tidak punya Batch API, jadi cocok untuk job massal ketika Anda lebih suka mengendalikan runner sendiri dan membayar harga per token normal, atau mengunci biaya dengan sesi paket DeepSeek V4.1 Flash. Untuk job kecil dengan anggaran terbatas, [Gemma 4 VL 26B](https://broadrouter.com/id/models/gemma-4-vl-26b/) dengan harga $0.10 input dan $0.22 output per 1M bisa dijalankan dengan kredit awal $5. Prompt dan output tidak disimpan setelah setiap permintaan. Jika job Anda bisa menunggu sehari dan model yang Anda butuhkan ada di penyedia dengan diskon batch 50%, biayanya mungkin lebih rendah; bandingkan sebelum berkomitmen. Paket dan limit ada di [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-batch-processing-without-batch-api&utm_content=body).

Alat gratis untuk topik ini (bahasa Inggris)

-   [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.

[Alat gratis (bahasa Inggris)](https://broadrouter.com/tools/)

## Istilah dalam artikel ini

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

Batch API adalah endpoint LLM asinkron yang menerima banyak request sekaligus, biasanya sebagai file, memprosesnya dalam jangka waktu tertentu alih-alih seketika, lalu mengembalikan hasilnya bersama-sama. Penyedia seperti OpenAI dan Anthropic memberi harga request batch dengan diskon dibanding API standar mereka.

[Rate limit (batas laju)](https://broadrouter.com/id/glossary/rate-limit/)

Rate limit adalah batas yang diterapkan API pada seberapa banyak client boleh memakainya dalam rentang waktu tertentu, misalnya permintaan per menit atau token per menit. Permintaan yang melebihi batas ditolak, biasanya dengan HTTP 429 Too Many Requests, sampai pemakaian kembali di bawah batas.

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

Token adalah satuan teks yang dibaca dan ditulis model bahasa: sebuah kata, bagian kata, tanda baca, atau urutan byte yang dihasilkan tokenizer model. API LLM menghitung, membatasi, dan biasanya menagih pemakaian dalam token.

[Konkurensi (concurrency)](https://broadrouter.com/id/glossary/concurrency/)

Konkurensi (concurrency) adalah jumlah permintaan yang sedang berjalan dari sebuah client pada saat yang sama. API LLM sering membatasinya per kunci atau per paket, terpisah dari batas permintaan per menit, karena setiap permintaan yang terbuka menahan kapasitas GPU sampai responsnya selesai.

[Bayar sesuai pemakaian (pay-as-you-go)](https://broadrouter.com/id/glossary/pay-as-you-go/)

Bayar sesuai pemakaian (pay-as-you-go) adalah model harga di mana Anda hanya membayar yang Anda pakai, dihitung per satuan seperti token, permintaan, atau menit audio, tanpa langganan atau komitmen minimum. Sebagian besar API LLM menagih dengan cara ini, dari saldo prabayar atau tagihan berkala.

[System prompt (prompt sistem)](https://broadrouter.com/id/glossary/system-prompt/)

System prompt adalah teks instruksi yang dikirim aplikasi ke model bahasa sebelum percakapan, biasanya sebagai pesan dengan peran system atau developer. System prompt menetapkan peran, aturan, gaya bahasa, dan format output model, dan model dirancang untuk mengikutinya di atas pesan pengguna yang bertentangan.

[Exponential backoff](https://broadrouter.com/id/glossary/exponential-backoff/)

Exponential backoff adalah strategi percobaan ulang di mana client menunggu makin lama setelah setiap percobaan yang gagal, biasanya menggandakan jedanya sampai batas tertentu, sebelum mencoba lagi. Menambahkan jitter acak pada setiap jeda menyebarkan percobaan ulang dari banyak client agar tidak menghantam server pada saat yang sama.

[Latensi (latency)](https://broadrouter.com/id/glossary/latency/)

Latensi, untuk API model bahasa, adalah waktu yang dibutuhkan sebuah permintaan sejak dikirim sampai token output terakhir diterima. Latensi adalah jumlah dari time to first token dan waktu generasi, dan biasanya dilaporkan sebagai persentil seperti p50 dan p95, bukan rata-rata.

## Pertanyaan umum

### Apakah BroadNet Inference punya Batch API?

Tidak. Referensi API-nya, dicek pada 15 November 2026, mendokumentasikan POST /v1/chat/completions, POST /v1/audio/transcriptions, dan GET /v1/models, tanpa endpoint batch atau upload file dan tanpa diskon batch. Jalankan job massal sebagai permintaan biasa dalam batas kunci Anda.

### Bagaimana memproses 100.000 prompt dengan API LLM?

Masukkan item ke file JSONL, masing-masing dengan ID. Jalankan sejumlah worker tetap sesuai limit permintaan bersamaan kunci Anda, atur laju awal permintaan di bawah limit per menit, lakukan retry untuk 429 dan 5xx dengan backoff terbatas, dan tambahkan setiap hasil ke file output dengan ID sebagai kunci agar job bisa dilanjutkan.

### Berapa lama batch sejuta permintaan akan selesai?

Bagi jumlah item dengan laju nyata Anda. Pada 30 permintaan per menit dan satu item per permintaan, satu kunci memproses 43.200 per hari, jadi sejuta butuh sekitar 23 hari. Mengemas 20 item pendek per permintaan memangkasnya menjadi sekitar 28 jam, jika model menangani prompt yang lebih panjang dengan baik.

### Sebaiknya pakai asyncio.gather atau worker pool untuk panggilan LLM batch?

Untuk puluhan ribu item, pakai worker pool tetap yang mengambil dari antrean. gather dengan semaphore cocok untuk job kecil, tetapi membuat semua task di awal dan mempersulit melanjutkan job serta memantau progres.

### Bolehkah saya memakai beberapa kunci API agar lebih cepat?

Tanyakan dulu. Kebijakan Penggunaan yang Dapat Diterima BroadNet melarang mengakali rate limit atau limit concurrency, jadi tanyakan ke BroadNet sebelum memecah satu job ke beberapa kunci untuk melewati limit per kunci. Mengemas lebih banyak item per permintaan dan sesi paket adalah cara terdokumentasi untuk menambah throughput.

### Apakah paket harga tetap cocok untuk job batch?

Bisa, untuk DeepSeek V4.1 Flash. Satu sesi menjalankan satu permintaan pada satu waktu tanpa meteran token, jadi biayanya tetap dan pertanyaannya adalah waktu. Ukur detik per item, lalu beli sesi secukupnya agar selesai dalam periode tersebut.

## Baca juga

-   [Cara mengatasi error 429 API LLM: backoff, jitter, dan limiter](https://broadrouter.com/id/blog/handle-llm-api-429-rate-limits/)
-   [Agent yang berjalan lama: timeout, retry, dan checkpoint yang andal](https://broadrouter.com/id/blog/long-running-agents-timeouts-retries/)
-   [Klasifikasi teks bahasa Arab dengan LLM: sentimen, intent, triase](https://broadrouter.com/id/blog/arabic-text-classification-llm/)
-   [Cara menjalankan agen coding paralel dengan API LLM harga tetap](https://broadrouter.com/id/blog/run-parallel-coding-agents-flat-rate/)
-   [Paket LLM mingguan untuk proyek singkat: Orbit vs per jam vs bulanan](https://broadrouter.com/id/blog/weekly-llm-plan-short-projects/)
-   [Cara menghitung estimasi biaya API LLM sebelum meluncurkan fitur](https://broadrouter.com/id/blog/estimate-llm-api-cost-before-launch/)
-   [Hardware GPU dan pendekatan serving BroadNet, menurut BroadNet](https://broadrouter.com/id/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache respons API LLM untuk memangkas biaya: exact cache di Python](https://broadrouter.com/id/blog/cache-llm-responses-cut-cost/)
-   [Panduan: Kode error BroadNet Inference dan kapan harus mencoba ulang](https://broadrouter.com/id/guides/errors-and-retries/)
-   [Panduan: Memakai OpenAI Python SDK dengan BroadNet Inference](https://broadrouter.com/id/guides/openai-python-sdk/)
-   [Panduan: Cara kerja paket API LLM unlimited untuk agen](https://broadrouter.com/id/guides/unlimited-llm-api-sessions/)

Coba dengan beban kerja Anda yang sebenarnya. Akun baru mendapat kredit US$5 untuk Gemma dan transkripsi. DeepSeek, GLM, dan Qwen3.8 memerlukan top up.

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

**Sumber**

-   [Referensi API BroadNet Inference: endpoint, limit bayar sesuai pemakaian (30 per menit, 4 bersamaan), limit kunci per jam, panduan retry 429 dan 5xx, reasoning\_effort (dicek 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Halaman paket BroadNet Inference: satu permintaan pada satu waktu per sesi, kecepatan tipikal, harga paket (dicek 2026-11-15) (bahasa Inggris)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=id-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Kebijakan Penggunaan yang Dapat Diterima BroadNet, bagian 3 dan 4: dilarang mengakali rate limit atau limit concurrency; paket best effort di bawah fair use (dicek 2026-11-15) (bahasa Inggris)](https://www.broadnet.ai/aup)
-   [Panduan Batch API OpenAI: diskon 50%, jendela 24 jam, 50.000 permintaan atau 200 MB per batch, urutan output bisa berbeda, custom\_id (dicek 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Dokumentasi Message Batches API Anthropic: diskon 50%, 100.000 permintaan atau 256 MB, sebagian besar batch selesai dalam 1 jam, kedaluwarsa setelah 24 jam (dicek 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
