BroadRouter

Un endpoint privé commence par une charge de travail bien définie

Par l’équipe BroadNet Inference · 7 min de lecture · Publié

Avant de demander un endpoint privé, décrivez la charge de travail : requêtes par jour et en pointe, tokens en entrée et en sortie, la concurrence qui en découle, le contexte nécessaire, la région de traitement, le modèle et sa licence, et un budget. Convenez par écrit de la région et des limites, puis testez l’endpoint fourni avant d’y envoyer de vraies données.

« Il nous faut un endpoint dédié » est le début d’une conversation, pas une spécification. Sans vos chiffres, le fournisseur ne peut ni dimensionner, ni placer, ni chiffrer la capacité, et sans eux vous ne pouvez pas non plus juger sa réponse. Cet article liste ce qu’il faut définir avant de demander, à l’aide d’un exemple chiffré d’extraction de factures, et se termine par un script qui vérifie l’endpoint qu’on vous fournit.

Il vaut pour tout fournisseur. Lorsqu’il décrit l’offre de BroadNet, il s’en tient à ce que BroadNet dit publiquement, vérifié le 15 novembre 2026. Tout le reste est une question à poser à BroadNet.

Quand un endpoint privé a-t-il du sens ?

En général, pour l’une de quatre raisons :

  • Un trafic au-delà des limites du libre-service. La référence de l’API BroadNet publie 30 requêtes par minute et 4 requêtes en cours pour une clé en paiement à l’usage. Une charge régulière au-delà relève de la capacité, pas des relances. (Gérer les erreurs 429 couvre les pics courts.)
  • Un modèle absent de la liste publique. Le catalogue de BroadNet marque certains modèles « available on request » (disponible sur demande), dont Qwen3-VL 30B-A3B, Qwen3-VL 8B et une version de Cohere Transcribe Arabic affinée par BroadNet. Lire un catalogue de modèles explique la différence.
  • Un lieu de traitement que vous devez maîtriser. Les règles de résidence des données, comme celles de la checklist PDPL pour l’Arabie saoudite et les Émirats, peuvent exiger une région convenue par écrit.
  • Une latence prévisible. Une capacité partagée varie avec la charge des autres utilisateurs. Une capacité réservée supprime cette variable, mais pas la distance réseau ni la taille de vos propres prompts.

Si aucune de ces raisons ne s’applique, une clé en libre-service est plus simple. Et si votre volume est très élevé et régulier, comparez avec l’auto-hébergement : auto-hébergement ou coût d’API donne la méthode.

Que faut-il définir sur la charge de travail ?

Rédigez une note d’une page. Voici les chiffres dont un fournisseur a besoin :

Élément Ce qu’il faut noter Exemple
Tâche Ce que fait le modèle, en une phrase Lire des photos de factures, renvoyer des champs JSON
Volume Requêtes par jour, et la part pendant l’heure la plus chargée 40 000 par jour, 15 % à l’heure de pointe
Tokens Tokens en entrée et en sortie, en moyenne et au 95e centile 1 800 en entrée (une image de page + prompt), 350 en sortie
Contexte Plus grosse requête unique, prompt et réponse compris 4 000 tokens
Latence Délai acceptable jusqu’au premier token et jusqu’à la réponse complète Réponse complète en moins de 10 secondes
Streaming Nécessaire ou non Non nécessaire (de type batch)
Entrées Texte, images, audio ; formats et tailles JPEG et PNG, une page chacun
Langues Lesquelles, et la part de chacune Arabe et anglais, 60/40
Croissance Volume attendu à 6 et 12 mois Doublement en 12 mois

Mesurez les nombres de tokens sur de vrais échantillons, pas sur des estimations. L’arabe demande souvent plus de tokens que l’anglais pour le même texte ; le compteur de tokens arabe et le coût réel par langue montrent de combien selon les tokenizers. Pour les images, le calculateur de tokens d’image donne une première estimation.

Comment convertir un volume en tokens par seconde et en concurrence ?

Les requêtes par seconde en pointe correspondent au volume de l’heure la plus chargée divisé par 3 600. La concurrence, c’est-à-dire le nombre de requêtes en cours à un instant donné, découle de la loi de Little : le nombre moyen d’éléments dans un système est égal au taux d’arrivée multiplié par le temps moyen que chacun y passe. Pour une API, cela donne requêtes par seconde × secondes par requête.

import math

def size(requests_per_day: int, peak_share_of_day_in_busiest_hour: float,
         in_tokens: int, out_tokens: int, out_tok_per_s_per_stream: float) -> dict:
    """Rough peak numbers to put in a capacity enquiry. Measure your own inputs; these are not provider specs."""
    peak_rps = requests_per_day * peak_share_of_day_in_busiest_hour / 3600
    seconds_per_request = out_tokens / out_tok_per_s_per_stream        # ignores queueing and prompt time
    concurrency = peak_rps * seconds_per_request                      # Little's law: L = λ × W
    return {
        "peak_requests_per_second": round(peak_rps, 2),
        "seconds_per_request": round(seconds_per_request, 1),
        "concurrent_requests_at_peak": math.ceil(concurrency),
        "peak_input_tokens_per_second": round(peak_rps * in_tokens),
        "peak_output_tokens_per_second": round(peak_rps * out_tokens),
        "monthly_tokens_millions": round(requests_per_day * 30 * (in_tokens + out_tokens) / 1e6, 1),
    }

# 40,000 invoice extractions a day, 15% of them in the busiest hour,
# 1,800 tokens in, 350 out, 60 tokens/s per stream measured on a trial.
print(size(40_000, 0.15, 1_800, 350, 60))

Le script a affiché 1,67 requête par seconde en pointe, environ 5,8 secondes par requête, 10 requêtes simultanées, 3 000 tokens d’entrée et 583 tokens de sortie par seconde, et 2 580 millions de tokens par mois. Les 60 tokens par seconde sont une hypothèse pour l’exemple ; mesurez votre propre valeur sur le modèle que vous utiliserez, car la vitesse varie selon le modèle, la longueur du prompt et la charge. L’article sur la latence, le TTFT et le débit explique quoi chronométrer.

Deux mises en garde. La formule ignore le temps de traitement du prompt : des prompts longs ou de grandes images rendent les vraies requêtes plus lentes et font monter la concurrence. Et les moyennes masquent les pics : donnez au fournisseur la taille de requête au 95e centile et un court profil de pic, pas seulement la moyenne. La pointe de cet exemple (environ 100 requêtes par minute et 10 en cours) dépasse largement les limites publiées du libre-service pour une seule clé en paiement à l’usage, et c’est précisément là qu’une discussion sur la capacité vaut la peine.

Et la région, la résidence des données et les limites ?

Convenez-en explicitement, par écrit, avant que des données réglementées ne circulent. Les Conditions d’utilisation de BroadNet (§7.3a) indiquent : « Contact us to agree processing locations for your deployment before sending data with residency requirements » (traduction : « Contactez-nous pour convenir des lieux de traitement de votre déploiement avant d’envoyer des données soumises à des exigences de résidence »), et précisent que l’hébergement chez des partenaires et le traitement de secours font intervenir d’autres sous-traitants, dont une liste à jour est communiquée aux clients sur demande. Sa déclaration de confidentialité indique que les modèles propres de BroadNet et les modèles open-weight qu’il héberge tournent sur du matériel détenu ou loué par BroadNet aux États-Unis, avec de la capacité partenaire en secours, et sa page de présentation indique qu’un traitement régional dans la région MENA ou en Europe est disponible sur demande.

Les questions à poser à tout fournisseur sont donc :

  1. Quelle région traite les requêtes, et quelle région héberge la capacité de secours ?
  2. Quels sous-traitants peuvent avoir accès au trafic, y compris en cas de bascule ou de débordement ?
  3. Quelles sont les limites de débit, de concurrence et de tokens de l’endpoint, et que se passe-t-il au-delà ?
  4. Quelles conditions de disponibilité et de support s’appliquent, et où sont-elles écrites ? Les Conditions d’utilisation de BroadNet (§7.4) indiquent que le libre-service n’a aucun engagement de disponibilité, et que les endpoints privés et la capacité réservée relèvent de votre accord écrit distinct. Pour voir ce que couvrent les SLA écrits d’autres fournisseurs, lisez les SLA des API LLM comparés.
  5. Qu’est-ce qui est conservé ? Pour l’API d’inférence de BroadNet, la position publiée est la suivante : le contenu d’inférence n’est pas conservé ; les métadonnées nécessaires de compte, de facturation et de sécurité sont conservées comme le décrit sa déclaration de confidentialité. Faites confirmer qu’il en va de même pour votre endpoint.

Quel modèle, et sous quelle licence ?

Nommez le modèle et la version exacts, et vérifiez que sa licence autorise votre usage et le service par API. Les pages modèles de BroadNet indiquent Apache-2.0 pour Gemma 4 26B, Qwen3-VL 30B-A3B et les poids de base de Cohere Transcribe, la version de Cohere Transcribe Arabic affinée par BroadNet étant « under contract » (sous contrat). Ses Conditions d’utilisation précisent que les modèles sont régis par leurs licences, et que la licence de DeepSeek V4.1 Flash s’applique toujours lorsqu’il est hébergé chez un partenaire.

Convenez aussi de la fenêtre de contexte. Les limites de contexte dépendent du modèle et du déploiement, pas seulement du maximum du modèle de base : BroadNet indique 32K tokens pour Gemma 4 VL 26B sur son API publique et 16K pour Qwen3-VL 30B-A3B, disponible sur demande. Utilisez le calculateur de fenêtre de contexte avec votre plus grosse requête, pas avec la moyenne.

Comment fixer un budget ?

BroadNet ne publie pas de prix pour les endpoints privés ; sa page de présentation dit « Reserved GPU, priced to your traffic. Ask for a quote. » (traduction : « GPU réservé, tarifé selon votre trafic. Demandez un devis. ») Fixez donc d’abord votre propre plafond. Chiffrez la même charge en libre-service avec le calculateur de coût d’API LLM, à partir du nombre mensuel de tokens donné par le script de dimensionnement, et décidez ce que valent en plus pour vous une capacité prévisible, une région ou un modèle non public. Un devis inférieur au chiffre du libre-service est un bonus ; un devis bien au-dessus doit se justifier par votre liste d’exigences.

Comment envoyer la demande ?

La référence de l’API BroadNet indique : « Private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint. » (traduction : « Les endpoints privés, nos modèles arabes affinés et les autres modèles sur demande sont accessibles via un identifiant privé fourni avec l’endpoint. ») Sa page de présentation demande « your model, languages and traffic requirements » (traduction : « votre modèle, vos langues et vos besoins de trafic »). Envoyez votre note d’une page via la page de contact, sans clé d’API ni données client. Joignez la sortie du dimensionnement, la région, le modèle et la licence, l’objectif de latence, votre plafond budgétaire et votre calendrier.

Comment valider l’endpoint qu’on vous fournit ?

Avant d’y envoyer le trafic de production, testez l’endpoint par rapport à ce qui a été convenu. Ce script n’utilise que la bibliothèque standard de Python. Il vérifie que l’identifiant de modèle privé fonctionne, que le streaming se termine par le marqueur data: [DONE] décrit dans la documentation de BroadNet, que la concurrence convenue passe sans 429 et qu’un mauvais identifiant de modèle est refusé.

import json, os, sys, time, urllib.error, urllib.request
from concurrent.futures import ThreadPoolExecutor

BASE = os.environ["ENDPOINT_BASE_URL"].rstrip("/")    # from your agreement, e.g. https://.../v1
KEY = os.environ["ENDPOINT_API_KEY"]
MODEL = os.environ["ENDPOINT_MODEL_ID"]                # the private ID issued with the endpoint
AGREED_CONCURRENCY = int(os.environ.get("AGREED_CONCURRENCY", "4"))

def post(payload: dict, stream=False):
    req = urllib.request.Request(f"{BASE}/chat/completions", data=json.dumps(payload).encode(),
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"})
    t0 = time.monotonic()
    try:
        with urllib.request.urlopen(req, timeout=120) as r:
            body = r.read().decode()
            return r.status, r.headers.get("X-Request-ID"), body, time.monotonic() - t0
    except urllib.error.HTTPError as e:
        return e.code, e.headers.get("X-Request-ID"), e.read().decode(), time.monotonic() - t0

def main() -> int:
    msg = [{"role": "user", "content": "Reply with the word OK."}]
    results = {}
    code, rid, body, secs = post({"model": MODEL, "messages": msg, "max_tokens": 1000})
    ok = code == 200 and "usage" in json.loads(body)
    results["model_id_accepted"] = (ok, f"HTTP {code}, request ID {rid}, {secs:.2f}s")
    code, _, body, _ = post({"model": MODEL, "messages": msg, "stream": True,
                             "stream_options": {"include_usage": True}})
    results["stream_ends_with_DONE"] = (code == 200 and body.rstrip().endswith("data: [DONE]"), f"HTTP {code}")
    with ThreadPoolExecutor(AGREED_CONCURRENCY) as pool:
        codes = list(pool.map(lambda _: post({"model": MODEL, "messages": msg, "max_tokens": 1000})[0],
                              range(AGREED_CONCURRENCY)))
    results["agreed_concurrency_no_429"] = (all(c == 200 for c in codes), f"codes {sorted(codes)}")
    code, _, _, _ = post({"model": MODEL + "-typo", "messages": msg})
    results["unknown_model_rejected"] = (code in (400, 403, 404), f"HTTP {code}")
    for name, (passed, note) in results.items():
        print(f"{'PASS' if passed else 'FAIL'}  {name}: {note}")
    return 0 if all(p for p, _ in results.values()) else 1

if __name__ == "__main__":
    sys.exit(main())

Nous l’avons exécuté contre un serveur fictif local (pas un vrai endpoint) qui autorise 8 requêtes en cours. Avec AGREED_CONCURRENCY=8, les quatre vérifications ont réussi. Avec 12, la vérification de concurrence a échoué avec huit 200 et quatre 429, ce qui est exactement le résultat qu’on veut voir avant le lancement plutôt qu’après. max_tokens=1000 laisse de la marge aux modèles de raisonnement, qui consomment une partie du budget avant de répondre.

Après ce test rapide, lancez un court test de charge à votre pointe mesurée avec des prompts de taille réelle, et relevez le délai jusqu’au premier token et la latence jusqu’à la réponse complète de l’endpoint. Gardez les ID de requête ; la documentation de BroadNet demande le X-Request-ID, l’horodatage, la route et le statut dans les demandes de support.

La place de BroadNet Inference

BroadRouter est le site de BroadNet. BroadNet Inference vend un accès en libre-service à des modèles publics au token, à la minute d’audio, par session de forfait et par clé horaire ; les prix sont sur la page des tarifs. Les endpoints privés, le traitement régional, les modèles affinés et les modèles listés « on request » ne sont pas en libre-service : ce sont des demandes que BroadNet chiffre et convient par écrit. Cet article ne peut pas vous dire ce que BroadNet proposera pour votre charge de travail. Une note claire est le moyen de le savoir.

Questions fréquentes

Qu’est-ce qu’un endpoint LLM privé ?

Un endpoint d’API adossé à une capacité réservée à un seul client, au lieu d’être partagée avec tous les utilisateurs en libre-service. BroadNet décrit sa version comme un GPU ou un nœud réservé avec le modèle de votre choix, vos propres clé et limites et la région dont vous avez besoin, accessible via un identifiant de modèle privé.

Comment estimer la concurrence dont j’ai besoin ?

Avec la loi de Little : requêtes simultanées = requêtes par seconde en pointe × secondes par requête. 1,67 requête par seconde à environ 5,8 secondes chacune donne environ 10 requêtes en cours. Mesurez les secondes par requête sur le vrai modèle avec vos vrais prompts.

Puis-je acheter un endpoint privé BroadNet en libre-service ?

Non. BroadNet présente les endpoints privés, le traitement régional et les modèles non listés comme des demandes : vous décrivez la charge de travail et BroadNet fait un devis. Ses Conditions d’utilisation précisent que les endpoints privés et la capacité réservée relèvent d’un accord écrit distinct.

Un endpoint privé est-il assorti d’un SLA ?

Seulement si votre accord écrit le prévoit. Les Conditions d’utilisation de BroadNet indiquent que l’offre en libre-service n’a aucun engagement de disponibilité et que des niveaux de service n’existent que dans un accord écrit distinct. Demandez les termes exacts avant de vous y fier.

Où mes données seront-elles traitées ?

Convenez-en avant d’envoyer des données. Les Conditions d’utilisation de BroadNet demandent aux clients soumis à des exigences de résidence de convenir d’abord des lieux de traitement, et indiquent que l’hébergement chez des partenaires et le traitement de secours font intervenir d’autres sous-traitants, dont la liste est communiquée aux clients sur demande.

Lire en MarkdownDemander à ChatGPTDemander à ClaudeDemander à Perplexity