---
title: "Traitement par lots LLM sans Batch API : code et calculs"
description: "Passer 10 000 à 1 000 000 de prompts dans une API chat completions sans Batch API : concurrence, cadence, nouvelles tentatives, points de reprise et calcul du temps."
url: https://broadrouter.com/fr/blog/llm-batch-processing-without-batch-api/
lang: fr
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduit de l’anglais avec l’aide de l’IA. [Lire l’original en anglais](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) (mis à jour le 2026-11-16).

# Traitement par lots LLM sans Batch API : un exécuteur reprenable

Par l’équipe BroadNet Inference · 8 min de lecture · Publié 2026-11-15 · Mis à jour 2026-11-16

Sans Batch API, pilotez le traitement vous-même : lisez les éléments depuis un fichier JSONL, plafonnez les requêtes simultanées à la limite de la clé, cadencez les départs sous la limite par minute, relancez les 429 et 5xx avec un backoff plafonné et ajoutez chaque résultat avec son identifiant. Au redémarrage, sautez les identifiants terminés. C’est en général la limite de débit, pas le modèle, qui fixe l’heure de fin.

## À retenir

-   BroadNet Inference ne documente que les chat completions et les transcriptions. Il n’y a ni Batch API ni remise sur les lots : un traitement de masse est une boucle de requêtes ordinaires.
-   Le temps total vaut éléments ÷ le plus lent de deux débits : limite de requêtes simultanées ÷ latence, ou requêtes par minute. Une clé en paiement à l’usage autorise 4 requêtes simultanées et 30 par minute, donc un élément par requête plafonne à 43 200 par jour.
-   Écrivez une ligne de résultat par élément, indexée par identifiant, et videz le tampon. Cette ligne est le point de reprise : un plantage coûte au plus les requêtes en cours.
-   Une session de forfait traite une requête à la fois. Son débit vaut 86 400 ÷ vos secondes mesurées par élément, par jour et par session.
-   Si le travail peut attendre un jour et qu’une remise de 50 % sur les lots compte, les Batch API d’OpenAI et d’Anthropic peuvent être l’outil le moins cher. Chiffrez les deux.

**Sur cette page**

1.  BroadNet Inference propose-t-il une Batch API ?
2.  Combien de temps prendra le traitement ?
3.  À quoi ressemble un exécuteur reprenable ?
4.  Pourquoi un pool de workers et pas asyncio.gather ?
5.  Comment les nouvelles tentatives restent-elles sûres ?
6.  Comment fonctionnent les points de reprise ?
7.  Combien ça coûte : paiement à l’usage ou session de forfait ?
8.  Où se situe BroadNet Inference

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](https://broadrouter.com/fr/glossary/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](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-batch-processing-without-batch-api&utm_content=body), 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](https://broadrouter.com/tools/llm-api-cost-calculator/) 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](https://broadrouter.com/fr/glossary/pay-as-you-go/) 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](https://broadrouter.com/fr/glossary/rate-limit/) 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](https://broadrouter.com/fr/blog/arabic-text-classification-llm/) montre le principe. Les éléments longs ne se regroupent pas : chaque requête doit toujours tenir dans la [fenêtre de contexte](https://broadrouter.com/fr/glossary/context-window/) 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](https://www.broadnet.ai/aup) 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](https://broadrouter.com/tools/llm-batch-job-planner/) 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.

```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]))
```

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](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/) 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.** `gather` cré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](https://broadrouter.com/fr/glossary/exponential-backoff/) 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](https://broadrouter.com/fr/glossary/idempotency-key/) 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](https://broadrouter.com/fr/blog/long-running-agents-timeouts-retries/) 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 :

1.  **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.
2.  **Vérifiez `finish_reason`.** Une réponse coupée à `max_tokens` est `"ok": true` mais inutile. DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et [le raisonnement compte dans max\_tokens](https://broadrouter.com/fr/guides/reasoning-tokens-empty-response/). L’exécuteur règle `reasoning_effort="low"`, que BroadNet documente, et laisse 1 500 tokens.
3.  **Journalisez l’usage à chaque ligne.** La somme des `usage` de `results.jsonl` donne 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](https://broadrouter.com/fr/models/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](https://broadrouter.com/fr/blog/cached-input-tokens-explained/), $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](https://broadrouter.com/fr/guides/unlimited-llm-api-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](https://broadrouter.com/fr/models/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](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-batch-processing-without-batch-api&utm_content=body).

Outils gratuits sur ce sujet (en anglais)

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

[Outils gratuits (en anglais)](https://broadrouter.com/tools/)

## Termes de cet article

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

Un token est l’unité de texte qu’un modèle de langage lit et écrit : un mot, une partie de mot, un signe de ponctuation ou une suite d’octets produite par le tokenizer du modèle. Les API LLM comptent, limitent et facturent généralement l’usage en tokens.

[API batch (traitement par lots)](https://broadrouter.com/fr/glossary/batch-api/)

Une API batch est un endpoint LLM asynchrone qui accepte de nombreuses requêtes d’un coup, généralement sous forme de fichier, les traite dans une fenêtre définie plutôt qu’immédiatement et renvoie les résultats ensemble. Des fournisseurs comme OpenAI et Anthropic facturent les requêtes batch avec une remise par rapport à leurs API standard.

[Concurrence (requêtes simultanées)](https://broadrouter.com/fr/glossary/concurrency/)

La concurrence est le nombre de requêtes qu’un client a en cours au même moment. Les API de LLM la plafonnent souvent par clé ou par forfait, indépendamment des requêtes par minute, car chaque requête ouverte occupe de la capacité GPU jusqu’à la fin de sa réponse.

[Limite de débit (rate limit)](https://broadrouter.com/fr/glossary/rate-limit/)

Une limite de débit (rate limit) est un plafond qu’une API impose à l’usage d’un client sur une période, par exemple en requêtes ou en tokens par minute. Les requêtes au-delà sont refusées, généralement avec HTTP 429 Too Many Requests, jusqu’à ce que l’usage repasse sous la limite.

[Paiement à l’usage (pay-as-you-go)](https://broadrouter.com/fr/glossary/pay-as-you-go/)

Le paiement à l’usage (pay-as-you-go) est un modèle tarifaire où vous ne payez que ce que vous consommez, mesuré par unité, comme les tokens, les requêtes ou les minutes d’audio, sans abonnement ni engagement minimal. La plupart des API LLM facturent ainsi, à partir d’un solde prépayé ou d’une facture périodique.

[Débit (throughput)](https://broadrouter.com/fr/glossary/throughput/)

Le débit (throughput), dans le service de LLM, est la quantité totale de travail qu’un système accomplit par unité de temps sur toutes les requêtes simultanées, généralement mesurée en tokens de sortie par seconde ou en requêtes par seconde. Il se distingue de la vitesse par flux, c’est-à-dire la vitesse à laquelle une seule requête reçoit ses tokens.

[Latence (LLM)](https://broadrouter.com/fr/glossary/latency/)

Pour une API de modèle de langage, la latence est le temps que prend une requête entre son envoi et la réception du dernier token de sortie. C’est la somme du time to first token et du temps de génération, généralement exprimée en percentiles comme le p50 et le p95 plutôt qu’en moyenne.

[Tokens d’entrée et de sortie](https://broadrouter.com/fr/glossary/input-and-output-tokens/)

Les tokens d’entrée sont les tokens qu’un modèle de langage lit dans une requête, dont le prompt système, l’historique de conversation, les définitions d’outils et les images. Les tokens de sortie sont ceux qu’il génère en réponse, raisonnement compris. Les API LLM les facturent généralement séparément, et la sortie coûte en général plus cher.

## Questions fréquentes

### BroadNet Inference propose-t-il une Batch API ?

Non. Sa référence d’API, vérifiée le 15 novembre 2026, documente POST /v1/chat/completions, POST /v1/audio/transcriptions et GET /v1/models, sans point de terminaison de lot ni d’envoi de fichier, et sans remise sur les lots. Lancez les traitements de masse comme des requêtes ordinaires dans les limites de votre clé.

### Comment traiter 100 000 prompts avec une API LLM ?

Placez les éléments dans un fichier JSONL, chacun avec un identifiant. Lancez un nombre fixe de workers égal à la limite de requêtes simultanées de la clé, cadencez les départs sous la limite par minute, relancez les 429 et 5xx avec un backoff plafonné, et ajoutez chaque résultat à un fichier de sortie indexé par identifiant pour pouvoir reprendre.

### Combien de temps prend un lot d’un million de requêtes ?

Divisez le nombre d’éléments par votre débit réel. À 30 requêtes par minute et un élément par requête, une clé en traite 43 200 par jour : un million prend donc environ 23 jours. Regrouper 20 éléments courts par requête ramène cela à environ 28 heures, si le modèle gère bien le prompt plus long.

### Faut-il utiliser asyncio.gather ou un pool de workers pour des appels LLM par lots ?

Pour des dizaines de milliers d’éléments, utilisez un pool fixe de workers qui puisent dans une file. gather avec un sémaphore convient aux petits traitements, mais il crée toutes les tâches d’emblée et complique la reprise et le suivi de progression.

### Puis-je utiliser plusieurs clés API pour aller plus vite ?

Vérifiez d’abord. La politique d’utilisation acceptable de BroadNet interdit de contourner les limites de débit ou de concurrence : demandez donc à BroadNet avant de répartir un traitement sur plusieurs clés pour dépasser une limite par clé. Regrouper plus d’éléments par requête et les sessions de forfait sont les moyens documentés d’augmenter le débit.

### Un forfait convient-il aux traitements par lots ?

Oui, pour DeepSeek V4.1 Flash. Une session traite une requête à la fois sans compteur de tokens : le coût est fixe et la question devient le temps. Mesurez les secondes par élément, puis achetez assez de sessions pour finir dans la période.

## À lire ensuite

-   [Gérer les erreurs 429 d’une API LLM : backoff, jitter et limiteurs](https://broadrouter.com/fr/blog/handle-llm-api-429-rate-limits/)
-   [Agents de longue durée : timeouts, retries et checkpoints qui tiennent](https://broadrouter.com/fr/blog/long-running-agents-timeouts-retries/)
-   [Classification de texte arabe par LLM : sentiment, intention, tri](https://broadrouter.com/fr/blog/arabic-text-classification-llm/)
-   [Lancer des agents de code en parallèle sur une API LLM au forfait](https://broadrouter.com/fr/blog/run-parallel-coding-agents-flat-rate/)
-   [Forfait LLM à la semaine pour projets courts : Orbit, heure ou mois](https://broadrouter.com/fr/blog/weekly-llm-plan-short-projects/)
-   [Estimer le coût d’une API LLM avant de lancer une fonctionnalité](https://broadrouter.com/fr/blog/estimate-llm-api-cost-before-launch/)
-   [Matériel GPU et serving de BroadNet, tels que BroadNet les décrit](https://broadrouter.com/fr/blog/broadnet-gpu-fleet-and-serving/)
-   [Mettre en cache les réponses d’API LLM : un cache exact en Python](https://broadrouter.com/fr/blog/cache-llm-responses-cut-cost/)
-   [Guide : Codes d’erreur de BroadNet Inference : quand réessayer ?](https://broadrouter.com/fr/guides/errors-and-retries/)
-   [Guide : Utiliser le SDK Python d’OpenAI avec BroadNet Inference](https://broadrouter.com/fr/guides/openai-python-sdk/)
-   [Guide : Comment fonctionnent les forfaits API LLM illimités pour agents](https://broadrouter.com/fr/guides/unlimited-llm-api-sessions/)

Essayez-le sur votre vraie charge de travail. Les nouveaux comptes démarrent avec USD 5 de crédit pour Gemma et transcription. DeepSeek, GLM et Qwen3.8 nécessitent une recharge.

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

**Sources**

-   [Référence de l’API BroadNet Inference : points de terminaison, limites du paiement à l’usage (30 par minute, 4 simultanées), limites des clés horaires, consignes de nouvelle tentative pour 429 et 5xx, reasoning\_effort (vérifié le 15/11/2026) (en anglais)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Page des forfaits BroadNet Inference : une requête à la fois par session, vitesse typique, prix des forfaits (vérifié le 15/11/2026) (en anglais)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=fr-blog-llm-batch-processing-without-batch-api&utm_content=sources)
-   [Politique d’utilisation acceptable de BroadNet, sections 3 et 4 : pas de contournement des limites de débit ou de concurrence ; forfaits fournis au mieux dans le cadre d’un usage raisonnable (vérifié le 15/11/2026) (en anglais)](https://www.broadnet.ai/aup)
-   [Guide de la Batch API d’OpenAI : remise de 50 %, fenêtre de 24 h, 50 000 requêtes ou 200 Mo par lot, ordre de sortie variable, custom\_id (vérifié le 15/11/2026)](https://developers.openai.com/api/docs/guides/batch)
-   [Documentation de l’API Message Batches d’Anthropic : remise de 50 %, 100 000 requêtes ou 256 Mo, la plupart des lots en moins d’1 heure, expiration après 24 heures (vérifié le 15/11/2026)](https://platform.claude.com/docs/en/build-with-claude/batch-processing)
