Tous vos modèles.
Une seule API.
Le contrôle en plus.
Latenza unifie OpenAI, Anthropic, Mistral et Google derrière une API compatible OpenAI — avec routing intelligent, failover, budgets, guardrails et traces. Zéro code à réécrire, en prod en 5 minutes.
from openai import OpenAI
client = OpenAI(
base_url="https://gateway.latenza.ai/v1",
api_key="lz_live_...", # clé virtuelle Latenza
)
# gpt-4o, claude-sonnet-4-5, mistral-large-2, gemini-2.5-pro...
resp = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)Connectez vos providers en un clic
Le problème
Des LLMs en prod
sans plateforme, c'est risqué.
Les équipes produit arrivent toutes au même point : trop de providers, des coûts opaques et un premier incident qui aurait pu être évité.
Trop de providers, trop de SDKs
OpenAI SDK, Anthropic SDK, Mistral SDK… Chaque équipe gère son wrapper, ses retry loops, ses clés. Le moindre changement de modèle devient un chantier — et personne n'ose plus toucher au code d'intégration.
Des coûts invisibles jusqu'à la facture
Sans traces par requête ni budget par clé, les dérives de coûts ne se voient qu'en fin de mois. Un prompt mal calibré ou une boucle d'agent peut brûler votre budget en une nuit — sans alerte.
Un provider qui tombe, une feature qui casse
OpenAI a des incidents. Anthropic aussi. Sans failover automatique ni guardrails, chaque outage de provider — ou chaque réponse hors des clous — devient votre incident de prod, visible par vos utilisateurs.
La plateforme
Connectez. Contrôlez.
Construisez.
Bien plus qu'un gateway : tout ce qu'il faut entre votre produit et les providers LLM, du premier appel API au chatbot en production.
Connecter — routing intelligent
Chaque requête au bon modèle, selon vos règles
Chaque clé API porte sa stratégie de routing — cheapest, fastest, balanced ou quality — son allowlist de modèles et son budget mensuel. Latenza sélectionne le meilleur candidat à chaque appel, et bascule automatiquement si un provider tombe.
- Stratégies cheapest · fastest · balanced · quality
- Allowlist de modèles et budget par clé API
- Failover transparent en <100 ms
Contrôler — observabilité & gouvernance
Voyez exactement ce que vos LLMs coûtent
Chaque requête laisse une trace complète : coût réel, latence, tokens, provider choisi, fallbacks, métadonnées. Découpez par clé, par assistant ou par équipe. Posez des budgets et des guardrails — les dérives sont bloquées avant de coûter.
- Trace complète par requête, métadonnées incluses
- Alertes budget avant le plafond, pas après
- Guardrails input/output évalués en temps réel
Construire — assistants, RAG & chatbots
De l'API brute au chatbot sur votre site
Créez des assistants branchés sur vos documents (RAG), testez-les en A/B sur du trafic réel, puis déployez-les en widget de chat embarquable — une balise script, une clé publique, et c'est en ligne. Le tout facturé et tracé comme le reste.
- Assistants avec contextes RAG (upload de documents)
- Widget de chat embarquable, sécurisé par origine
- A/B testing et feedback utilisateur intégrés
Assistant Support
RAG · docs-produit.pdf · faq.md
Comment réinitialiser ma clé API ?
Rendez-vous dans Clés API → Régénérer. L'ancienne clé reste valide 24h pour la rotation.Source : docs-produit.pdf · p.12
<script src="https://cdn.latenza.ai/widget.js" data-key="lz_pub_…">
Failover automatique
Panne OpenAI, quota dépassé ? La requête bascule sur le provider suivant en moins de 100 ms. Vos utilisateurs ne le voient jamais.
Cache sémantique
Les requêtes sémantiquement proches sont servies depuis le cache, isolé par organisation. Réduction des coûts mesurable dès les premiers jours.
Budgets & rate limiting
Plafond mensuel en euros, quota de requêtes et allowlist de modèles par clé API. Le dépassement est bloqué côté gateway, avant l'appel provider.
Guardrails
Filtres input/output par mots, regex ou longueur — en mode blocage ou signalement. Évalués à chaque requête, y compris en streaming.
A/B testing
Comparez deux modèles ou deux prompts sur du trafic réel, mesurez coût, latence et feedback utilisateur, puis basculez sans déploiement.
Webhooks
Alertes de budget, quotas atteints, événements d'usage : recevez les signaux opérationnels directement dans vos systèmes.
Multi-tenant
Isolez chaque client ou chaque équipe dans sa propre organisation : clés, budgets, traces et facturation séparés.
Compatible OpenAI
Drop-in replacement : changez base_url et api_key dans votre client existant. Fonctionne avec le SDK openai, LangChain et LlamaIndex.
Comment ça marche
De zéro à prod
en 4 étapes.
- 01
Créez votre clé virtuelle
Inscrivez-vous, créez une organisation et générez votre première clé API — avec sa stratégie de routing, son budget et son allowlist de modèles.
- 02
Pointez votre client OpenAI
Remplacez base_url par https://gateway.latenza.ai/v1. Votre code existant — SDK openai, LangChain, LlamaIndex — fonctionne sans modification.
- 03
Posez vos règles
Guardrails, budgets, rate limits, cache sémantique : tout se configure depuis le dashboard et s'applique à la requête suivante, sans redéploiement.
- 04
Observez et construisez
Suivez coûts, latences et traces en temps réel. Puis allez plus loin : assistants RAG, A/B tests, widget de chat sur votre site.
Témoignages
Ce que disent
nos premiers utilisateurs.
On a réduit nos coûts OpenAI de 40% en activant le cache sémantique sur nos flows de support. Le budget par clé a fait le reste : plus aucune dérive silencieuse depuis trois mois.
Avant, un outage OpenAI devenait notre incident prod. Avec le failover automatique de Latenza, nos utilisateurs ne voient rien. C'est sorti de notre runbook.
Le multi-tenant nous permet d'isoler chaque client en 30 secondes, et le widget de chat se déploie avec une balise script. On a mis en ligne 3 chatbots clients dès la première semaine.
Témoignages recueillis auprès d'équipes en accès bêta.
Cas d'usage
Adapté à votre profil.
De la startup qui prototype à l'agence qui déploie des chatbots pour ses clients.
Contrôlez vos coûts LLM dès le premier appel
Un budget mensuel par clé API, le cache sémantique sur les réponses répétitives, la stratégie cheapest quand le contexte le permet. Latenza vous donne la visibilité et les garde-fous que vous n'avez pas le temps de coder vous-même.
Gouvernance et observabilité pour plusieurs squads
Une clé par squad avec quotas, budget et allowlist de modèles dédiés. Traces par feature, guardrails partagés, A/B tests sur du trafic réel, alertes de dérive par webhook. Zéro downtime grâce au failover multi-provider.
Multi-tenant et chatbots clients sans infrastructure
Une organisation par client, des assistants RAG branchés sur leurs documents, un widget de chat déployé sur leur site en une balise script. Consommation tracée et facturée par tenant — revendez de la capacité LLM sans gérer de gateway.
Comparatif
Latenza vs les alternatives.
Le feature set complet — gateway, gouvernance et outils de build — en SaaS clé en main, sans infra à opérer.
| Fonctionnalité | Latenza | LiteLLM | Portkey | OpenRouter |
|---|---|---|---|---|
| Routing multi-critères | ~ | |||
| Failover automatique | ~ | |||
| Cache sémantique | ~ | — | ||
| Budgets & rate limiting | ~ | |||
| Guardrails input/output | — | |||
| Observabilité native | ~ | ~ | ||
| Assistants & RAG intégrés | — | ~ | — | |
| Widget chat embarquable | — | — | — | |
| A/B testing | — | — | ||
| Multi-tenant | ~ | — | ||
| API OpenAI compatible | ||||
| SaaS clé en main | — |
FAQ
Questions fréquentes.
Une plateforme LLM placée entre votre application et les APIs des providers (OpenAI, Anthropic, Mistral, Google). La couche gateway gère routing, failover, cache, budgets et guardrails ; la couche produit vous permet de créer des assistants RAG, de lancer des A/B tests et de déployer des chatbots embarquables. Vous n'intégrez qu'un seul point d'entrée, compatible OpenAI.
Oui, à 100%. Latenza implémente la même interface que l'API OpenAI (chat/completions, embeddings, models). Vous changez uniquement base_url et api_key dans votre client existant — SDK openai, LangChain, LlamaIndex ou LibreChat fonctionnent tels quels. Aucune migration de code.
OpenAI (GPT-4o, GPT-4o mini…), Anthropic (Claude Sonnet, Haiku, Opus…), Mistral (Large, Small…) et Google (Gemini 2.5 Flash, Gemini 2.5 Pro…). Le catalogue complet, avec tarifs et fenêtres de contexte à jour, est publié sur la page Modèles.
Chaque clé API (ou organisation, ou assistant) porte une stratégie : cheapest minimise le coût par token, fastest privilégie la latence, quality la performance du modèle, balanced combine les trois. Latenza filtre par allowlist et fenêtre de contexte, sélectionne le meilleur candidat, et bascule automatiquement sur le suivant si un provider est indisponible.
À filtrer ce qui entre et ce qui sort de vos LLMs : règles par mots, expressions régulières ou longueur maximale, appliquées à l'entrée (avant l'appel provider) et à la sortie (y compris en streaming). Chaque règle bloque la requête ou la signale dans vos traces. Tout se configure depuis le dashboard, sans redéploiement.
Oui. Uploadez vos documents dans un contexte, liez-le à un assistant : les réponses s'appuient alors sur vos données. L'assistant peut ensuite être exposé en widget de chat embarquable sur votre site — clé publique, vérification d'origine et rate limiting par visiteur inclus.
Oui : en tant que gateway, Latenza proxie les requêtes vers les providers. Le contenu transite par notre infrastructure en Europe mais n'est pas conservé au-delà des logs d'observabilité (configurable). Les logs peuvent être désactivés en Enterprise. Nous ne réutilisons jamais vos données pour entraîner des modèles.
Vous achetez des crédits Latenza. Chaque appel LLM est débité au coût réel du provider (prix public), auquel s'ajoute la marge platform Latenza. Le détail du coût par appel, par modèle et par assistant est disponible dans votre dashboard. Les crédits non consommés sont reportés de mois en mois.