---
title: "Routage entre modèles et maîtrise du coût"
description: "Envoyer chaque demande au modèle qui suffit, et suivre la facture."
url: https://meridal.fr/apprendre/routage-entre-modeles/
language: fr
written: 2026-10-09
verified: 2026-10-09
license: CC BY 4.0
---

[Apprendre](https://meridal.fr/apprendre/) › [Construction et programmation](https://meridal.fr/apprendre/dossier/construire/)

Comprendre · Niveau 3, Construire · 14 minutes

# Routage entre modèles et maîtrise du coût

Chez un même éditeur, le prix d'un modèle va de 1 à 100. Envoyer chaque demande au plus petit modèle qui suffit divise la facture, à condition de mesurer ce qui suffit. Les trois façons de router, les outils qui le font, un exemple chiffré et les pièges.

Écrit le 9 octobre 2026 · Vérifié le 9 octobre 2026

## Vous saurez

- Savoir pourquoi un seul modèle pour tout coûte trop cher ou rend trop peu
- Distinguer une règle fixe, une cascade et un routeur tout fait
- Chiffrer le gain d'un routage sur vos volumes
- Repérer ce que coûte un routeur : qualité, frais, données

## Dans le parcours

[Développement d'applications d'IA](https://meridal.fr/apprendre/parcours/dev-avance/)

Étape 9 sur 10

- [← Avant Premier appel à un modèle](https://meridal.fr/apprendre/premier-appel/)
- [↑ Plus général Coût d'un outil d'IA en service](https://meridal.fr/apprendre/cout-d-un-outil-d-ia-en-service/)
- [↓ Plus concret Réponse dans un format imposé](https://meridal.fr/apprendre/format-impose/)
- [→ Ensuite Projet : une application déployée en Europe avec connexion d'entreprise](https://meridal.fr/apprendre/projet-application-en-europe/)

L'essentiel

1. Chez OpenAI comme chez Anthropic, le prix d'entrée va de 0,10 $ à 10 $ le million de tokens : un rapport de 1 à 100, calculé sur leurs grilles.
2. Router, c'est envoyer chaque demande au plus petit modèle qui la réussit : un classement à un petit modèle, une réponse délicate à un modèle plus fort.
3. Trois façons : une règle fixe par type de demande ; une cascade, qui essaie le petit modèle et remonte s'il échoue ; un routeur tout fait, comme celui de Microsoft Foundry ou d'OpenRouter.
4. Sur notre exemple, 70 % de demandes simples envoyées à un petit modèle font passer la facture de 149,60 $ à 51,04 $ par mois, tri compris.
5. Ce qui « suffit » se mesure, sur vos cas : sans jeu de tests, le routage économise en silence sur la qualité.

## Problème

Un outil d'IA reçoit des demandes très différentes : classer un courriel, extraire un montant, rédiger une réponse délicate, analyser un dossier de quatre-vingts pages. Avec un seul modèle pour tout, il faut choisir : un grand modèle, qui réussit tout mais fait payer le prix fort aux demandes faciles ; ou un petit, bon marché, qui échoue sur les difficiles.

L'écart n'est pas marginal. Chez OpenAI, GPT-6 Astra coûte 10 $ le million de tokens lus, GPT-6 Luna 0,10 $ ; chez Anthropic, de Claude Fable 5.1 à Claude Haiku 5.5, le même écart de 1 à 100. Le coût d'un outil en service se joue d'abord là : [ce que coûte un outil d'IA en service](https://meridal.fr/apprendre/cout-d-un-outil-d-ia-en-service/).

## Principe

Avant de regarder : sur cent demandes reçues par un service client, combien demandent vraiment le meilleur modèle ?

![Le routage entre modèles. La demande, un courriel à classer ou une réponse à rédiger, passe par le tri : une règle, ou un petit modèle qui classe. Le tri l'envoie à un petit modèle, pour classer, extraire ou résumer court, à 0,10 dollar le million de tokens lus ; à un modèle intermédiaire, pour rédiger ou répondre à un client, de 0,75 à 2 dollars ; ou à un grand modèle, pour raisonner sur un dossier difficile, de 4 à 10 dollars. Si le modèle échoue ou hésite, la demande remonte au suivant. Chaque passage note le modèle choisi, les tokens et le coût.](https://meridal.fr/assets/apprendre/medias/apprendre-routage.svg)

Souvent peu. Le principe du routage tient en une ligne : chaque demande va au plus petit modèle qui la réussit. Un tri décide, par une règle ou par un petit modèle qui classe ; ce qui échoue ou hésite remonte au modèle suivant ; et chaque passage laisse une trace, pour vérifier que l'économie ne se paie pas en erreurs.

## Fonctionnement

Trois façons de router

- Une règle fixe le type de demande est connu d'avance : le formulaire, la boîte de réception, l'étape de l'automatisation le disent **Ce qu'elle apporte :** le plus simple, le plus prévisible, rien à payer pour le tri **Sa limite :** ne s'adapte pas à une demande inhabituelle
- Une cascade on essaie le petit modèle ; si sa réponse échoue à un contrôle, ou s'il dit ne pas savoir, la demande remonte au suivant **Ce qu'elle apporte :** le petit modèle traite tout ce qu'il sait faire **Sa limite :** le contrôle doit être fiable ; une demande remontée coûte deux appels
- Un routeur tout fait un service choisit le modèle à chaque demande : le model router de Microsoft Foundry, entraîné pour cela ; l'Auto Router d'OpenRouter **Ce qu'elle apporte :** rien à construire **Sa limite :** ses critères ne sont pas les vôtres ; il faut mesurer sur vos cas

Les outils qui routent

| Microsoft Foundry, model router | Un modèle entraîné qui choisit, à chaque demande, parmi des modèles sous-jacents ; trois modes : Balanced par défaut, qui reste à 1 ou 2 % de la meilleure qualité, Cost, à 5 ou 6 %, et Quality ; un sous-ensemble de modèles au choix. Version 2025-11-18, mise à jour en place. |
|---|---|
| OpenRouter, Auto Router | Le modèle « openrouter/auto » classe la demande parmi une trentaine de types de tâches et classe les modèles selon leur part des dépenses de la communauté sur sept jours ; cinq niveaux de coût, de low à max ; pas de frais en plus du modèle choisi. |
| LiteLLM | Une passerelle libre, à installer chez soi, qui parle à plus de cent modèles dans le format d'OpenAI : répartition de charge, replis vers un autre fournisseur, nouvelles tentatives ; des budgets par clé et par équipe. Licence MIT, sauf un dossier « enterprise » sous licence commerciale ; version 1.104.2. |

*Documentation des éditeurs, lue le 8 et le 9 octobre 2026, en anglais.*

Le code, tel que les documentations le donnent, noms de modèles compris.

LiteLLM OpenRouter

Plusieurs déploiements derrière un même nom de modèle ; la passerelle répartit les demandes et se replie en cas d'erreur.

`Le routeur de LiteLLM, extrait de la documentation`

```
from litellm import Router

model_list = [{ # list of model deployments
	"model_name": "gpt-5.6-luna", # model alias -> loadbalance between models with same `model_name`
	"litellm_params": { # params for litellm completion/embedding call
		"model": "azure/chatgpt-v-2", # actual model name
		"api_key": os.getenv("AZURE_API_KEY"),
		"api_version": os.getenv("AZURE_API_VERSION"),
		"api_base": os.getenv("AZURE_API_BASE")
	}
}, {
    "model_name": "gpt-5.6-luna",
	"litellm_params": { # params for litellm completion/embedding call
		"model": "azure/chatgpt-functioncalling",
		"api_key": os.getenv("AZURE_API_KEY"),
		"api_version": os.getenv("AZURE_API_VERSION"),
		"api_base": os.getenv("AZURE_API_BASE")
	}
}, {
    "model_name": "gpt-5.6-luna",
	"litellm_params": { # params for litellm completion/embedding call
		"model": "gpt-5.6-luna",
		"api_key": os.getenv("OPENAI_API_KEY"),
	}
}, {
    "model_name": "gpt-5.6-terra",
	"litellm_params": { # params for litellm completion/embedding call
		"model": "azure/gpt-5.6-terra",
		"api_key": os.getenv("AZURE_API_KEY"),
		"api_base": os.getenv("AZURE_API_BASE"),
		"api_version": os.getenv("AZURE_API_VERSION"),
	}
}, {
    "model_name": "gpt-5.6-terra",
	"litellm_params": { # params for litellm completion/embedding call
		"model": "gpt-5.6-terra",
		"api_key": os.getenv("OPENAI_API_KEY"),
	}
},

]

router = Router(model_list=model_list)

# openai.ChatCompletion.create replacement
# requests with model="gpt-5.6-luna" will pick a deployment where model_name="gpt-5.6-luna"
response = await router.acompletion(model="gpt-5.6-luna",
				messages=[{"role": "user", "content": "Hey, how's it going?"}])

print(response)

# openai.ChatCompletion.create replacement
# requests with model="gpt-5.6-terra" will pick a deployment where model_name="gpt-5.6-terra"
response = await router.acompletion(model="gpt-5.6-terra",
				messages=[{"role": "user", "content": "Hey, how's it going?"}])

print(response)
```

La sortie`python`

**Pas encore exécuté par Meridal.** Ce code appelle des modèles payants ; la documentation de LiteLLM n'en montre pas la réponse.

Le modèle « openrouter/auto » laisse le routeur choisir ; la réponse dit lequel il a pris.

`L'Auto Router d'OpenRouter, extrait de la documentation`

```
import requests
import json

response = requests.post(
  url="https://openrouter.ai/api/v1/chat/completions",
  headers={
    "Authorization": "Bearer <OPENROUTER_API_KEY>",
    "Content-Type": "application/json",
  },
  data=json.dumps({
    "model": "openrouter/auto",
    "messages": [
      {
        "role": "user",
        "content": "Explain quantum entanglement in simple terms"
      }
    ]
  })
)

data = response.json()
print(data['choices'][0]['message']['content'])
# Check which model was selected
print('Model used:', data['model'])
```

La sortie`python`

**Pas encore exécuté par Meridal.** Ce code appelle un modèle payant ; il imprime la réponse, puis le nom du modèle que le routeur a choisi.

## Exemple détaillé

Reprenons le service client de [la page sur le coût](https://meridal.fr/apprendre/cout-d-un-outil-d-ia-en-service/) : 400 demandes par jour ouvré, chacune lit 6 000 tokens et en écrit 500. Une partie des demandes sont de simples classements ; supposons, pour l'exemple, 70 % de demandes simples et 30 % de réponses à rédiger.

| Demande | Part | Modèle |
|---|---|---|
| Classer le courriel, extraire le numéro de commande | 70 % | Claude Haiku 5.5 |
| Rédiger la réponse au client | 30 % | Claude Sonnet 5.5 |
| Le tri lui-même, à chaque demande | 100 % | Claude Haiku 5.5, 1 000 tokens lus, 10 écrits |

Le même service client, trois façons de le servir

1. Tout sur Claude Sonnet 5.5 chaque demande au modèle intermédiaire 149,60 $
2. Routé 70 % au petit modèle, 30 % à l'intermédiaire, tri compris 51,04 $
3. Tout sur Claude Haiku 5.5 le moins cher, qui échouera sur les réponses délicates 7,48 $

*Coût par mois en dollars hors taxe : 8 800 demandes, 6 000 tokens lus et 500 écrits par demande, aux prix standard d'Anthropic relevés le 8 octobre 2026 (2 $ et 10 $ le million pour Sonnet 5.5, 0,10 $ et 0,50 $ pour Haiku 5.5). Le partage 70 / 30 est fabriqué pour l'exemple ; le vôtre se mesure.*

Le routage ramène la facture de 149,60 $ à 51,04 $ par mois, dont 0,92 $ pour le tri. Tout envoyer au petit modèle coûterait 7,48 $, mais les réponses délicates en pâtiraient. Ces chiffres ne valent que si le petit modèle réussit vraiment les classements : c'est ce que mesure [l'évaluation d'un outil](https://meridal.fr/apprendre/evaluer-un-outil-d-ia/), cas par cas, avant de basculer.

## Risques

- **L'économie qui se paie en erreurs** : un tri qui envoie une demande difficile au petit modèle donne une mauvaise réponse, moins chère. Sans jeu de tests, on ne le voit pas ; voir [les jeux de tests](https://meridal.fr/apprendre/jeux-de-tests/).
- **Des critères qui ne sont pas les vôtres** : l'Auto Router d'OpenRouter classe les modèles selon les dépenses de la communauté, pas selon vos cas ; le routeur de Microsoft, en mode Balanced, accepte un modèle à 1 ou 2 % de la meilleure qualité, selon sa propre estimation.
- **La fenêtre de contexte la plus petite** : chez Microsoft, la fenêtre utile du routeur est celle du plus petit modèle sous-jacent ; un long document peut ne pas passer.
- **Les frais d'un intermédiaire** : OpenRouter ne majore pas le prix des modèles, mais prend 5,5 % sur l'achat de crédits, 8 % en offre Business ; avec vos propres clés, l'usage est gratuit jusqu'à 25 000 $ par mois, puis à 5 %.
- **Le chemin des données** : par OpenRouter, vos demandes passent par un intermédiaire de plus ; il ne garde par défaut que les métadonnées, et le routage dans l'Union européenne est réservé aux offres Business et Enterprise. Voir [les données confiées à une IA](https://meridal.fr/apprendre/donnees-confiees-a-une-ia/).
- **Le budget qui ne plafonne rien** : chez LiteLLM, les budgets exigent une base de données ; sans elle, ils ne bloquent rien.

## Mise en place

1. Lister les types de demandes et leurs volumes **Ce qu'on fait :** classer, extraire, résumer, rédiger, analyser : combien de chaque, par jour.
2. Mesurer chaque type sur deux ou trois modèles **Ce qu'on fait :** le même jeu de cas, un petit modèle, un intermédiaire, un grand ; on note les réussites et le coût ([évaluer un outil d'IA](https://meridal.fr/apprendre/evaluer-un-outil-d-ia/)).
3. Écrire la règle de tri la plus simple qui marche **Ce qu'on fait :** une règle d'abord, quand le type est connu d'avance ; un petit modèle qui classe, seulement s'il le faut.
4. Prévoir l'escalade et le repli **Ce qu'on fait :** ce qui échoue à un contrôle remonte au modèle suivant ; une panne chez un fournisseur bascule vers un autre, ce que fait une passerelle comme LiteLLM.
5. Noter le modèle choisi et le coût de chaque passage **Ce qu'on fait :** dans les traces de l'outil ([l'observabilité](https://meridal.fr/apprendre/observabilite/)) ; et des budgets ou des plafonds chez chaque éditeur ([le coût en service](https://meridal.fr/apprendre/cout-d-un-outil-d-ia-en-service/)).
6. Refaire la mesure à chaque nouveau modèle **Ce qu'on fait :** un nouveau petit modèle peut prendre des demandes au modèle intermédiaire ; un changement de prix peut renverser le calcul.

## Exercice

Une entreprise de distribution veut router les demandes de ses outils d'IA. Pour chacune, choisissez un petit modèle, un intermédiaire ou un grand, et dites ce qu'il faudrait mesurer. L'entreprise et ses volumes sont fabriqués pour l'exercice.

- Classer les courriels entrants 300 par jour
- Extraire le montant et la date des factures fournisseurs 80 par jour
- Rédiger la réponse à une réclamation 40 par jour
- Résumer un appel d'offres de quatre-vingts pages 2 par semaine
- Traduire une fiche produit 20 par jour

*Cinq types de demandes, avec leur volume.*

**Voir la correction**

**Classer les courriels**Un petit modèle, entre des catégories fixes : c'est le plus gros volume, le gain est là. À mesurer : la part de courriels bien classés, et ce qui part en « autre ».

**Extraire montant et date**Un petit modèle, suivi de règles qui vérifient le total et la date ; ce qui échoue au contrôle remonte au modèle suivant.

**Répondre à une réclamation**Un modèle intermédiaire, et une personne qui valide : l'enjeu est la relation client, pas le coût.

**Résumer un appel d'offres**Un grand modèle, ou un intermédiaire si la mesure le permet : deux par semaine, le coût compte peu ; vérifier aussi que le document tient dans la fenêtre de contexte.

**Traduire une fiche produit**À mesurer : un petit modèle peut suffire sur des fiches simples ; une personne relit les premières.

## Vérification

**1 Comprendre Pourquoi ne pas envoyer toutes les demandes au meilleur modèle ?**

Parce que son prix peut être cent fois celui d'un petit modèle du même éditeur, alors que beaucoup de demandes, classer, extraire, n'en ont pas besoin.

**2 Comprendre Qu'est-ce qu'une cascade ?**

On essaie d'abord le petit modèle ; si sa réponse échoue à un contrôle, ou s'il dit ne pas savoir, la demande remonte au modèle suivant.

**3 Appliquer Vous voulez confier les classements à un petit modèle. Que faire avant ?**

Le mesurer sur le même jeu de cas que le modèle actuel, cas par cas ; garder une escalade pour ce qu'il rate ; suivre ensuite le coût et les erreurs dans les traces.

## Lectures suivantes

↑ Plus général [Coût d'un outil d'IA en service Faire · Niveau 3 · 15 minutes](https://meridal.fr/apprendre/cout-d-un-outil-d-ia-en-service/)

← Avant [Premier appel à un modèle S'exercer · Niveau 3 · 15 minutes](https://meridal.fr/apprendre/premier-appel/)

Vous êtes ici

Routage entre modèles et maîtrise du coût

→ Ensuite [Projet : une application déployée en Europe avec connexion d'entreprise S'exercer · Niveau 3 · 480 minutes](https://meridal.fr/apprendre/projet-application-en-europe/)

Développement d'applications d'IA · étape 10 sur 10

↓ Plus concret [Réponse dans un format imposé S'exercer · Niveau 3 · 20 minutes](https://meridal.fr/apprendre/format-impose/)

[Tout le dossier « Construction et programmation »](https://meridal.fr/apprendre/dossier/construire/)

Les pages qui renvoient ici

- [Interface de discussion et connexion d'entreprise](https://meridal.fr/apprendre/interface-et-connexion-d-entreprise/)

**Limites et sources**

Le partage 70 / 30 et l'exercice sont fabriqués ; les prix sont ceux du relevé du 8 octobre 2026.

Le code vient des documentations, sans avoir été exécuté ici ; les noms de modèles y sont ceux des éditeurs.

Le rapport de 1 à 100 est calculé sur les grilles de prix ; les éditeurs ne l'écrivent pas.

1. [Microsoft, model router](https://learn.microsoft.com/en-us/azure/ai-foundry/openai/concepts/model-router) ; [OpenRouter, Auto Router](https://openrouter.ai/docs/guides/routing/routers/auto-router.md) ; [OpenRouter, prix](https://openrouter.ai/pricing) ; [LiteLLM, routeur](https://docs.litellm.ai/docs/routing) ; [LiteLLM, budgets](https://docs.litellm.ai/docs/proxy/users) ; [OpenAI, prix](https://developers.openai.com/api/docs/pricing.md) ; [Anthropic, prix](https://platform.claude.com/docs/en/about-claude/pricing.md).
2. Les relevés : `apprendre/recherches/2026-10-09-routage.json` et `apprendre/recherches/2026-10-08-dev-avance.json`.

Écrit par Meridal, avec l'aide de l'IA ; chaque fait vérifié à sa source et relu avant publication. Texte et schémas sous licence [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/deed.fr) : reprenez-les en citant Meridal. Le code sous licence MIT.

Service correspondant

Garder vos outils en état

200 € à 1 500 € par mois

[Voir le service](https://meridal.fr/offre/#suivi)

## Un premier échange de 30 minutes

En visio et sans frais : vous décrivez votre situation, nous vous indiquons ce qui est réalisable, avec quels outils et pour quel ordre de prix. Vous pouvez aussi nous écrire ; chaque message reçoit une réponse écrite.

[Réserver 30 minutes](https://meridal.fr/contact/#reserver) [Écrire un message](https://meridal.fr/contact/)