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. 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, 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 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-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 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 zeigt das Muster. Lange Items lassen sich nicht bündeln: Jede Anfrage muss weiterhin ins Kontextfenster 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 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 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.
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 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.
gathererzeugt 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 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 und erledigen ihn in einem separaten Durchlauf über results.jsonl. Der Beitrag zu lang laufenden Agenten 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:
- Stabile IDs. Verwenden Sie einen Datenbankschlüssel oder einen Hash des Inputs, nie eine Zeilennummer, die sich verschiebt, wenn sich die Eingabedatei ändert.
- Prüfen Sie
finish_reason. Eine beimax_tokensabgeschnittene 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. Der Runner setztreasoning_effort="low", was BroadNet dokumentiert, und lässt 1.500 Tokens Spielraum. - Loggen Sie die Nutzung pro Zeile. Die Summe von
usageausresults.jsonlergibt 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 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 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 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 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.
