---
title: "LLM-Batch-Verarbeitung ohne Batch API: Runner und Rechnung"
description: "10.000 bis 1.000.000 Prompts über eine Chat-Completions-API ohne Batch API: Parallelitätslimits, Taktung, Retries, fortsetzbare Checkpoints und die Zeitrechnung."
url: https://broadrouter.com/de/blog/llm-batch-processing-without-batch-api/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (aktualisiert am 2026-11-16).

# LLM-Batch-Verarbeitung ohne Batch API: ein fortsetzbarer Runner

Vom Team von BroadNet Inference · 8 Min. Lesezeit · Veröffentlicht 2026-11-15 · Aktualisiert 2026-11-16

Ohne Batch API betreiben Sie den Job selbst: Items aus einer JSONL-Datei lesen, gleichzeitige Anfragen auf das Limit des Schlüssels begrenzen, Anfragestarts unter dem Minutenlimit takten, 429 und 5xx mit begrenztem Backoff wiederholen und jedes Ergebnis mit seiner ID anhängen. Beim Neustart überspringen Sie erledigte IDs. Meist bestimmt das Rate Limit, nicht das Modell, wann der Job fertig ist.

## Das Wichtigste in Kürze

-   BroadNet Inference dokumentiert nur Chat Completions und Transkriptionen. Es gibt keine Batch API und keinen Batch-Rabatt, ein Massenjob ist also eine Schleife gewöhnlicher Anfragen.
-   Die Laufzeit ist Items ÷ die langsamere von zwei Raten: Limit gleichzeitiger Anfragen ÷ Latenz oder Anfragen pro Minute. Ein Pay-as-you-go-Schlüssel erlaubt 4 gleichzeitig und 30 pro Minute, bei einem Item pro Anfrage also höchstens 43.200 pro Tag.
-   Schreiben Sie pro Item eine Ergebniszeile mit der ID als Schlüssel und flushen Sie sie. Diese Zeile ist der Checkpoint: Ein Absturz kostet höchstens die Anfragen, die gerade liefen.
-   Eine Plan-Session verarbeitet jeweils eine Anfrage. Ihr Durchsatz beträgt 86.400 ÷ Ihre gemessenen Sekunden pro Item, pro Tag und Session.
-   Wenn die Arbeit einen Tag warten kann und 50 % Batch-Rabatt zählen, sind die Batch APIs von OpenAI und Anthropic eventuell das günstigere Werkzeug. Rechnen Sie beides durch.

**Auf dieser Seite**

1.  Hat BroadNet Inference eine Batch API?
2.  Wie lange dauert der Job?
3.  Wie sieht ein fortsetzbarer Runner aus?
4.  Warum ein Worker-Pool und nicht asyncio.gather?
5.  Wie bleiben Retries sicher?
6.  Wie funktioniert das Checkpointing?
7.  Was kostet es: Pay-as-you-go oder Plan-Session?
8.  Wo BroadNet Inference ins Bild passt

Manche LLM-Jobs sind keine Chats. Sie haben 50.000 Support-Tickets zu labeln, 200.000 Produktbeschreibungen zu übersetzen oder eine Million Bewertungen einzustufen. Anbieter wie OpenAI und Anthropic verkaufen dafür eine [Batch API](https://broadrouter.com/de/glossary/batch-api/). Viele OpenAI-kompatible APIs, darunter BroadNet Inference, haben keine. Dieser Beitrag zeigt, wie Sie den Job selbst ausführen: abschätzen, wie lange er dauert, einen Runner schreiben, der die Limits einhält, und dafür sorgen, dass er sich gefahrlos anhalten und neu starten lässt.

BroadRouter ist die eigene Website von BroadNet, die Beispielrechnungen nutzen also die veröffentlichten Limits von BroadNet. Die Methode funktioniert mit jeder Chat-Completions-API; setzen Sie die Zahlen Ihres Anbieters ein.

## Hat BroadNet Inference eine Batch API?

Nein. Die [API-Referenz](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-batch-processing-without-batch-api&utm_content=body), geprüft am 15. November 2026, dokumentiert `POST /v1/chat/completions`, `POST /v1/audio/transcriptions` und `GET /v1/models` (eine Modellliste) sowie Konto-Endpunkte unter `/portal/`. Es gibt keinen Batch- oder Datei-Upload-Endpunkt und keinen Batch-Rabatt. Ein Massenjob ist eine Schleife normaler Anfragen.

Das bietet Ihnen eine gehostete Batch API, damit Sie wissen, was Sie nachbauen:

|  | Batch API von OpenAI | Message Batches von Anthropic | Ihr eigener Runner |
| --- | --- | --- | --- |
| Preis | 50 % unter synchron | 50 % Rabatt | Normaler Preis |
| Bearbeitungszeit | Innerhalb von 24 Stunden | Meist innerhalb 1 Stunde; verfällt nach 24 | Bestimmt durch Ihre Rate Limits |
| Größe pro Batch | 50.000 Anfragen oder 200 MB | 100.000 Anfragen oder 256 MB | Beliebig |
| Rate Limits | Getrennt von den Limits pro Modell | Gelten für Anfragen in der Warteschlange | Die Limits Ihres Schlüssels |
| Reihenfolge der Ergebnisse | Kann abweichen; Abgleich über `custom_id` | Abgleich über `custom_id` | Ergebnisse per ID als Schlüssel |

Zwei Lehren lassen sich übertragen. Beide Anbieter verlangen eine ID pro Anfrage, weil die Ergebnisse nicht in Reihenfolge zurückkommen. Keiner verspricht eine Antwort in Sekunden. Ihr Runner sollte genauso arbeiten: IDs an allem und eine Planung in Stunden.

Wenn 50 % Rabatt wichtiger sind als die Bearbeitungszeit und die benötigten Modelle dort verfügbar sind, ist eine gehostete Batch API eventuell das günstigere Werkzeug. Rechnen Sie beides mit dem [LLM-API-Kostenrechner](https://broadrouter.com/tools/llm-api-cost-calculator/) durch, bevor Sie bauen.

## Wie lange dauert der Job?

Rechnen Sie das aus, bevor Sie Code schreiben. Zwei Limits begrenzen den Durchsatz, und das langsamere gewinnt:

-   **Limit gleichzeitiger Anfragen ÷ Latenz.** Mit 4 gleichzeitigen Anfragen und 2 Sekunden pro Anfrage schaffen Sie 2 pro Sekunde.
-   **Anfragen pro Minute.** Bei 30 pro Minute können Sie 0,5 pro Sekunde starten, egal wie schnell das Modell ist.

Ein [Pay-as-you-go](https://broadrouter.com/de/glossary/pay-as-you-go/)\-Schlüssel von BroadNet erlaubt 4 gleichzeitige Anfragen und 30 pro Minute. Bei den Werten in der API-Referenz zum Zeitpunkt unserer Prüfung (30 pro Minute und 4 gleichzeitig, 2026-11-15) ist das [Rate Limit](https://broadrouter.com/de/glossary/rate-limit/) die Grenze, sofern nicht jede Anfrage länger als 8 Sekunden dauert, und die Tabelle unten rechnet mit 30 pro Minute:

| Items | Ein Item pro Anfrage | 20 Items pro Anfrage |
| --- | --- | --- |
| 10.000 | 5,6 Stunden | 17 Minuten |
| 100.000 | 2,3 Tage | 2,8 Stunden |
| 1.000.000 | 23 Tage | 28 Stunden |

Bei 30 Anfragen pro Minute schafft ein Schlüssel 1.800 Anfragen pro Stunde oder 43.200 pro Tag. Retries zählen mit: Jeder 429, den Sie auslösen, verbraucht einen Slot.

Die zweite Spalte ist der größte Hebel. Kurze Items wie Bewertungen oder Ticket-Betreffzeilen lassen sich zu 10 bis 50 pro Anfrage als nummerierte Liste senden, mit einem JSON-Array als Antwort. Prüfen Sie, dass das Array einen Eintrag pro Input hat und jeder seine Nummer trägt. Der [Beitrag zur Klassifizierung arabischer Texte](https://broadrouter.com/de/blog/arabic-text-classification-llm/) zeigt das Muster. Lange Items lassen sich nicht bündeln: Jede Anfrage muss weiterhin ins [Kontextfenster](https://broadrouter.com/de/glossary/context-window/) des Modells passen, und die Qualität kann mit wachsender Liste sinken. Testen Sie das Bündeln an 200 Items, bevor Sie sich darauf verlassen.

Verteilen Sie einen Job nicht ungefragt auf mehrere Schlüssel, um ein Limit pro Schlüssel zu umgehen. Die [Acceptable Use Policy](https://www.broadnet.ai/aup) von BroadNet verbietet die Umgehung von Rate-, Parallelitäts- oder Budgetlimits. Wenn Sie mehr brauchen, fragen Sie BroadNet oder nutzen Sie Plan-Sessions, siehe unten. Der [Batch-Job-Planer](https://broadrouter.com/tools/llm-batch-job-planner/) erledigt diese Rechnung für Ihre Item-Zahl, Latenz und Limits.

## Wie sieht ein fortsetzbarer Runner aus?

Dieser Runner liest `items.jsonl` (ein `{"id", "text"}`\-Objekt pro Zeile) und hängt pro Item eine Ergebniszeile an `results.jsonl` an. Er braucht nur das 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]))
```

Starten Sie ihn mit `python batch_run.py items.jsonl results.jsonl`. Wir haben genau diese Datei gegen einen lokalen Mock-Server getestet, der zufällig 429 (8 %) und 500 (5 %) zurückgab und alles über 4 gleichzeitige Anfragen oder 30 Starts pro Minute ablehnte. 25 Items waren nach 55 Sekunden mit 28 Anfragen (3 Retries) fertig, und in keinem 60-Sekunden-Fenster gab es mehr als 30 Starts. Mit auf 300 pro Minute angehobenem Mock-Limit, um Zeit zu sparen, setzte ein nach 10 Sekunden abgebrochener Lauf mit 120 Items bei 39 gespeicherten Ergebnissen wieder ein und endete mit 120 eindeutigen IDs ohne Duplikate.

## Warum ein Worker-Pool und nicht asyncio.gather?

Der [429-Leitfaden](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/) nutzt eine Semaphore um `asyncio.gather`. Für ein paar hundert Aufrufe ist das in Ordnung. Für einen großen Job ist ein fester Pool von Workern, die aus einer Queue ziehen, besser:

-   **Speicher.** `gather` erzeugt im Voraus einen Task pro Item. Ein Pool hält nur die Items, die gerade laufen.
-   **Parallelität ist die Pool-Größe.** Vier Worker können nie fünf offene Anfragen haben.
-   **Ergebnisse fließen auf die Platte**, sobald sie fertig sind, in beliebiger Reihenfolge, mit der ID als Schlüssel.

Der `Pacer` kümmert sich um das zweite Limit. Eine Semaphore allein verhindert, dass Sie 4 gleichzeitige Anfragen überschreiten, aber wenn Anfragen eine Sekunde dauern, würden vier Worker 240 pro Minute starten und bei den meisten einen 429 bekommen. Der Pacer setzt die Starts über alle Worker hinweg 2 Sekunden auseinander, Retries eingeschlossen.

## Wie bleiben Retries sicher?

Wiederholen Sie nur, was beim zweiten Versuch gelingen kann:

| Antwort | Aktion |
| --- | --- |
| 429 | Zurückhalten und wiederholen; die Doku von BroadNet sagt “use response details and bounded backoff” (Übersetzung: Antwortdetails und begrenzten Backoff nutzen) |
| 500, 502, 503, 504, Timeouts, abgebrochene Verbindungen | Mit begrenztem exponentiellem Backoff wiederholen |
| 400, 422 | Anfrage korrigieren; ein Retry liefert denselben Fehler |
| 401, 402, 403 | Job anhalten; Schlüssel, Guthaben oder Richtlinie brauchen Aufmerksamkeit |
| 413 | Item kürzen |

Der Runner schaltet die eigenen Retries des SDK ab (`max_retries=0`), damit es genau eine Retry-Strategie mit sichtbarer Obergrenze gibt. Der Backoff ist [exponentiell](https://broadrouter.com/de/glossary/exponential-backoff/) mit Full Jitter und auf 60 Sekunden begrenzt, damit Worker, die gemeinsam gescheitert sind, nicht gemeinsam wiederholen. Nach sechs Versuchen wird das Item als `"ok": false` geschrieben, und der Job läuft weiter. Ein fehlerhaftes Item hält nie eine Million auf.

Ein Modellaufruf hat keine Seiteneffekte, die Zustellung erfolgt hier also mindestens einmal: Stirbt der Prozess mitten in einer Anfrage, wird dieses Item beim Neustart erneut gesendet, und Sie zahlen es doppelt. Das ist die einzige Verschwendung. Schreibt der Job auch in ein anderes System, etwa Tickets oder E-Mails, machen Sie diesen Schreibvorgang per Item-ID [idempotent](https://broadrouter.com/de/glossary/idempotency-key/) und erledigen ihn in einem separaten Durchlauf über `results.jsonl`. Der [Beitrag zu lang laufenden Agenten](https://broadrouter.com/de/blog/long-running-agents-timeouts-retries/) behandelt idempotente Seiteneffekte ausführlich.

## Wie funktioniert das Checkpointing?

Die Ausgabedatei ist der Checkpoint. Jedes fertige Item ist eine geflushte Zeile; nach einem Absturz, einem Deploy oder Strg+C liest der nächste Lauf die Datei, sammelt die IDs mit `"ok": true` und stellt nur den Rest in die Queue. Zuvor gescheiterte Items werden im nächsten Lauf wiederholt, und ihre neue Zeile wird angehängt. Nehmen Sie beim Auslesen pro ID die letzte Zeile.

Drei Gewohnheiten sorgen dafür, dass das über Tage hält:

1.  **Stabile IDs.** Verwenden Sie einen Datenbankschlüssel oder einen Hash des Inputs, nie eine Zeilennummer, die sich verschiebt, wenn sich die Eingabedatei ändert.
2.  **Prüfen Sie `finish_reason`.** Eine bei `max_tokens` abgeschnittene Antwort ist `"ok": true`, aber nutzlos. DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B denken nach, bevor sie antworten, und [Reasoning zählt zu max\_tokens](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/). Der Runner setzt `reasoning_effort="low"`, was BroadNet dokumentiert, und lässt 1.500 Tokens Spielraum.
3.  **Loggen Sie die Nutzung pro Zeile.** Die Summe von `usage` aus `results.jsonl` ergibt die tatsächliche Token-Rechnung, die Sie mit Ihrer Schätzung vergleichen können.

## Was kostet es: Pay-as-you-go oder Plan-Session?

Bei Pay-as-you-go sind die Kosten Tokens. Nehmen Sie 100.000 Bewertungen, einen System-Prompt mit 150 Tokens, eine Bewertung mit 150 Tokens und 100 Output-Tokens bei niedrigem Reasoning. Das sind 30 Millionen Input- und 10 Millionen Output-Tokens. Auf [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) kostet das 30 × $0.175 + 10 × $0.52. Halten Sie den System-Prompt an erster Stelle und byte-identisch, dann können seine 15 Millionen Tokens dort, wo der Cache greift, zum Tarif für [gecachten Input](https://broadrouter.com/de/blog/cached-input-tokens-explained/) von $0.0055 pro 1M abgerechnet werden. Ihre `usage`\-Zeilen zeigen, wie oft das der Fall war.

Bei einem Plan sind Tokens kostenlos, und die Zeit ist der Preis. Eine Plan-Session für DeepSeek V4.1 Flash “runs one request at a time” (Übersetzung: verarbeitet jeweils eine Anfrage), setzen Sie also `IN_FLIGHT=1` pro Session. Der Durchsatz pro Session beträgt 86.400 ÷ Sekunden pro Item, pro Tag. BroadNet gibt die typische Geschwindigkeit mit etwa 100 Tokens pro Sekunde an, aber Ihre Latenz hängt von Prompt-Länge und Reasoning ab, messen Sie sie also an 50 Items. Messen Sie 3 Sekunden pro Item, schafft eine Session 28.800 pro Tag:

| Job | Sessions | Zeit bei 3 s/Item | Plan |
| --- | --- | --- | --- |
| 100.000 Items | 1 | Etwa 3,5 Tage | Eine Orbit-Woche, $15 pro Session |
| 100.000 Items | 4 | Etwa 21 Stunden | Vier Orbit-Wochen, eine pro Session; oder etwa 21 Meteor-Stunden pro Session zu je $1 |
| 1.000.000 Items | 6 | Etwa 6 Tage | Sechs Orbit-Wochen |

Pläne werden “best effort under fair use” (Übersetzung: nach bestem Bemühen im Rahmen fairer Nutzung) erbracht, und BroadNet veröffentlicht kein Minutenlimit für Anfragen mit Plan-Schlüsseln; Ihr Konto zeigt die geltenden Limits. Setzen Sie `RPM` anhand dieser Werte, nicht nach Gefühl. Der [Leitfaden zum Session-Planer](https://broadrouter.com/de/guides/unlimited-llm-api-sessions/) erklärt, wie Sie Sessions auf Schlüssel verteilen.

## Wo BroadNet Inference ins Bild passt

BroadNet Inference hat keine Batch API und eignet sich daher für Massenjobs, wenn Sie den Runner lieber selbst steuern und normale Preise pro Token zahlen oder die Kosten mit Plan-Sessions für DeepSeek V4.1 Flash festschreiben wollen. Für kleine Jobs mit knappem Budget läuft [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) zu $0.10 Input und $0.22 Output pro 1M mit dem Startguthaben von $5. Prompts und Ausgaben werden nach jeder Anfrage nicht gespeichert. Wenn Ihr Job einen Tag warten kann und die benötigten Modelle bei einem Anbieter mit 50 % Batch-Rabatt verfügbar sind, kann das weniger kosten; vergleichen Sie, bevor Sie sich festlegen. Pläne und Limits finden Sie unter [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-batch-processing-without-batch-api&utm_content=body).

Kostenlose Tools zum Thema (auf Englisch)

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

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

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

Ein Token ist die Texteinheit, die ein Sprachmodell liest und schreibt: ein Wort, ein Wortteil, ein Satzzeichen oder eine Bytefolge, die der Tokenizer des Modells erzeugt. LLM-APIs zählen, begrenzen und berechnen die Nutzung meist in Tokens.

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

Eine Batch API ist ein asynchroner LLM-Endpoint, der viele Anfragen auf einmal annimmt, meist als Datei, sie innerhalb eines festgelegten Zeitfensters statt sofort verarbeitet und die Ergebnisse gesammelt zurückgibt. Anbieter wie OpenAI und Anthropic berechnen Batch-Anfragen mit Rabatt gegenüber ihren Standard-APIs.

[Rate Limit (Ratenbegrenzung)](https://broadrouter.com/de/glossary/rate-limit/)

Ein Rate Limit ist eine Obergrenze, die eine API festlegt, wie stark ein Client sie in einem Zeitfenster nutzen darf, etwa Anfragen pro Minute oder Tokens pro Minute. Anfragen über dem Limit werden abgelehnt, meist mit HTTP 429 Too Many Requests, bis die Nutzung wieder darunter liegt.

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

Pay-as-you-go ist ein Preismodell, bei dem Sie nur für tatsächliche Nutzung zahlen, gemessen pro Einheit wie Tokens, Anfragen oder Audiominuten, ohne Abonnement oder Mindestabnahme. Die meisten LLM-APIs rechnen so ab, aus einem vorausbezahlten Guthaben oder per regelmäßiger Rechnung.

[Concurrency (Parallelität)](https://broadrouter.com/de/glossary/concurrency/)

Concurrency (Parallelität) ist die Zahl der Anfragen, die ein Client gleichzeitig offen hat. LLM-APIs begrenzen sie oft pro Schlüssel oder Plan, getrennt von den Anfragen pro Minute, weil jede offene Anfrage GPU-Kapazität belegt, bis ihre Antwort fertig ist.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Latenz (LLM)](https://broadrouter.com/de/glossary/latency/)

Latenz ist bei einer Sprachmodell-API die Zeit, die eine Anfrage vom Senden bis zum Empfang des letzten Output-Tokens braucht. Sie ist die Summe aus Time to First Token und Generierungszeit und wird meist als Perzentile wie p50 und p95 angegeben statt als Durchschnitt.

[Durchsatz (Throughput)](https://broadrouter.com/de/glossary/throughput/)

Durchsatz (Throughput) ist beim Betrieb von LLMs die gesamte Arbeit, die ein System pro Zeiteinheit über alle gleichzeitigen Anfragen erledigt, meist gemessen in Output-Tokens pro Sekunde oder Anfragen pro Sekunde. Er unterscheidet sich von der Geschwindigkeit pro Stream, also davon, wie schnell eine einzelne Anfrage ihre Tokens erhält.

## Häufige Fragen

### Hat BroadNet Inference eine Batch API?

Nein. Die API-Referenz, geprüft am 15. November 2026, dokumentiert POST /v1/chat/completions, POST /v1/audio/transcriptions und GET /v1/models, ohne Batch- oder Datei-Upload-Endpunkt und ohne Batch-Rabatt. Führen Sie Massenjobs als gewöhnliche Anfragen innerhalb der Limits Ihres Schlüssels aus.

### Wie verarbeite ich 100.000 Prompts mit einer LLM-API?

Legen Sie die Items mit je einer ID in eine JSONL-Datei. Lassen Sie eine feste Zahl von Workern laufen, die dem Limit gleichzeitiger Anfragen des Schlüssels entspricht, takten Sie die Starts unter dem Minutenlimit, wiederholen Sie 429 und 5xx mit begrenztem Backoff und hängen Sie jedes Ergebnis mit der ID als Schlüssel an eine Ausgabedatei an, damit der Job fortgesetzt werden kann.

### Wie lange dauert ein Batch mit einer Million Anfragen?

Teilen Sie die Items durch Ihre reale Rate. Bei 30 Anfragen pro Minute und einem Item pro Anfrage schafft ein Schlüssel 43.200 pro Tag, eine Million dauert also rund 23 Tage. Mit 20 kurzen Items pro Anfrage sinkt das auf etwa 28 Stunden, sofern das Modell mit dem längeren Prompt gut umgeht.

### Sollte ich für Batch-LLM-Aufrufe asyncio.gather oder einen Worker-Pool nutzen?

Für Zehntausende Items nutzen Sie einen festen Pool von Workern, die aus einer Queue ziehen. gather mit einer Semaphore funktioniert für kleine Jobs, erzeugt aber alle Tasks im Voraus und erschwert Fortsetzen und Fortschrittsverfolgung.

### Kann ich mehrere API-Schlüssel nutzen, um schneller zu sein?

Klären Sie das vorher. Die Acceptable Use Policy von BroadNet verbietet die Umgehung von Rate- oder Parallelitätslimits, fragen Sie BroadNet also, bevor Sie einen Job auf mehrere Schlüssel verteilen, um ein Limit pro Schlüssel zu umgehen. Mehr Items pro Anfrage und Plan-Sessions sind die dokumentierten Wege zu mehr Durchsatz.

### Eignet sich ein Flatrate-Plan für Batch-Jobs?

Für DeepSeek V4.1 Flash durchaus. Eine Session verarbeitet jeweils eine Anfrage ohne Token-Zähler, die Kosten sind also fix und die Frage ist die Zeit. Messen Sie die Sekunden pro Item und kaufen Sie dann genug Sessions, um innerhalb des Zeitraums fertig zu werden.

## Weiterlesen

-   [LLM-API-Fehler 429 behandeln: Backoff, Jitter und Limiter](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/)
-   [Lang laufende Agenten: Timeouts, Retries und Checkpoints, die halten](https://broadrouter.com/de/blog/long-running-agents-timeouts-retries/)
-   [Arabische Textklassifikation mit LLM: Sentiment, Intent, Triage](https://broadrouter.com/de/blog/arabic-text-classification-llm/)
-   [Parallele Coding-Agenten mit einer LLM-API-Flatrate betreiben](https://broadrouter.com/de/blog/run-parallel-coding-agents-flat-rate/)
-   [LLM-Wochenplan für kurze Projekte: Orbit vs. Stunde vs. Monat](https://broadrouter.com/de/blog/weekly-llm-plan-short-projects/)
-   [LLM-API-Kosten vor dem Launch eines Features schätzen](https://broadrouter.com/de/blog/estimate-llm-api-cost-before-launch/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: Fehlercodes von BroadNet Inference: Wann ist ein Retry sinnvoll?](https://broadrouter.com/de/guides/errors-and-retries/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: So funktionieren die unbegrenzten LLM-API-Pläne für Agenten](https://broadrouter.com/de/guides/unlimited-llm-api-sessions/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

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

**Quellen**

-   [API-Referenz von BroadNet Inference: Endpunkte, Pay-as-you-go-Limits (30 pro Minute, 4 gleichzeitig), Limits für Stundenschlüssel, Retry-Hinweise für 429 und 5xx, reasoning\_effort (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Plan-Seite von BroadNet Inference: eine Anfrage gleichzeitig pro Session, typische Geschwindigkeit, Planpreise (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Nutzungsrichtlinie (Acceptable Use Policy) von BroadNet, Abschnitte 3 und 4: keine Umgehung von Rate- oder Parallelitätslimits; Pläne nach bestem Bemühen im Rahmen fairer Nutzung (geprüft am 2026-11-15) (auf Englisch)](https://www.broadnet.ai/aup)
-   [Leitfaden zur Batch API von OpenAI: 50 % Rabatt, 24-Stunden-Fenster, 50.000 Anfragen oder 200 MB pro Batch, Ausgabereihenfolge kann abweichen, custom\_id (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/batch)
-   [Doku zur Message Batches API von Anthropic: 50 % Rabatt, 100.000 Anfragen oder 256 MB, die meisten Batches innerhalb 1 Stunde, Ablauf nach 24 Stunden (geprüft am 2026-11-15)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
