---
title: "Пакетная обработка LLM без Batch API: раннер и расчёт"
description: "Как прогнать от 10 000 до 1 000 000 промптов через chat completions без Batch API: лимит параллельности, темп запросов, повторы, чекпойнты и расчёт времени."
url: https://broadrouter.com/ru/blog/llm-batch-processing-without-batch-api/
lang: ru
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Переведено с английского с помощью ИИ. [Читать оригинал на английском](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (обновлён 2026-11-16).

# Пакетная обработка LLM без Batch API: возобновляемый раннер

Команда BroadNet Inference · 8 мин чтения · Опубликовано 2026-11-15 · Обновлено 2026-11-16

Без Batch API запускайте задание сами: читайте элементы из JSONL-файла, держите число одновременных запросов на лимите ключа, распределяйте старты запросов в пределах лимита в минуту, повторяйте 429 и 5xx с ограниченной задержкой и дописывайте каждый результат с его ID. При перезапуске пропускайте готовые ID. Время завершения обычно задаёт лимит запросов, а не модель.

## Главное

-   BroadNet Inference документирует только chat completions и транскрибацию. Batch API и пакетной скидки нет, так что массовое задание — это цикл обычных запросов.
-   Время завершения — число элементов ÷ меньшая из двух скоростей: лимит одновременных запросов ÷ задержка или запросы в минуту. Ключ с оплатой по факту допускает 4 одновременных запросов и 30 в минуту, так что при одном элементе на запрос потолок — 43 200 в день.
-   Пишите по одной строке результата на элемент с ключом по ID и сразу сбрасывайте её на диск. Эта строка и есть чекпойнт: сбой стоит максимум тех запросов, что были в работе.
-   Сессия по тарифу выполняет один запрос за раз. Её пропускная способность — 86 400 ÷ измеренные секунды на элемент, в день, на сессию.
-   Если работа может подождать сутки и скидка 50% на пакеты важна, Batch API от OpenAI и Anthropic могут оказаться дешевле. Посчитайте оба варианта.

**На этой странице**

1.  Есть ли у BroadNet Inference Batch API?
2.  Сколько времени займёт задание?
3.  Как выглядит возобновляемый раннер?
4.  Почему пул воркеров, а не asyncio.gather?
5.  Как сделать повторы безопасными?
6.  Как работают чекпойнты?
7.  Сколько это стоит: оплата по факту или сессия по тарифу?
8.  Где здесь BroadNet Inference

Не каждое задание для LLM — это чат. У вас 50 000 обращений в поддержку, которые нужно разметить, 200 000 описаний товаров для перевода или миллион отзывов для оценки. Провайдеры вроде OpenAI и Anthropic продают для этого [Batch API](https://broadrouter.com/ru/glossary/batch-api/). Многие OpenAI-совместимые API, в том числе BroadNet Inference, — нет. В этой статье показано, как запустить такое задание самому: рассчитать, сколько оно займёт, написать раннер, который соблюдает лимиты, и сделать так, чтобы его можно было безопасно остановить и перезапустить.

BroadRouter — собственный сайт BroadNet, поэтому в расчётах используются опубликованные лимиты BroadNet. Метод работает с любым API chat completions; подставьте цифры своего провайдера.

## Есть ли у BroadNet Inference Batch API?

Нет. [Справочник API](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-llm-batch-processing-without-batch-api&utm_content=body), проверенный 15 ноября 2026 года, документирует `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 | Задаётся вашими лимитами |
| Размер пакета | 50 000 запросов или 200 МБ | 100 000 запросов или 256 МБ | Любой |
| Лимиты запросов | Отдельно от лимитов на модель | Действуют на запросы в очереди | Лимиты вашего ключа |
| Порядок результатов | Может отличаться; сопоставление по `custom_id` | Сопоставление по `custom_id` | Вы сами храните результаты по ID |

Два урока переносятся напрямую. Оба провайдера требуют помечать каждый запрос ID, потому что результаты приходят не по порядку. Ни один не обещает ответ за секунды. Ваш раннер должен работать так же: ID у всего и план, рассчитанный в часах.

Если скидка 50% важнее скорости и нужные модели там есть, размещённый Batch API может оказаться дешевле. Посчитайте оба варианта в [калькуляторе стоимости LLM API](https://broadrouter.com/tools/llm-api-cost-calculator/), прежде чем что-то строить.

## Сколько времени займёт задание?

Посчитайте это до написания кода. Пропускную способность ограничивают два лимита, и побеждает более медленный:

-   **Лимит одновременных запросов ÷ задержка.** При 4 одновременных запросах и 2 секундах на запрос можно завершать 2 в секунду.
-   **Запросы в минуту.** При 30 в минуту можно начинать 0,5 запроса в секунду, как бы быстро ни работала модель.

Ключ BroadNet с [оплатой по факту](https://broadrouter.com/ru/glossary/pay-as-you-go/) допускает 4 одновременных запросов и 30 в минуту. При значениях из справочника API на момент проверки (30 в минуту и 4 одновременно, 2026-11-15) ограничивает [лимит запросов](https://broadrouter.com/ru/glossary/rate-limit/), если только каждый запрос не длится больше 8 секунд; таблица ниже исходит из 30 в минуту:

| Элементов | Один элемент на запрос | 20 элементов на запрос |
| --- | --- | --- |
| 10 000 | 5,6 часа | 17 минут |
| 100 000 | 2,3 дня | 2,8 часа |
| 1 000 000 | 23 дня | 28 часов |

При 30 запросах в минуту один ключ выполняет 1800 запросов в час, или 43 200 в день. Повторы тоже считаются: каждый вызванный вами 429 тратит слот.

Второй столбец — самый сильный рычаг. Короткие элементы, например отзывы или темы обращений, можно отправлять по 10–50 в запросе нумерованным списком и получать обратно JSON-массив. Проверяйте, что в массиве по одной записи на каждый вход и у каждой есть её номер. Этот приём показан в статье [о классификации арабского текста](https://broadrouter.com/ru/blog/arabic-text-classification-llm/). Длинные элементы так не упакуешь: каждый запрос всё равно должен помещаться в [контекстное окно](https://broadrouter.com/ru/glossary/context-window/) модели, а с ростом списка качество может падать. Проверьте упаковку на 200 элементах, прежде чем ей доверять.

Не распределяйте одно задание по нескольким ключам ради обхода лимита на ключ, не спросив. [Политика допустимого использования](https://www.broadnet.ai/aup) BroadNet запрещает обходить лимиты запросов, параллельности и бюджета. Если нужно больше, спросите BroadNet или используйте сессии по тарифу (см. ниже). [Планировщик пакетных заданий](https://broadrouter.com/tools/llm-batch-job-planner/) делает этот расчёт для вашего числа элементов, задержки и лимитов.

## Как выглядит возобновляемый раннер?

Этот раннер читает `items.jsonl` (по одному объекту `{"id", "text"}` на строку) и дописывает по одной строке результата на элемент в `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`. Мы проверили именно этот файл на локальном mock-сервере, который случайно возвращал 429 (8%) и 500 (5%) и отклонял всё сверх 4 одновременных запросов или 30 стартов в минуту. 25 элементов завершились за 55 секунд за 28 запросов (3 повтора), и ни в одном 60-секундном окне не было больше 30 стартов. Когда для экономии времени лимит mock-сервера подняли до 300 в минуту, прогон на 120 элементов, прерванный через 10 секунд, возобновился с 39 сохранённых результатов и завершился со 120 уникальными ID без дубликатов.

## Почему пул воркеров, а не asyncio.gather?

В [руководстве по ошибке 429](https://broadrouter.com/ru/blog/handle-llm-api-429-rate-limits/) используется семафор вокруг `asyncio.gather`. Для нескольких сотен вызовов это нормально. Для большого задания лучше фиксированный пул воркеров, которые берут задачи из очереди:

-   **Память.** `gather` сразу создаёт по задаче на каждый элемент. Пул держит только элементы, которые сейчас в работе.
-   **Параллельность равна размеру пула.** У четырёх воркеров никогда не будет пяти открытых запросов.
-   **Результаты пишутся на диск** по мере завершения, в любом порядке, с ключом по ID.

`Pacer` отвечает за второй лимит. Один семафор не даст превысить 4 одновременных запроса, но если запросы длятся секунду, четыре воркера начнут 240 в минуту и получат 429 на большинстве из них. Pacer разносит старты на 2 секунды по всем воркерам, включая повторы.

## Как сделать повторы безопасными?

Повторяйте только то, что может пройти со второй попытки:

| Ответ | Действие |
| --- | --- |
| 429 | Подождать и повторить; документация BroadNet говорит “use response details and bounded backoff” (перевод: «используйте данные ответа и ограниченную задержку») |
| 500, 502, 503, 504, таймауты, оборванные соединения | Повторить с ограниченной экспоненциальной задержкой |
| 400, 422 | Исправить запрос; повтор вернёт ту же ошибку |
| 401, 402, 403 | Остановить задание; нужно разобраться с ключом, балансом или политикой |
| 413 | Сократить элемент |

Раннер отключает собственные повторы SDK (`max_retries=0`), чтобы политика повторов была ровно одна и с видимым ограничением. Задержка [экспоненциальная](https://broadrouter.com/ru/glossary/exponential-backoff/) с полным случайным разбросом и потолком 60 секунд, так что воркеры, упавшие вместе, не повторяют вместе. После шести попыток элемент записывается как `"ok": false`, и задание идёт дальше. Один плохой элемент никогда не остановит миллион.

У вызова модели нет побочных эффектов, поэтому доставка здесь «хотя бы один раз»: если процесс упадёт посреди запроса, этот элемент при перезапуске отправится снова, и вы заплатите за него дважды. Это единственные потери. Если задание ещё и пишет в другую систему, например создаёт тикеты или отправляет письма, сделайте эту запись [идемпотентной](https://broadrouter.com/ru/glossary/idempotency-key/) по ID элемента и выполняйте её отдельным проходом по `results.jsonl`. Идемпотентные побочные эффекты подробно разобраны в статье [о долгоживущих агентах](https://broadrouter.com/ru/blog/long-running-agents-timeouts-retries/).

## Как работают чекпойнты?

Выходной файл и есть чекпойнт. Каждый завершённый элемент — одна сброшенная на диск строка, поэтому после сбоя, деплоя или Ctrl-C следующий запуск читает файл, собирает ID с `"ok": true` и ставит в очередь только остальные. Элементы, которые раньше завершились ошибкой, повторяются при следующем запуске, и их новая строка дописывается в конец. При чтении результатов берите последнюю строку для каждого ID.

Три привычки помогают этому держаться днями:

1.  **Стабильные ID.** Используйте ключ из базы данных или хеш входа, но не номер строки, который сдвигается при изменении входного файла.
2.  **Проверяйте `finish_reason`.** Ответ, обрезанный по `max_tokens`, помечен `"ok": true`, но бесполезен. DeepSeek V4.1 Flash, GLM 5.3 и Qwen3.8 27B рассуждают перед ответом, и [рассуждения засчитываются в max\_tokens](https://broadrouter.com/ru/guides/reasoning-tokens-empty-response/). Раннер задаёт `reasoning_effort="low"`, который документирует BroadNet, и оставляет 1500 токенов.
3.  **Логируйте использование в каждой строке.** Сумма `usage` из `results.jsonl` даёт реальный счёт за токены, который можно сравнить с вашей оценкой.

## Сколько это стоит: оплата по факту или сессия по тарифу?

При оплате по факту стоимость — это токены. Возьмём 100 000 отзывов, системный промпт на 150 токенов, отзыв на 150 токенов и 100 выходных токенов при низком уровне рассуждений. Это 30 млн входных и 10 млн выходных токенов. На [DeepSeek V4.1 Flash](https://broadrouter.com/ru/models/deepseek-v4.1-flash/) это стоит 30 × $0.175 + 10 × $0.52. Держите системный промпт первым и побайтно неизменным, и его 15 млн токенов могут тарифицироваться по ставке [входа из кэша](https://broadrouter.com/ru/blog/cached-input-tokens-explained/) — $0.0055 за 1 млн там, где кэш срабатывает. Ваши строки `usage` покажут, как часто это происходило.

На тарифе токены бесплатны, а платите вы временем. Сессия по тарифу DeepSeek V4.1 Flash “runs one request at a time” (перевод: «выполняет один запрос за раз»), поэтому задайте `IN_FLIGHT=1` на сессию. Пропускная способность сессии — 86 400 ÷ секунды на элемент, в день. BroadNet указывает типичную скорость около 100 токенов в секунду, но ваша задержка зависит от длины промпта и рассуждений, так что измерьте её на 50 элементах. Если вы намерили 3 секунды на элемент, одна сессия обрабатывает 28 800 в день:

| Задание | Сессий | Время при 3 с/элемент | Тариф |
| --- | --- | --- | --- |
| 100 000 элементов | 1 | Около 3,5 дня | Одна неделя Orbit, $15 за сессию |
| 100 000 элементов | 4 | Около 21 часа | Четыре недели Orbit, по одной на сессию, или около 21 часа Meteor на сессию по $1 за час |
| 1 000 000 элементов | 6 | Около 6 дней | Шесть недель Orbit |

Тарифы предоставляются “best effort under fair use” (перевод: «по принципу best effort в рамках добросовестного использования»), и BroadNet не публикует лимит запросов в минуту для ключей тарифа; действующие лимиты видны в вашем аккаунте. Задавайте `RPM` по ним, а не наугад. Как распределять сессии по ключам, объясняет [руководство по сессиям](https://broadrouter.com/ru/guides/unlimited-llm-api-sessions/).

## Где здесь BroadNet Inference

У BroadNet Inference нет Batch API, поэтому для массовых заданий он подходит, когда вы предпочитаете сами управлять раннером и платить обычные цены за токены или зафиксировать стоимость сессиями по тарифу DeepSeek V4.1 Flash. Для небольших заданий с ограниченным бюджетом [Gemma 4 VL 26B](https://broadrouter.com/ru/models/gemma-4-vl-26b/) за $0.10 за вход и $0.22 за выход за 1 млн работает на стартовом гранте $5. Промпты и ответы не хранятся после каждого запроса. Если задание может подождать сутки, а нужные модели есть у провайдера со скидкой 50% на пакеты, это может обойтись дешевле; сравните, прежде чем принимать решение. Тарифы и лимиты — на [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-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/)

## Термины в этой статье

[Batch API (пакетная обработка запросов)](https://broadrouter.com/ru/glossary/batch-api/)

Batch API — это асинхронный эндпоинт LLM, который принимает сразу много запросов, обычно в виде файла, обрабатывает их не немедленно, а в пределах заданного окна, и возвращает результаты вместе. Такие провайдеры, как OpenAI и Anthropic, берут за пакетные запросы меньше, чем в своих стандартных API.

[Токен (token)](https://broadrouter.com/ru/glossary/token/)

Токен — это единица текста, которую языковая модель читает и пишет: слово, часть слова, знак препинания или последовательность байтов, которую выдаёт токенизатор модели. LLM API считают, ограничивают и обычно тарифицируют использование в токенах.

[Оплата по факту (pay-as-you-go)](https://broadrouter.com/ru/glossary/pay-as-you-go/)

Оплата по факту (pay-as-you-go) — это модель ценообразования, при которой вы платите только за то, что использовали, по счётчику в единицах вроде токенов, запросов или минут аудио, без подписки и минимальных обязательств. Так тарифицирует большинство LLM API — с предоплаченного баланса или по периодическому счёту.

[Вызов инструментов (tool calling)](https://broadrouter.com/ru/glossary/tool-calling/)

Вызов инструментов (function calling) — это функция LLM API, при которой модель возвращает структурированный запрос на выполнение функции, заданной разработчиком, с аргументами в JSON. Приложение выполняет функцию и отправляет результат обратно; сама модель код никогда не выполняет.

[Лимит запросов (rate limit)](https://broadrouter.com/ru/glossary/rate-limit/)

Лимит запросов (rate limit) — это ограничение, которое API накладывает на объём использования клиентом за отрезок времени, например число запросов или токенов в минуту. Запросы сверх лимита отклоняются, обычно с HTTP 429 Too Many Requests, пока использование снова не опустится ниже порога.

[Параллельность (concurrency)](https://broadrouter.com/ru/glossary/concurrency/)

Параллельность (concurrency) — это число запросов, которые клиент одновременно держит в работе. LLM API часто ограничивают её на ключ или тариф отдельно от лимита запросов в минуту, потому что каждый открытый запрос занимает мощности GPU, пока ответ не будет готов.

[Экспоненциальная задержка (exponential backoff)](https://broadrouter.com/ru/glossary/exponential-backoff/)

Экспоненциальная задержка (exponential backoff) — это стратегия повторов, при которой клиент после каждой неудачной попытки ждёт дольше, обычно удваивая паузу до потолка, прежде чем попробовать снова. Случайный джиттер в каждой паузе разносит повторы множества клиентов, чтобы они не били в сервер одновременно.

[Chat Completions API](https://broadrouter.com/ru/glossary/chat-completions-api/)

Chat Completions API — это HTTP-эндпоинт OpenAI, POST /v1/chat/completions, который принимает имя модели и список сообщений с ролями и возвращает следующее сообщение модели. Формат его запроса и ответа стал общим стандартом, который повторяют OpenAI-совместимые провайдеры и SDK.

## Вопросы и ответы

### Есть ли у BroadNet Inference Batch API?

Нет. Справочник API, проверенный 15 ноября 2026 года, документирует POST /v1/chat/completions, POST /v1/audio/transcriptions и GET /v1/models, без эндпоинта для пакетов или загрузки файлов и без пакетной скидки. Запускайте массовые задания обычными запросами в пределах лимитов вашего ключа.

### Как обработать 100 000 промптов через LLM API?

Сложите элементы в JSONL-файл, у каждого свой ID. Запустите фиксированное число воркеров, равное лимиту одновременных запросов ключа, распределяйте старты запросов в пределах лимита в минуту, повторяйте 429 и 5xx с ограниченной задержкой и дописывайте каждый результат в выходной файл с ключом по ID, чтобы задание можно было возобновить.

### Сколько времени займёт пакет из миллиона запросов?

Разделите число элементов на свою реальную скорость. При 30 запросах в минуту и одном элементе на запрос один ключ обрабатывает 43 200 в день, так что миллион займёт около 23 дней. Упаковка 20 коротких элементов в запрос сокращает это примерно до 28 часов, если модель хорошо справляется с более длинным промптом.

### Что использовать для пакетных вызовов LLM — asyncio.gather или пул воркеров?

Для десятков тысяч элементов используйте фиксированный пул воркеров, которые берут задачи из очереди. gather с семафором подходит для небольших заданий, но создаёт все задачи сразу и усложняет возобновление и отслеживание прогресса.

### Можно ли ускориться с помощью нескольких API-ключей?

Сначала уточните. Политика допустимого использования BroadNet запрещает обходить лимиты запросов и параллельности, поэтому спросите BroadNet, прежде чем делить одно задание между ключами ради обхода лимита на ключ. Задокументированные способы увеличить пропускную способность — упаковка нескольких элементов в запрос и сессии по тарифу.

### Подходит ли безлимитный тариф для пакетных заданий?

Может подойти — для DeepSeek V4.1 Flash. Сессия выполняет один запрос за раз без счётчика токенов, так что стоимость фиксирована, а вопрос только во времени. Измерьте секунды на элемент и купите столько сессий, чтобы уложиться в срок.

## Читайте также

-   [Ошибка 429 в LLM API: экспоненциальная задержка, jitter и лимитеры](https://broadrouter.com/ru/blog/handle-llm-api-429-rate-limits/)
-   [Долгоживущие ИИ-агенты: таймауты, повторы и чекпойнты](https://broadrouter.com/ru/blog/long-running-agents-timeouts-retries/)
-   [Классификация арабского текста с LLM: тональность, интенты, тикеты](https://broadrouter.com/ru/blog/arabic-text-classification-llm/)
-   [Параллельные агенты для программирования на безлимитном LLM API](https://broadrouter.com/ru/blog/run-parallel-coding-agents-flat-rate/)
-   [Недельный тариф LLM для коротких проектов: Orbit, час или месяц](https://broadrouter.com/ru/blog/weekly-llm-plan-short-projects/)
-   [Как рассчитать стоимость LLM API до запуска функции](https://broadrouter.com/ru/blog/estimate-llm-api-cost-before-launch/)
-   [GPU-парк и подход к инференсу BroadNet — по описанию самой BroadNet](https://broadrouter.com/ru/blog/broadnet-gpu-fleet-and-serving/)
-   [Кэширование ответов LLM API: кэш точных совпадений на Python](https://broadrouter.com/ru/blog/cache-llm-responses-cut-cost/)
-   [Руководство: Коды ошибок BroadNet Inference и когда повторять запрос](https://broadrouter.com/ru/guides/errors-and-retries/)
-   [Руководство: OpenAI Python SDK и BroadNet Inference](https://broadrouter.com/ru/guides/openai-python-sdk/)
-   [Руководство: Как устроены безлимитные тарифы LLM API для агентов](https://broadrouter.com/ru/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=ru-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=ru-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Страница тарифов BroadNet Inference: один запрос за раз на сессию, типичная скорость, цены тарифов (проверено 2026-11-15) (на английском)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=ru-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Политика допустимого использования BroadNet, разделы 3 и 4: запрет обхода лимитов запросов и параллельности; тарифы по принципу best effort в рамках добросовестного использования (проверено 2026-11-15) (на английском)](https://www.broadnet.ai/aup)
-   [Руководство OpenAI по Batch API: скидка 50%, окно 24 ч, 50 000 запросов или 200 МБ на пакет, порядок результатов может отличаться, custom\_id (проверено 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Документация Anthropic Message Batches API: скидка 50%, 100 000 запросов или 256 МБ, большинство пакетов в течение 1 часа, истечение через 24 часа (проверено 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
