Certains travaux LLM ne sont pas des conversations. Vous avez 50 000 tickets de support à étiqueter, 200 000 descriptions de produits à traduire ou un million d’avis à noter. Des fournisseurs comme OpenAI et Anthropic vendent une Batch API pour cela. Beaucoup d’API compatibles OpenAI, dont BroadNet Inference, n’en ont pas. Cet article montre comment mener le traitement vous-même : estimer sa durée, écrire un exécuteur qui respecte les limites, et pouvoir l’arrêter et le relancer sans risque.
BroadRouter est le site de BroadNet ; les exemples chiffrés utilisent donc les limites publiées par BroadNet. La méthode fonctionne avec n’importe quelle API chat completions ; remplacez par les chiffres de votre fournisseur.
BroadNet Inference propose-t-il une Batch API ?
Non. La référence de l’API, vérifiée le 15 novembre 2026, documente POST /v1/chat/completions, POST /v1/audio/transcriptions et GET /v1/models (une liste de modèles), plus des points de terminaison de compte sous /portal/. Il n’y a ni point de terminaison de lot ou d’envoi de fichier, ni remise sur les lots. Un traitement de masse est une boucle de requêtes normales.
Voici ce qu’apporte une Batch API hébergée, pour savoir ce que vous reconstruisez :
| Batch API d’OpenAI | Message Batches d’Anthropic | Votre propre exécuteur | |
|---|---|---|---|
| Prix | 50 % de moins que le synchrone | 50 % de remise | Prix normal |
| Délai | Sous 24 heures | La plupart en moins d’1 heure ; expire après 24 | Fixé par vos limites de débit |
| Taille par lot | 50 000 requêtes ou 200 Mo | 100 000 requêtes ou 256 Mo | Toute taille |
| Limites de débit | Séparées des limites par modèle | S’appliquent aux requêtes en file | Les limites de votre clé |
| Ordre des résultats | Peut varier ; rapprochement par custom_id |
Rapprochement par custom_id |
Résultats indexés par identifiant |
Deux leçons se transposent. Les deux fournisseurs vous obligent à étiqueter chaque requête avec un identifiant, car les résultats ne reviennent pas dans l’ordre. Aucun ne promet de réponse en quelques secondes. Votre exécuteur doit fonctionner de la même façon : des identifiants partout, et un plan mesuré en heures.
Si une remise de 50 % compte plus que le délai, et que les modèles dont vous avez besoin y sont disponibles, une Batch API hébergée peut être l’outil le moins cher. Chiffrez les deux avec le calculateur de coût d’API LLM avant de construire.
Combien de temps prendra le traitement ?
Faites ce calcul avant d’écrire du code. Deux limites plafonnent le débit, et la plus lente l’emporte :
- Limite de requêtes simultanées ÷ latence. Avec 4 requêtes simultanées et 2 secondes par requête, vous en terminez 2 par seconde.
- Requêtes par minute. À 30 par minute, vous pouvez en lancer 0,5 par seconde, quelle que soit la vitesse du modèle.
Une clé BroadNet en paiement à l’usage autorise 4 requêtes simultanées et 30 par minute. Avec les valeurs de la référence de l’API au moment de notre vérification (30 par minute et 4 simultanées, le 2026-11-15), c’est la limite de débit qui bloque, sauf si chaque requête dure plus de 8 secondes ; le tableau ci-dessous utilise 30 par minute :
| Éléments | Un élément par requête | 20 éléments par requête |
|---|---|---|
| 10 000 | 5,6 heures | 17 minutes |
| 100 000 | 2,3 jours | 2,8 heures |
| 1 000 000 | 23 jours | 28 heures |
À 30 requêtes par minute, une clé traite 1 800 requêtes par heure, soit 43 200 par jour. Les nouvelles tentatives comptent aussi : chaque 429 que vous déclenchez consomme un créneau.
La deuxième colonne est le levier le plus puissant. Les éléments courts, comme des avis ou des objets de tickets, peuvent partir par 10 à 50 par requête sous forme de liste numérotée, avec un tableau JSON en retour. Vérifiez que le tableau a une entrée par élément et que chacune porte son numéro. L’article sur la classification de textes arabes montre le principe. Les éléments longs ne se regroupent pas : chaque requête doit toujours tenir dans la fenêtre de contexte du modèle, et la qualité peut baisser quand la liste s’allonge. Testez le regroupement sur 200 éléments avant de vous y fier.
Ne répartissez pas un traitement sur plusieurs clés pour dépasser une limite par clé sans demander. La politique d’utilisation acceptable de BroadNet interdit de contourner les limites de débit, de concurrence ou de budget. S’il vous en faut plus, demandez à BroadNet, ou utilisez des sessions de forfait (voir plus bas). Le planificateur de traitement par lots fait ce calcul pour votre nombre d’éléments, votre latence et vos limites.
À quoi ressemble un exécuteur reprenable ?
Cet exécuteur lit items.jsonl (un objet {"id", "text"} par ligne) et ajoute une ligne de résultat par élément à results.jsonl. Il n’a besoin que du SDK Python d’OpenAI.
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]))
Lancez-le avec python batch_run.py items.jsonl results.jsonl. Nous avons testé ce fichier tel quel contre un serveur fictif local qui renvoyait des 429 (8 %) et des 500 (5 %) au hasard et refusait tout au-delà de 4 requêtes simultanées ou de 30 départs par minute. 25 éléments ont été traités en 55 secondes avec 28 requêtes (3 nouvelles tentatives), et jamais plus de 30 départs sur une fenêtre de 60 secondes. Avec la limite du serveur fictif relevée à 300 par minute pour gagner du temps, une exécution de 120 éléments interrompue au bout de 10 secondes a repris à partir de 39 résultats enregistrés et s’est terminée avec 120 identifiants uniques, sans doublon.
Pourquoi un pool de workers et pas asyncio.gather ?
Le guide des erreurs 429 utilise un sémaphore autour de asyncio.gather. C’est très bien pour quelques centaines d’appels. Pour un gros traitement, un pool fixe de workers qui puisent dans une file est préférable :
- Mémoire.
gathercrée d’emblée une tâche par élément. Un pool ne garde que les éléments en cours. - La concurrence, c’est la taille du pool. Quatre workers ne peuvent jamais avoir cinq requêtes ouvertes.
- Les résultats partent sur le disque au fur et à mesure, dans n’importe quel ordre, indexés par identifiant.
Le Pacer gère la seconde limite. Un sémaphore seul vous empêche de dépasser 4 requêtes simultanées, mais si les requêtes prennent une seconde, quatre workers en lanceraient 240 par minute et recevraient un 429 pour la plupart. Le pacer espace les départs de 2 secondes, tous workers confondus, nouvelles tentatives comprises.
Comment les nouvelles tentatives restent-elles sûres ?
Ne relancez que ce qui peut réussir au second essai :
| Réponse | Action |
|---|---|
| 429 | Attendre puis relancer ; la documentation de BroadNet dit « use response details and bounded backoff » (traduction : « utilisez les détails de la réponse et un backoff borné ») |
| 500, 502, 503, 504, délais dépassés, connexions coupées | Relancer avec un backoff exponentiel borné |
| 400, 422 | Corriger la requête ; la relancer renvoie la même erreur |
| 401, 402, 403 | Arrêter le traitement ; la clé, le solde ou la politique demande votre attention |
| 413 | Raccourcir l’élément |
L’exécuteur désactive les nouvelles tentatives propres au SDK (max_retries=0) pour qu’il n’y ait qu’une seule politique de relance, avec un plafond visible. Le backoff est exponentiel avec gigue complète, plafonné à 60 secondes, pour que des workers qui ont échoué ensemble ne relancent pas ensemble. Après six tentatives, l’élément est écrit avec "ok": false et le traitement continue. Un élément défectueux n’arrête jamais un million d’autres.
Un appel au modèle n’a pas d’effet de bord : la livraison est ici « au moins une fois ». Si le processus meurt au milieu d’une requête, cet élément est renvoyé au redémarrage, et vous le payez deux fois. C’est le seul gaspillage. Si le traitement écrit aussi dans un autre système, comme des tickets ou des e-mails, rendez cette écriture idempotente par identifiant d’élément et faites-la dans une passe séparée sur results.jsonl. L’article sur les agents longue durée traite en détail des effets de bord idempotents.
Comment fonctionnent les points de reprise ?
Le fichier de sortie est le point de reprise. Chaque élément terminé est une ligne écrite sur disque ; après un plantage, un déploiement ou un Ctrl-C, l’exécution suivante lit le fichier, collecte les identifiants avec "ok": true et ne met en file que le reste. Les éléments qui avaient échoué sont relancés à l’exécution suivante, et leur nouvelle ligne est ajoutée. À la lecture des résultats, prenez la dernière ligne de chaque identifiant.
Trois habitudes rendent cela robuste sur plusieurs jours :
- Des identifiants stables. Utilisez une clé de base de données ou un hachage de l’entrée, jamais un numéro de ligne qui bouge quand le fichier d’entrée change.
- Vérifiez
finish_reason. Une réponse coupée àmax_tokensest"ok": truemais inutile. DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et le raisonnement compte dans max_tokens. L’exécuteur règlereasoning_effort="low", que BroadNet documente, et laisse 1 500 tokens. - Journalisez l’usage à chaque ligne. La somme des
usagederesults.jsonldonne la vraie facture en tokens, à comparer avec votre estimation.
Combien ça coûte : paiement à l’usage ou session de forfait ?
En paiement à l’usage, le coût, ce sont les tokens. Prenez 100 000 avis, un prompt système de 150 tokens, un avis de 150 tokens et 100 tokens de sortie avec un raisonnement faible. Cela fait 30 millions de tokens d’entrée et 10 millions de tokens de sortie. Sur DeepSeek V4.1 Flash, cela coûte 30 × $0.175 + 10 × $0.52. Gardez le prompt système en premier et identique à l’octet près : ses 15 millions de tokens pourront alors être facturés au tarif de l’entrée en cache, $0.0055 par million, là où le cache fonctionne. Vos lignes usage montrent à quelle fréquence c’est le cas.
Avec un forfait, les tokens sont gratuits et c’est le temps qui coûte. Une session de forfait DeepSeek V4.1 Flash « runs one request at a time » (traduction : « traite une requête à la fois ») : réglez donc IN_FLIGHT=1 par session. Le débit par session vaut 86 400 ÷ secondes par élément, par jour. BroadNet indique une vitesse typique de environ 100 tokens par seconde, mais votre latence dépend de la longueur du prompt et du raisonnement : mesurez-la sur 50 éléments. Si vous mesurez 3 secondes par élément, une session en traite 28 800 par jour :
| Traitement | Sessions | Durée à 3 s/élément | Forfait |
|---|---|---|---|
| 100 000 éléments | 1 | Environ 3,5 jours | Une semaine Orbit, $15 par session |
| 100 000 éléments | 4 | Environ 21 heures | Quatre semaines Orbit, une par session ; ou environ 21 heures Meteor par session, à $1 chacune |
| 1 000 000 éléments | 6 | Environ 6 jours | Six semaines Orbit |
Les forfaits sont fournis « best effort under fair use » (traduction : « au mieux, dans le cadre d’un usage raisonnable »), et BroadNet ne publie pas de limite de requêtes par minute pour les clés de forfait ; votre compte affiche les limites applicables. Réglez RPM à partir de celles-ci, pas au jugé. Le guide du planificateur de sessions explique comment répartir les sessions entre les clés.
Où se situe BroadNet Inference
BroadNet Inference n’a pas de Batch API : il convient aux traitements de masse quand vous préférez piloter l’exécuteur vous-même et payer les prix normaux au token, ou fixer le coût avec des sessions de forfait DeepSeek V4.1 Flash. Pour de petits traitements à petit budget, Gemma 4 VL 26B, à $0.10 en entrée et $0.22 en sortie par million, fonctionne avec le crédit de départ de $5. Les prompts et les sorties ne sont pas conservés après chaque requête. Si votre traitement peut attendre un jour et que les modèles dont vous avez besoin sont chez un fournisseur offrant 50 % de remise sur les lots, cela peut coûter moins cher ; comparez avant de vous engager. Forfaits et limites sur inference.broadnet.ai/plans.
