---
title: "Batch API なしの LLM 一括処理：ランナーと所要時間の計算 | BroadRouter"
description: "Batch API がなくても、chat completions API で 1 万〜100 万件のプロンプトを処理する方法。同時実行の上限、レート制御、リトライ、再開できるチェックポイント、所要時間の計算を解説します。"
url: https://broadrouter.com/ja/blog/llm-batch-processing-without-batch-api/
lang: ja
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

このページは英語の原文を AI の支援を受けて翻訳したものです。 [英語の原文を読む](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (2026-11-16 更新).

# Batch API なしで LLM を一括処理する：再開できるランナー

BroadNet Inference チーム · 約 8 分で読めます · 公開日 2026-11-15 · 更新日 2026-11-16

Batch API がなければ、ジョブを自分で動かします。JSONL ファイルから項目を読み、同時実行数をキーの上限に抑え、毎分の上限内に開始間隔を空け、429 と 5xx は上限付きバックオフでリトライし、結果を ID 付きで追記します。再起動時は完了済みの ID を飛ばします。完了時刻を決めるのは通常、モデルではなくレート制限です。

## 要点

-   BroadNet Inference がドキュメント化しているのは chat completions と文字起こしだけです。Batch API もバッチ割引もないので、一括ジョブは通常のリクエストのループになります。
-   完了時間は、項目数 ÷ 2 つのレートのうち遅いほうです。同時実行上限 ÷ レイテンシ、または毎分のリクエスト数。従量課金のキーは同時 4 件、毎分 30 件なので、1 リクエスト 1 項目なら 1 日最大 43,200 件です。
-   項目ごとに結果を 1 行、ID をキーとして書き、すぐに flush します。その行がチェックポイントです。クラッシュしても失うのは実行中だったリクエストだけです。
-   プランのセッションは 1 度に 1 リクエストを実行します。スループットは、セッション 1 つにつき 1 日あたり 86,400 ÷ 実測した 1 項目あたりの秒数です。
-   1 日待てる作業で 50% のバッチ割引が重要なら、OpenAI や Anthropic の Batch API のほうが安いかもしれません。両方の価格を計算してください。

**このページの内容**

1.  BroadNet Inference に Batch API はあるか？
2.  ジョブにはどれくらい時間がかかるか？
3.  再開できるランナーはどんな形か？
4.  なぜ asyncio.gather ではなくワーカープールなのか？
5.  リトライを安全に保つには？
6.  チェックポイントはどう機能するのか？
7.  費用はどうなるか：従量課金か、プランのセッションか？
8.  BroadNet Inference の位置づけ

LLM のジョブがすべてチャットとは限りません。ラベル付けすべきサポートチケットが 5 万件、翻訳すべき商品説明が 20 万件、スコアを付けるべきレビューが 100 万件あるかもしれません。OpenAI や Anthropic などのプロバイダーは、このために [Batch API](https://broadrouter.com/ja/glossary/batch-api/) を提供しています。多くの OpenAI 互換 API にはそれがなく、BroadNet Inference もその 1 つです。この記事では、ジョブを自分で動かす方法を紹介します。所要時間を見積もり、制限を守るランナーを書き、安全に止めて再開できるようにします。

BroadRouter は BroadNet 自身のサイトなので、計算例には BroadNet が公表している制限を使います。方法自体はどの chat completions API でも使えます。数字を自分のプロバイダーのものに置き換えてください。

## BroadNet Inference に Batch API はあるか？

ありません。2026 年 11 月 15 日時点の [API リファレンス](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-llm-batch-processing-without-batch-api&utm_content=body)に載っているのは、`POST /v1/chat/completions`、`POST /v1/audio/transcriptions`、`GET /v1/models`（モデル一覧）と、`/portal/` 以下のアカウント用エンドポイントです。バッチやファイルアップロードのエンドポイントも、バッチ割引もありません。一括ジョブは通常のリクエストのループです。

自分で何を作り直すことになるのかを知るために、ホスト型の Batch API が提供するものを見ておきましょう。

|  | OpenAI Batch API | Anthropic Message Batches | 自前のランナー |
| --- | --- | --- | --- |
| 価格 | 同期呼び出しの 50% 引き | 50% 引き | 通常価格 |
| 完了までの時間 | 24 時間以内 | 大半は 1 時間以内、24 時間で期限切れ | レート制限で決まる |
| 1 バッチのサイズ | 50,000 リクエストまたは 200 MB | 100,000 リクエストまたは 256 MB | 制限なし |
| レート制限 | モデルごとの制限とは別枠 | キュー内のリクエストに適用 | キーの制限 |
| 結果の順序 | 異なる場合あり、`custom_id` で照合 | `custom_id` で照合 | 自分で ID をキーに結果を保存 |

ここから 2 つの教訓が得られます。どちらのプロバイダーも、結果が順番どおりに返らないため、各リクエストに ID を付けさせます。どちらも数秒での回答は約束しません。自前のランナーも同じように動かすべきです。すべてに ID を付け、計画は時間単位で考えます。

完了までの時間より 50% の割引が重要で、必要なモデルがそこにあるなら、ホスト型の Batch API のほうが安いかもしれません。作り始める前に、[LLM API コスト計算ツール](https://broadrouter.com/tools/llm-api-cost-calculator/)で両方の価格を計算してください。

## ジョブにはどれくらい時間がかかるか？

コードを書く前に計算します。スループットを制限するものは 2 つあり、遅いほうが勝ちます。

-   **同時実行上限 ÷ レイテンシ。** 同時 4 リクエストで 1 リクエスト 2 秒なら、1 秒に 2 件完了できます。
-   **毎分のリクエスト数。** 毎分 30 件なら、モデルがどれだけ速くても 1 秒に 0.5 件しか開始できません。

BroadNet の[従量課金](https://broadrouter.com/ja/glossary/pay-as-you-go/)のキーは、同時 4 リクエスト、毎分 30 件まで使えます。確認時（2026-11-15）の API リファレンスの値（毎分 30 件、同時 4 件）では、各リクエストに 8 秒以上かからない限り、効いてくるのは[レート制限](https://broadrouter.com/ja/glossary/rate-limit/)です。下の表は毎分 30 件で計算しています。

| 項目数 | 1 リクエスト 1 項目 | 1 リクエスト 20 項目 |
| --- | --- | --- |
| 10,000 | 5.6 時間 | 17 分 |
| 100,000 | 2.3 日 | 2.8 時間 |
| 1,000,000 | 23 日 | 28 時間 |

毎分 30 リクエストなら、1 つのキーで 1 時間に 1,800 リクエスト、1 日に 43,200 リクエストです。リトライも数に入ります。発生させた 429 はどれも 1 枠を消費します。

2 列目がもっとも大きな手段です。レビューやチケットの件名のような短い項目なら、番号付きリストとして 1 リクエストに 10〜50 件まとめ、JSON 配列で返してもらえます。配列が入力 1 件につき 1 要素あり、それぞれに番号が付いているかを確認してください。[アラビア語テキスト分類の記事](https://broadrouter.com/ja/blog/arabic-text-classification-llm/)でこのパターンを紹介しています。長い項目はまとめられません。各リクエストはモデルの[コンテキストウィンドウ](https://broadrouter.com/ja/glossary/context-window/)に収まる必要があり、リストが長くなると品質が落ちることもあります。まとめ方を信頼する前に、200 項目で試してください。

キーごとの制限を超えるために、問い合わせずに 1 つのジョブを複数のキーに分散させてはいけません。BroadNet の[利用規定（AUP）](https://www.broadnet.ai/aup)は、レート、同時実行、予算の制限の回避を禁じています。もっと必要なら BroadNet に問い合わせるか、後述のプランのセッションを使ってください。[バッチジョブ計画ツール](https://broadrouter.com/tools/llm-batch-job-planner/)を使えば、項目数、レイテンシ、制限からこの計算ができます。

## 再開できるランナーはどんな形か？

このランナーは `items.jsonl`（1 行に 1 つの `{"id", "text"}` オブジェクト）を読み、項目ごとに 1 行の結果を `results.jsonl` に追記します。必要なのは 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]))
```

`python batch_run.py items.jsonl results.jsonl` で実行します。私たちはこのファイルをそのまま、ランダムに 429（8%）と 500（5%）を返し、同時 4 件または毎分 30 件の開始を超えるリクエストを拒否するローカルのモックサーバーでテストしました。25 項目が 28 リクエスト（リトライ 3 回）で 55 秒で完了し、どの 60 秒間でも開始数は 30 件を超えませんでした。時間短縮のためにモックの制限を毎分 300 件に上げたうえで、120 項目のジョブを 10 秒後に強制終了したところ、保存済みの 39 件の結果から再開し、重複なしの 120 個の ID で完了しました。

## なぜ asyncio.gather ではなくワーカープールなのか？

[429 のガイド](https://broadrouter.com/ja/blog/handle-llm-api-429-rate-limits/)では、`asyncio.gather` をセマフォで囲んでいます。数百件の呼び出しならそれで問題ありません。大きなジョブには、キューから取り出す固定数のワーカープールのほうが適しています。

-   **メモリ。** `gather` は最初に項目ごとにタスクを 1 つ作ります。プールが保持するのは実行中の項目だけです。
-   **同時実行数はプールのサイズそのもの。** 4 つのワーカーが 5 つのリクエストを同時に開くことはありえません。
-   **結果は完了した順にディスクへ流れます。** 順序は問わず、ID がキーです。

2 つ目の制限を扱うのが `Pacer` です。セマフォだけでは同時 4 件を超えないことしか保証できず、リクエストが 1 秒で終わるなら 4 つのワーカーは毎分 240 件を開始し、その大半が 429 になります。Pacer は、リトライを含めすべてのワーカーにわたって開始の間隔を 2 秒空けます。

## リトライを安全に保つには？

2 回目で成功する見込みのあるものだけをリトライします。

| レスポンス | 対応 |
| --- | --- |
| 429 | バックオフしてリトライ。BroadNet のドキュメントには “use response details and bounded backoff”（訳：レスポンスの詳細を使い、上限付きのバックオフを行う）とあります |
| 500、502、503、504、タイムアウト、接続切断 | 上限付きの指数バックオフでリトライ |
| 400、422 | リクエストを修正する。リトライしても同じエラーになる |
| 401、402、403 | ジョブを止める。キー、残高、ポリシーへの対応が必要 |
| 413 | 項目を短くする |

ランナーは SDK 自体のリトライを無効にしている（`max_retries=0`）ので、リトライ方針はただ 1 つで、上限も明確です。バックオフは完全ジッター付きの[指数バックオフ](https://broadrouter.com/ja/glossary/exponential-backoff/)で上限は 60 秒なので、同時に失敗したワーカーが同時にリトライすることはありません。6 回試しても失敗した項目は `"ok": false` として書き出され、ジョブは先に進みます。1 件の不良項目が 100 万件を止めることはありません。

モデル呼び出しには副作用がないので、ここでの配信は「少なくとも 1 回」です。リクエストの途中でプロセスが落ちると、その項目は再起動時にもう一度送られ、料金も 2 回かかります。無駄はそれだけです。ジョブがチケットやメールなど別のシステムにも書き込む場合は、その書き込みを項目 ID で[冪等](https://broadrouter.com/ja/glossary/idempotency-key/)にし、`results.jsonl` を走査する別のパスで行ってください。冪等な副作用については[長時間動くエージェントの記事](https://broadrouter.com/ja/blog/long-running-agents-timeouts-retries/)で詳しく扱っています。

## チェックポイントはどう機能するのか？

出力ファイルがチェックポイントです。完了した項目はそれぞれ flush 済みの 1 行なので、クラッシュ、デプロイ、Ctrl-C の後、次の実行はファイルを読み、`"ok": true` の ID を集め、残りだけをキューに入れます。以前失敗した項目は次の実行でリトライされ、新しい行が追記されます。結果を読むときは、ID ごとに最後の行を採用してください。

何日も続けて安定させるための習慣が 3 つあります。

1.  **安定した ID。** データベースのキーか入力のハッシュを使い、入力ファイルが変わるとずれる行番号は決して使いません。
2.  **`finish_reason` を確認する。** `max_tokens` で打ち切られた返信は `"ok": true` でも役に立ちません。DeepSeek V4.1 Flash、GLM 5.3、Qwen3.8 27B は回答の前に推論し、[推論は max\_tokens に含まれます](https://broadrouter.com/ja/guides/reasoning-tokens-empty-response/)。ランナーは BroadNet がドキュメント化している `reasoning_effort="low"` を指定し、1,500 トークンの余裕を残しています。
3.  **行ごとに使用量を記録する。** `results.jsonl` の `usage` を合計すれば実際のトークン請求額がわかり、見積もりと比べられます。

## 費用はどうなるか：従量課金か、プランのセッションか？

従量課金では、費用はトークンです。レビュー 10 万件、システムプロンプト 150 トークン、レビュー 150 トークン、推論を低く設定して出力 100 トークンとすると、入力 3,000 万トークン、出力 1,000 万トークンです。[DeepSeek V4.1 Flash](https://broadrouter.com/ja/models/deepseek-v4.1-flash/) では 30 × $0.175 + 10 × $0.52 になります。システムプロンプトを先頭に置いてバイト単位で同一に保てば、キャッシュに当たった分のその 1,500 万トークンは、100 万トークンあたり $0.0055 の[キャッシュ入力](https://broadrouter.com/ja/blog/cached-input-tokens-explained/)価格で課金されます。どれだけ当たったかは `usage` の行でわかります。

プランでは、トークンは無料で、コストは時間です。DeepSeek V4.1 Flash のプランのセッションは “runs one request at a time”（訳：1 度に 1 リクエストを実行する）ので、セッションごとに `IN_FLIGHT=1` を設定します。セッション 1 つあたりのスループットは、1 日 86,400 ÷ 1 項目あたりの秒数です。BroadNet は標準的な速度を 毎秒約 100 トークン としていますが、レイテンシはプロンプトの長さと推論量で変わるので、50 項目で測ってください。1 項目 3 秒なら、1 セッションで 1 日 28,800 件です。

| ジョブ | セッション数 | 1 項目 3 秒での所要時間 | プラン |
| --- | --- | --- | --- |
| 100,000 項目 | 1 | 約 3.5 日 | Orbit 1 週間、セッションあたり $15 |
| 100,000 項目 | 4 | 約 21 時間 | Orbit 1 週間 × 4（セッションごとに 1 つ）、またはセッションごとに約 21 時間分の Meteor（1 時間 $1） |
| 1,000,000 項目 | 6 | 約 6 日 | Orbit 1 週間 × 6 |

プランは “best effort under fair use”（訳：フェアユースの範囲でのベストエフォート）で提供され、BroadNet はプランのキーの毎分リクエスト上限を公表していません。適用される制限はアカウントに表示されます。`RPM` は推測ではなく、その値に基づいて設定してください。セッションを複数のキーに分ける方法は[セッション計画ガイド](https://broadrouter.com/ja/guides/unlimited-llm-api-sessions/)で説明しています。

## BroadNet Inference の位置づけ

BroadNet Inference には Batch API がないので、ランナーを自分で管理して通常のトークン単価で払いたい場合や、DeepSeek V4.1 Flash のプランのセッションで費用を固定したい場合の一括ジョブに向いています。予算の限られた小さなジョブなら、100 万トークンあたり入力 $0.10、出力 $0.22 の [Gemma 4 VL 26B](https://broadrouter.com/ja/models/gemma-4-vl-26b/) を $5 の初回クレジットで動かせます。プロンプトと出力は各リクエストの後に保持されません。1 日待てるジョブで、必要なモデルが 50% のバッチ割引のあるプロバイダーにあるなら、そちらのほうが安いかもしれません。決める前に比較してください。プランと制限は [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-llm-batch-processing-without-batch-api&utm_content=body) にあります。

関連する無料ツール （英語）

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

[無料ツール （英語）](https://broadrouter.com/tools/)

## この記事の用語

[トークン（token）](https://broadrouter.com/ja/glossary/token/)

トークンとは、言語モデルが読み書きするテキストの単位です。モデルのトークナイザーが作る単語、単語の一部、句読点、バイト列のいずれかにあたります。LLM API は利用量をトークンで数え、上限を設け、通常はトークン単位で課金します。

[バッチ API（Batch API）](https://broadrouter.com/ja/glossary/batch-api/)

バッチ API とは、多数のリクエストを通常はファイルとして一度に受け付け、すぐにではなく決められた時間枠の中で処理し、結果をまとめて返す非同期の LLM エンドポイントです。OpenAI や Anthropic などの事業者は、バッチリクエストを標準 API より割り引いた価格にしています。

[指数バックオフ（exponential backoff）](https://broadrouter.com/ja/glossary/exponential-backoff/)

指数バックオフ（exponential backoff）とは、失敗するたびに待ち時間を長くして再試行するリトライ戦略で、通常は上限まで遅延を 2 倍ずつ増やします。各待ち時間にランダムなジッターを加えると、多数のクライアントの再試行が分散し、同時にサーバーへ集中しなくなります。

[レート制限（rate limit）](https://broadrouter.com/ja/glossary/rate-limit/)

レート制限とは、1 分あたりのリクエスト数やトークン数など、一定時間内にクライアントが API を使える量に API 側が設ける上限です。上限を超えたリクエストは、使用量が下回るまで通常 HTTP 429 Too Many Requests で拒否されます。

[従量課金（pay-as-you-go）](https://broadrouter.com/ja/glossary/pay-as-you-go/)

従量課金とは、使った分だけを支払う料金体系です。トークン、リクエスト、音声の分数などの単位で計測され、サブスクリプションや最低利用額はありません。多くの LLM API はこの方式で、前払いの残高か定期的な請求書から支払います。

[同時実行数（concurrency）](https://broadrouter.com/ja/glossary/concurrency/)

同時実行数（concurrency）とは、クライアントが同時に処理中にしているリクエストの数です。開いているリクエストは応答が終わるまで GPU の容量を占有するため、LLM API は毎分リクエスト数とは別に、キーやプランごとにこれを制限することがよくあります。

[Chat Completions API（チャット補完 API）](https://broadrouter.com/ja/glossary/chat-completions-api/)

Chat Completions API とは、OpenAI の HTTP エンドポイント POST /v1/chat/completions で、モデル名とロール付きメッセージのリストを受け取り、モデルの次のメッセージを返します。そのリクエストと応答の形は、OpenAI 互換のプロバイダーや SDK が使う共通形式になりました。

[OpenAI 互換 API（OpenAI-compatible API）](https://broadrouter.com/ja/glossary/openai-compatible-api/)

OpenAI 互換 API とは、POST /v1/chat/completions など OpenAI API と同じリクエスト形式とレスポンス形式を受け付ける HTTP API です。OpenAI の SDK やツールは、ベース URL、API キー、モデル名を変えるだけで利用できます。

## よくある質問

### BroadNet Inference に Batch API はありますか？

ありません。2026 年 11 月 15 日時点の API リファレンスには POST /v1/chat/completions、POST /v1/audio/transcriptions、GET /v1/models があり、バッチやファイルアップロードのエンドポイントも、バッチ割引もありません。一括ジョブはキーの制限内で通常のリクエストとして実行してください。

### LLM API で 10 万件のプロンプトを処理するには？

項目を JSONL ファイルに入れ、それぞれに ID を付けます。キーの同時実行上限と同じ数のワーカーを動かし、毎分の上限を超えないよう開始間隔を空け、429 と 5xx は上限付きのバックオフでリトライし、結果を ID をキーとして出力ファイルに追記すれば、ジョブを再開できます。

### 100 万リクエストの一括処理にはどれくらいかかりますか？

項目数を実際のレートで割ります。毎分 30 リクエスト・1 リクエスト 1 項目なら、1 つのキーで 1 日 43,200 件なので、100 万件で約 23 日です。短い項目を 1 リクエストに 20 件まとめれば約 28 時間に縮みます。ただしモデルが長いプロンプトをうまく扱えることが前提です。

### LLM の一括呼び出しには asyncio.gather とワーカープールのどちらを使うべきですか？

数万件規模なら、キューから取り出す固定数のワーカープールを使います。セマフォ付きの gather は小さなジョブには使えますが、最初にすべてのタスクを作るため、再開や進捗管理が難しくなります。

### 複数の API キーを使って速くできますか？

まず確認してください。BroadNet の利用規定はレートや同時実行の制限の回避を禁じているので、キーごとの上限を超えるために 1 つのジョブを複数のキーに分ける前に BroadNet に問い合わせてください。1 リクエストに多くの項目をまとめることと、プランのセッションが、ドキュメント化されたスループット向上の方法です。

### 定額プランはバッチジョブに向いていますか？

DeepSeek V4.1 Flash なら向いている場合があります。セッションはトークンの計量なしで 1 度に 1 リクエストを実行するので、費用は固定で、問題は時間です。1 項目あたりの秒数を測り、期間内に終わるだけのセッションを買ってください。

## 続けて読む

-   [LLM API の 429 エラー対処法：バックオフ、ジッター、同時実行制限](https://broadrouter.com/ja/blog/handle-llm-api-429-rate-limits/)
-   [長時間動くエージェント：崩れないタイムアウト、リトライ、チェックポイント](https://broadrouter.com/ja/blog/long-running-agents-timeouts-retries/)
-   [LLM によるアラビア語テキスト分類：感情、意図、振り分け](https://broadrouter.com/ja/blog/arabic-text-classification-llm/)
-   [定額の LLM API で並列コーディングエージェントを動かす方法](https://broadrouter.com/ja/blog/run-parallel-coding-agents-flat-rate/)
-   [短期プロジェクト向け LLM 週間プラン：Orbit、1 時間、1 か月の比較](https://broadrouter.com/ja/blog/weekly-llm-plan-short-projects/)
-   [機能リリース前に LLM API のコストを見積もる方法](https://broadrouter.com/ja/blog/estimate-llm-api-cost-before-launch/)
-   [BroadNet の GPU ハードウェアとサービング方式（BroadNet の説明による）](https://broadrouter.com/ja/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API のレスポンスをキャッシュしてコスト削減：Python の完全一致キャッシュ](https://broadrouter.com/ja/blog/cache-llm-responses-cut-cost/)
-   [ガイド：BroadNet Inference のエラーコードとリトライすべき場合](https://broadrouter.com/ja/guides/errors-and-retries/)
-   [ガイド：OpenAI Python SDK を BroadNet Inference で使う](https://broadrouter.com/ja/guides/openai-python-sdk/)
-   [ガイド：エージェント向け無制限 LLM API プランのしくみ](https://broadrouter.com/ja/guides/unlimited-llm-api-sessions/)

実際のワークロードで試してください。 新規アカウントには US$5 の初回クレジットがあり、Gemma、文字起こし に使えます。DeepSeek、GLM、Qwen3.8 はチャージが必要です。

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

**出典**

-   [BroadNet Inference API リファレンス：エンドポイント、従量課金の制限（毎分 30 件、同時 4 件）、時間制キーの制限、429 と 5xx のリトライ指針、reasoning\_effort（2026-11-15 確認） （英語）](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet Inference プランページ：1 セッションにつき 1 度に 1 リクエスト、標準的な速度、プラン価格（2026-11-15 確認） （英語）](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=ja-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [BroadNet 利用規定（AUP）第 3・4 節：レート・同時実行の制限の回避禁止、プランはフェアユースの範囲でベストエフォート（2026-11-15 確認） （英語）](https://www.broadnet.ai/aup)
-   [OpenAI Batch API ガイド：50% 割引、24 時間枠、1 バッチ 50,000 リクエストまたは 200 MB、出力順は異なる場合あり、custom\_id（2026-11-15 確認）](https://developers.openai.com/api/docs/guides/batch)
-   [Anthropic Message Batches API ドキュメント：50% 割引、100,000 リクエストまたは 256 MB、大半のバッチは 1 時間以内、24 時間後に期限切れ（2026-11-15 確認）](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
