OpenRouter: Un guide avec des exemples pratiques

La gestion de plusieurs API de fournisseurs d'IA peut rapidement devenir complexe. Chaque fournisseur dispose de méthodes d'authentification, de modèles tarifaires et de spécifications API différents. Les développeurs consacrent d'innombrables heures à passer d'OpenAI à Anthropic, Google et d'autres plateformes simplement pour accéder à différents modèles.

OpenRouter simplifie cette complexité en fournissant une API unifiée qui vous connecte à plus de 400 modèles provenant de dizaines de fournisseurs. Vous pouvez accéder à GPT-5et Claude 4, Gemini 2.5 Proet des centaines d'autres modèles à l'aide d'une seule clé API et d'une interface cohérente. La plateforme gère automatiquement les repli, la gestion des coûts et le routage des fournisseurs en arrière-plan.

Dans ce tutoriel, je vous explique tout ce que vous devez savoir sur OpenRouter, de la configuration de votre premier appel API à la mise en œuvre de fonctionnalités avancées telles que les sorties structurées. À la fin, vous saurez comment créer des applications fiables qui ne dépendent pas d'un seul fournisseur.

Qu'est-ce qu'OpenRouter ?

OpenRouter est une plateforme API unifiée qui vous donne accès à plus de 400 modèles d'IA provenant de dizaines de fournisseurs via un seul point de terminaison. Au lieu de jongler avec différentes clés API pour OpenAI, Anthropic, Google, Meta et d'autres, vous utilisez une seule clé pour accéder à l'ensemble de leur catalogue de modèles.

La plateforme fonctionne comme un routeur intelligent, transmettant vos demandes au fournisseur approprié tout en se chargeant de l'authentification, de la facturation et du traitement des erreurs. Cette approche résout plusieurs problèmes liés à l'utilisation de plusieurs fournisseurs d'IA.

Problèmes résolus par OpenRouter

Travailler avec plusieurs fournisseurs d'IA peut rapidement devenir compliqué. Chacun dispose de son propre format API, processus de connexion et système de facturation. Vous finissez par maintenir un code distinct pour chaque service, ce qui ralentit le développement et rend difficile le test de nouveaux modèles.

La situation se complique lorsque les fournisseurs sont indisponibles ou imposent des limites de débit. Votre application ne fonctionne plus et vous ne pouvez rien faire d'autre qu'attendre. De plus, pour déterminer quel fournisseur propose le meilleur prix pour des modèles similaires, il est nécessaire de suivre manuellement les coûts sur différentes plateformes.

Le principal problème est de se retrouver lié à un seul fournisseur. Lorsque vous construisez tout autour de leur API spécifique, passer à des modèles plus performants ou à des options moins coûteuses devient par la suite un projet de grande envergure.

Comment OpenRouter résout ce problème

OpenRouter résout ces problèmes grâce à un ensemble de fonctionnalités connectées :

• Une seule clé API est compatible avec plus de 400 modèles provenant de tous les principaux fournisseurs.
• Commutation automatique vers des fournisseurs de secours lorsque votre premier choix échoue
• Comparaison des prix côte à côte pour tous les modèles afin de comparer les coûts instantanément.
• Fonctionne avec le code OpenAI existant — il suffit de modifier l'URL du point de terminaison.
• Surveillance en temps réel qui achemine les demandes vers le fournisseur le plus rapide disponible.

Ces éléments fonctionnent ensemble pour rendre le développement de l'IA plus fluide et plus fiable.

Qui devrait utiliser OpenRouter ?

Différents types d'utilisateurs bénéficient de cette approche unifiée :

• Les développeurs peuvent tester de nouveaux modèles sans avoir à créer de comptes partout, ce qui accélère l'expérimentation.
• Les équipes d'entreprise bénéficient de la disponibilité dont elles ont besoin grâce à des sauvegardes automatiques en cas de défaillance des fournisseurs.
• Les utilisateurs soucieux de leur budget peuvent trouver l'option la plus économique pour leurs besoins sans avoir à effectuer de calculs complexes.
• Les chercheurs bénéficient d'un accès instantané à des modèles de pointe sans avoir à créer de compte.

Maintenant que vous comprenez ce qu'OpenRouter apporte, nous allons vous aider à configurer votre premier appel API.

Conditions préalables

Avant de vous lancer dans OpenRouter, vous devez configurer certains éléments sur votre ordinateur. Ce tutoriel suppose que vous maîtrisez les bases de la programmation Python et que vous avez déjà travaillé avec des API. Il n'est pas nécessaire d'être un expert, mais vous devez comprendre des concepts tels que la création de requêtes HTTP et le traitement des réponses JSON.

Vous devez disposer de Python 3.7 ou d'une version ultérieure sur votre système. Nous utiliserons le package Python openai pour interagir avec l'API d'OpenRouter, ainsi que python-dotenv pour gérer les variables d'environnement en toute sécurité. Vous pouvez installer les deux à l'aide de la commande suivante :

pip install requests openai python-dotenv

Vous aurez également besoin d'un compte OpenRouter et d'une clé API. Rendez-vous sur openrouter.ai pour créer un compte gratuit. Vous bénéficierez d'un petit crédit pour tester le service. Une fois connecté, accédez à la section Clés API dans les paramètres de votre compte et générez une nouvelle clé.

Une fois que vous avez obtenu votre clé API, veuillez créer un fichier .env dans le répertoire de votre projet et ajouter votre clé comme suit :

OPENROUTER_API_KEY=your_api_key_here

Cela permet de sécuriser votre clé API et de la garder hors de votre code. Si vous envisagez d'utiliser OpenRouter au-delà de la phase de test, vous devrez ajouter des crédits à votre compte via la page Crédits.

Une fois ces bases acquises, vous êtes prêt à effectuer votre premier appel API via OpenRouter.

Effectuer votre premier appel API dans OpenRouter

La prise en main d'OpenRouter est remarquablement simple si vous avez déjà utilisé le SDK OpenAI. Il vous suffit de modifier une ligne de code pour accéder instantanément à des centaines de modèles provenant de différents fournisseurs.

Votre première demande et configuration

Commençons par un exemple concret illustrant l'approche d'OpenRouter :

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY"),
)

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Write a haiku about debugging code at 2 AM"
       }
   ]
)

print(response.choices[0].message.content)

Night hum, coffee cooled
cursor blinks, bug hides somewhere
I chase ghosts 'til dawn

La magie opère à deux endroits. Tout d'abord, le paramètre base_url redirige vos requêtes vers les serveurs d'OpenRouter au lieu de ceux d'OpenAI. Deuxièmement, le nom du modèle suit le format provider/model-name - openai/gpt-5-mini au lieu de simplement gpt-5-mini. Cela indique à OpenRouter la version du fournisseur que vous souhaitez utiliser tout en conservant l'interface familière. Voici quelques modèles courants que vous pouvez intégrer à l'exemple ci-dessus sans rencontrer d'erreurs :

• google/gemini-2.0-flash-001
• google/gemini-2.5-pro
• mistralai/mistral-nemo
• deepseek/deepseek-r1-distill-qwen-32b

Maintenant que vous avez constaté à quel point il est facile de travailler avec différents modèles, vous vous demandez peut-être ce qui se passe lorsque le modèle que vous avez choisi n'est pas disponible. Comment concevez-vous des applications qui restent fiables même lorsque les fournisseurs rencontrent des problèmes ? C'est là qu'interviennent les fonctionnalités de routage et de résilience d'OpenRouter.

Modèle de routage pour la résilience

Développer des applications d'IA fiables implique de se préparer à l'imprévu. Les fournisseurs peuvent rencontrer des temps d'arrêt, les modèles peuvent atteindre leurs limites de taux de réussite et, parfois, la modération du contenu peut bloquer vos demandes. Le routage par modèle est la solution proposée par OpenRouter : il bascule automatiquement entre différents modèles afin d'assurer le bon fonctionnement de votre application.

Configuration des solutions de secours manuelles

La méthode la plus simple pour renforcer la résilience consiste à définir des modèles de sauvegarde. Lorsque votre premier choix échoue, OpenRouter essaie vos alternatives dans l'ordre. Le paramètre extra_body transmet ces instructions de routage à l'API d'OpenRouter, car le paramètre SDK OpenAI ne prend pas en charge cette fonctionnalité de manière native :

response = client.chat.completions.create(
   model="moonshotai/kimi-k2",  # Primary choice
   messages=[
       {"role": "user", "content": "Explain quantum computing in simple terms"}
   ],
   extra_body={
       "models": ["anthropic/claude-sonnet-4", "deepseek/deepseek-r1"]
   }   
)

print(f"Response from: {response.model}")
print(response.choices[0].message.content)

Response from: moonshotai/kimi-k2
Imagine a normal computer bit as a tiny light-switch that can only be OFF (0) or ON (1)...

OpenRouter tente d'abord Kimi-K2. Si celui-ci n'est pas disponible, soumis à une limitation de débit ou bloqué, le système essaie automatiquement Claude Sonnet 4, puis DeepSeek R1. Le champ « response.model » (Réponse du modèle) indique quel modèle a réellement répondu.

Routeur automatique pour un confort optimal

Une fois que vous comprenez les repli manuels, le routage automatique devient très intéressant. Il gère automatiquement la sélection des modèles et les solutions de repli, grâce à système d'évaluation de NotDiamond:

response = client.chat.completions.create(
   model="openrouter/auto",
   messages=[
       {"role": "user", "content": "Debug this Python code in 3 sentences: def factorial(n): return n * factorial(n-1)"}
   ]
)

print(f"Auto router selected: {response.model}")
print(response.choices[0].message.content)

Auto router selected: openai/chatgpt-4o-latest
The given code is missing a base case, which causes infinite recursion and eventually a RecursionError. To fix it, add a base case like `if n == 0: return 1` before the recursive call. Here's the corrected version:

\```python
def factorial(n):
   if n == 0:
       return 1
   return n * factorial(n - 1)
\```

Le routeur automatique analyse votre invite et sélectionne le meilleur modèle disponible, avec des solutions de secours intégrées si votre premier choix n'est pas disponible. Vous bénéficiez d'une résilience sans aucune configuration. Cependant, veuillez utiliser le routage automatique avec précaution dans les scénarios sensibles ou importants, car il a tendance à sous-estimer la complexité de votre problème et, par conséquent, à choisir un modèle de capacité inférieure.

Élaborer des stratégies de repli efficaces

Tous les modèles ne constituent pas de bonnes sauvegardes les uns pour les autres. Les interruptions de service d'un fournisseur peuvent affecter tous les modèles de cette entreprise. Veuillez donc choisir des solutions de secours provenant de différents fournisseurs. Les limites de débit et les coûts varient considérablement, il est donc recommandé d'associer les modèles coûteux à des alternatives plus économiques.

# Good fallback chain: different providers, decreasing cost
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Your prompt here"}
   ],
   extra_body={
       "models": [
           "x-ai/grok-4",                  # Close performance
           "moonshotai/kimi-k2",           # Cheaper
           "deepseek/deepseek-r1:free"     # Free backup
       ]
   }   
)

Cela vous garantit une qualité optimale lorsque celle-ci est disponible, des performances solides en cas de besoin et une disponibilité assurée en dernier recours. Les politiques de modération des contenus diffèrent également d'un fournisseur à l'autre. Diversifier votre chaîne vous permet donc de mieux couvrir les sujets sensibles.

Recherche de modèles pour votre chaîne de secours

La page Modèles vous permet de filtrer par fournisseur et par fonctionnalités afin de créer votre chaîne. De nombreux modèles performants tels que DeepSeek R1 et Kimi-K2 sont gratuits car ils sont open source, ce qui en fait d'excellentes solutions de secours. Les modèles gratuits sont soumis à une limite de 50 requêtes par jour pour les nouveaux utilisateurs, ou de 1 000 requêtes par jour si vous avez acheté 10 crédits.

Pour les applications dynamiques, vous pouvez découvrir des modèles par programmation :

def get_provider_models(api_key: str, provider: str) -> list[str]:
   r = requests.get(
       "https://openrouter.ai/api/v1/models",
       headers={"Authorization": f"Bearer {api_key}"}
   )
   return [m["id"] for m in r.json()["data"] if m["id"].startswith(provider)]

# Build fallbacks across providers
openai_models = get_provider_models(api_key, "openai/")
anthropic_models = get_provider_models(api_key, "anthropic/")

Cette approche vous permet de créer des chaînes de secours robustes qui s'adaptent à mesure que de nouveaux modèles deviennent disponibles.

Diffusion en continu pour des réponses en temps réel

Lorsqu'ils utilisent des modèles d'IA, en particulier pour des réponses longues, les utilisateurs s'attendent à voir le résultat s'afficher progressivement plutôt que d'attendre la réponse complète. Le streaming résout ce problème en envoyant les morceaux de réponse au fur et à mesure qu'ils sont générés, créant ainsi une expérience plus interactive similaire à l'interface de ChatGPT.

Configuration de base du streaming

Pour configurer le streaming dans OpenRouter, veuillez ajouter stream=True à votre requête. La réponse devient un itérateur qui produit des morceaux à mesure que le modèle les génère :

response = client.chat.completions.create(
   model="openai/gpt-5",
   messages=[
       {"role": "user", "content": "Write a detailed explanation of how neural networks learn"}
   ],
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content is not None:
       print(chunk.choices[0].delta.content, end="")

Chaque fragment contient une petite partie de la réponse. Le champ « delta.content » contient le nouveau fragment de texte, que nous imprimons immédiatement sans nouvelle ligne afin de créer un effet de flux. Le paramètre « end="" » empêche l'impression d'ajouter des sauts de ligne entre les blocs.

Développement d'un meilleur gestionnaire de streaming

Pour les applications de production, vous souhaiterez disposer d'un contrôle accru sur le processus de streaming. Voici un gestionnaire plus complet qui gère la réponse complète :

def stream_response(model, messages, show_progress=True):
   response = client.chat.completions.create(
       model=model,
       messages=messages,
       stream=True
   )
  
   complete_response = ""
  
   for chunk in response:
       if chunk.choices[0].delta.content is not None:
           content = chunk.choices[0].delta.content
           complete_response += content
          
           if show_progress:
               print(content, end="", flush=True)
  
   if show_progress:
       print()  # Add final newline
  
   return complete_response

# Use it with different models
result = stream_response(
   "anthropic/claude-sonnet-4",
   [{"role": "user", "content": "Explain quantum entanglement like I'm 12 years old"}]
)

Ce gestionnaire capture la réponse complète tout en affichant la progression, vous offre à la fois l'expérience de streaming et le texte final, et inclut un formatage de sortie approprié.

Le streaming transforme l'expérience utilisateur, qui passe de « l'attente et l'espoir » à « l'observation de la progression ». Cela rend vos applications d'IA beaucoup plus réactives et attrayantes pour les utilisateurs.

Gestion des jetons de raisonnement dans OpenRouter

Certains modèles d'IA peuvent vous montrer leur processus de « réflexion » avant de donner leur réponse finale. Ces jetons de raisonnement offrent un aperçu transparent de la manière dont le modèle aborde les problèmes complexes, en montrant la logique étape par étape qui mène à leurs conclusions. Comprendre ce raisonnement interne peut vous aider à vérifier les réponses, à déboguer le comportement du modèle et à créer des applications plus fiables.

Que sont les jetons de raisonnement ?

Les jetons de raisonnement apparaissent dans un champ distinct intitulé « reasoning » (jetons de raisonnement) dans la réponse, séparés du contenu principal. Différents modèles prennent en charge le raisonnement de différentes manières : certains utilisent des niveaux d'effort, tandis que d'autres utilisent des budgets de jetons. 

Voici un exemple simple illustrant le raisonnement en action :

response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "How many 'r's are in the word 'strrawberry'?"}
   ],
   max_tokens=2048,
   extra_body={
       "reasoning": {
           "max_tokens": 512
       }
   }
)

print("Final answer:")
print(response.choices[0].message.content)
print("\nReasoning process:")
print(response.choices[0].message.reasoning)

Final answer:
To count the 'r's in 'strrawberry', I'll go through each letter:
...
There are **4** 'r's in the word 'strrawberry'.

Reasoning process:
...

Le modèle affichera à la fois sa réponse finale et le raisonnement interne qui a conduit à cette conclusion. Cette double sortie vous aide à déterminer si le modèle a correctement abordé le problème.

Contrôler l'intensité du raisonnement

Vous pouvez contrôler l'effort de raisonnement que les modèles consacrent à leurs réponses à l'aide de deux approches. Le paramètre « effort » fonctionne avec des modèles tels que la série o d'OpenAI et utilise des niveaux correspondant à des pourcentages de tokens spécifiques en fonction de votre paramètre « max_tokens » :

• s très exigeantes: Utilise environ 80 % de l' max_tokens s pour le raisonnement.
• de difficulté moyenne: Utilise environ 50 % de l' max_tokens s pour le raisonnement.
• s minimales requises: Utilise environ 20 % de l' max_tokens s nécessaires pour le raisonnement.

# High effort reasoning for complex problems
response = client.chat.completions.create(
   model="deepseek/deepseek-r1",
   messages=[
       {"role": "user", "content": "Solve this step by step: If a train travels 240 miles in 3 hours, then speeds up by 20 mph for the next 2 hours, how far does it travel total?"}
   ],
   max_tokens=4000,  # High effort will use ~3200 tokens for reasoning
   extra_body={
       "reasoning": {
           "effort": "high" 
       }
   }
)

print("Problem solution:")
print(response.choices[0].message.content)
print("\nStep-by-step reasoning:")
print(response.choices[0].message.reasoning)

Pour les modèles qui prennent en charge l'allocation directe de jetons, comme les modèles Anthropic, vous pouvez définir des budgets de raisonnement précis :

def get_reasoning_response(question, reasoning_budget=2000):
   response = client.chat.completions.create(
       model="anthropic/claude-sonnet-4",
       messages=[{"role": "user", "content": question}],
       max_tokens=10000,
       extra_body={
           "reasoning": {
               "max_tokens": reasoning_budget  # Exact token allocation
           }
       }
   )
   return response

# Compare different reasoning budgets
response = get_reasoning_response(
   "What's bigger: 9.9 or 9.11? Explain your reasoning carefully.",
   reasoning_budget=3000
)

print("Answer:", response.choices[0].message.content)
print("Detailed reasoning:", response.choices[0].message.reasoning)

Des budgets de jetons plus élevés permettent généralement un raisonnement plus approfondi, tandis que des budgets plus modestes donnent lieu à des processus de réflexion plus rapides mais moins détaillés.

Préserver le raisonnement dans les conversations

Lorsque vous construisez des conversations à plusieurs tours, vous devez conserver à la fois le raisonnement et la réponse finale afin de préserver le contexte. Ceci est particulièrement important pour les discussions complexes où le processus de réflexion du modèle influence les réponses suivantes :

# First message with reasoning
response = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=[
       {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."}
   ],
   extra_body={
       "reasoning": {
           "max_tokens": 3000
       }
   }
)

# Build conversation history with reasoning preserved
messages = [
   {"role": "user", "content": "Should I invest in renewable energy stocks? Consider both risks and opportunities."},
   {
       "role": "assistant",
       "content": response.choices[0].message.content,
       "reasoning_details": response.choices[0].message.reasoning_details  # Preserve reasoning
   },
   {"role": "user", "content": "What about solar energy specifically? How does that change your analysis?"}
]

# Continue conversation with reasoning context
follow_up = client.chat.completions.create(
   model="anthropic/claude-sonnet-4",
   messages=messages,
   extra_body={
       "reasoning": {
           "max_tokens": 2000
       }
   }
)

print("Follow-up answer:")
print(follow_up.choices[0].message.content)
print("\nContinued reasoning:")
print(follow_up.choices[0].message.reasoning)

Le champ « reasoning_details » (Chaîne de raisonnement) conserve la chaîne de raisonnement complète, ce qui permet au modèle de s'appuyer sur son analyse précédente pour répondre aux questions suivantes. Cela permet d'avoir des conversations plus cohérentes et mieux adaptées au contexte.

Considérations relatives aux coûts et à la facturation

Les jetons de raisonnement sont facturés comme des jetons de sortie, ils augmentent donc vos coûts d'utilisation. Cependant, ils améliorent souvent suffisamment la qualité des réponses pour justifier leur coût, en particulier pour les tâches complexes où la précision est plus importante que la rapidité. Selon documentation d'OpenRouter, les jetons de raisonnement peuvent améliorer les performances du modèle sur des problèmes complexes tout en apportant de la transparence au processus décisionnel.

Pour les applications où le coût est un facteur important, vous pouvez équilibrer la qualité du raisonnement et les dépenses en ajustant les niveaux d'effort ou les budgets de jetons en fonction de la complexité des tâches. Les questions simples peuvent ne nécessiter aucune réflexion, tandis que les problèmes complexes nécessitent une réflexion approfondie.

Utilisation de modèles multimodaux dans OpenRouter

Jusqu'à présent, vous avez travaillé avec du texte, mais que se passe-t-il lorsque vous devez analyser des images ou des documents ? Vous souhaitez peut-être poser des questions sur un graphique, extraire des informations d'un PDF ou décrire ce qui se passe sur une photo. C'est là qu'intervient le modèles multimodaux entrent en jeu : ils sont capables de comprendre à la fois le contenu textuel et visuel d'une même requête.

Comprendre les capacités multimodales

Au lieu d'essayer de décrire une image par écrit, vous pouvez envoyer l'image elle-même et poser des questions à son sujet directement. Cela rend vos applications beaucoup plus intuitives, car le modèle voit exactement ce sur quoi vous travaillez. Vous n'avez pas besoin de vous demander si votre description textuelle a bien capturé tous les détails importants.

Vous utilisez les modèles multimodaux via la même interface que celle que vous utilisez habituellement, avec simplement un paramètre supplémentaire « attachments » pour inclure votre contenu visuel. Les pièces jointes fonctionnent avec tous les modèles sur OpenRouter. Même si un modèle ne prend pas en charge nativement les fichiers PDF ou les images, OpenRouter analyse ces fichiers en interne et transmet leur contenu au modèle.

Travailler avec des images

Vous pouvez inclure des images dans vos requêtes via des URL ou un encodage base64. Si votre image est déjà en ligne, l'approche par URL est plus simple :

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "What's happening in this image? Describe the scene in detail."
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/jpeg",
               "url": "https://example.com/photo.jpg"
           }
       ]
   }
)

print(response.choices[0].message.content)

Pour les images locales, vous pouvez utiliser l'encodage base64:

import base64

def encode_image_to_base64(image_path):
   with open(image_path, "rb") as image_file:
       encoded_string = base64.b64encode(image_file.read()).decode('utf-8')
   return encoded_string

# Analyze a local screenshot
encoded_image = encode_image_to_base64("screenshot.png")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "This is a screenshot of a data dashboard. What insights can you extract from the charts and metrics shown?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "image/png",
               "data": encoded_image
           }
       ]
   }
)

print(response.choices[0].message.content)

Le modèle examinera l'image réelle et vous fournira des informations spécifiques sur ce qu'il voit, et non pas seulement des réponses génériques.

Traitement de documents PDF

Le traitement des fichiers PDF fonctionne de la même manière, mais permet en outre d'analyser les documents. Vous pouvez poser des questions sur des rapports, analyser des formulaires ou extraire des informations de documents complexes :

def encode_pdf_to_base64(pdf_path):
   with open(pdf_path, "rb") as pdf_file:
       encoded_string = base64.b64encode(pdf_file.read()).decode('utf-8')
   return encoded_string

# Analyze a research paper
encoded_pdf = encode_pdf_to_base64("research_paper.pdf")

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {
           "role": "user",
           "content": "Summarize the key findings from this research paper. What are the main conclusions and methodology used?"
       }
   ],
   extra_body={
       "attachments": [
           {
               "type": "application/pdf",
               "data": encoded_pdf
           }
       ]
   }
)

print(response.choices[0].message.content)

Cette fonctionnalité est particulièrement utile pour les rapports financiers, les articles universitaires, les contrats ou tout autre document PDF nécessitant une analyse IA du contenu réel. Vous pouvez également joindre plusieurs pièces jointes à une seule demande si vous devez comparer des images ou analyser plusieurs documents ensemble.

Coût et sélection du modèle

Les requêtes multimodales coûtent plus cher que les requêtes textuelles, car elles impliquent le traitement de types de données supplémentaires. Les images et les fichiers PDF nécessitent davantage de puissance de calcul, ce qui se reflète dans les tarifs. Vous pouvez consulter les tarifs multimodaux spécifiques à chaque modèle sur la page des modèles.

Différents modèles présentent différents atouts en matière de contenu visuel. Certains sont plus performants dans l'analyse détaillée d'images, tandis que d'autres excellent dans la compréhension de documents. Nous vous recommandons d'essayer différents modèles afin de déterminer celui qui correspond le mieux à vos besoins spécifiques et à votre budget.

Utilisation des sorties structurées

Lorsque vous développez des applications réelles, vous avez besoin de formats de données prévisibles que votre code peut analyser de manière fiable. Les réponses sous forme de texte libre sont idéales pour les interfaces de chat, mais peu adaptées aux applications qui nécessitent l'extraction d'informations spécifiques. Au lieu de recevoir du texte imprévisible que vous devez analyser à l'aide d'expressions régulières ou en espérant que le modèle ait été correctement formaté, les sorties structurées obligent les modèles à renvoyer un JSON garanti avec les champs et les types de données exacts dont vous avez besoin. Cela élimine les erreurs d'analyse et simplifie considérablement le code de votre application.

Anatomie des requêtes de sortie structurées

Les sorties structurées utilisent un paramètre d' response_format avec la structure de base suivante :

"response_format": {
   "type": "json_schema",           # Always this for structured outputs
   "json_schema": {
       "name": "your_schema_name",  # Name for your schema
       "strict": True,              # Enforce strict compliance
       "schema": {
           # Your actual JSON schema definition goes here
       }
   }
}

Exemple d'analyse des sentiments

Examinons un exemple complet qui extrait le sentiment d'un texte. Ceci illustre le fonctionnement des sorties structurées dans la pratique :

response = client.chat.completions.create(
   model="openai/gpt-5-mini",
   messages=[
       {"role": "user", "content": "Analyze the sentiment: 'This movie was absolutely terrible!'"}
   ],
   extra_body={
       "response_format": {
           "type": "json_schema",
           "json_schema": {
               "name": "sentiment_analysis",
               "strict": True,
               "schema": {
                   "type": "object",
                   "properties": {
                       "sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"]},
                       "confidence": {"type": "number"}
                   },
                   "required": ["sentiment", "confidence"]
               }
           }
       }
   }
)

import json
result = json.loads(response.choices[0].message.content)
print(result)

{'sentiment': 'negative', 'confidence': 0.98}

Voici ce qui se passe dans ce schéma :

• sentiment: Champ de chaîne limité à trois valeurs spécifiques à l'aide de l'enum. Le modèle ne peut pas renvoyer de résultat autre que « positif », « négatif » ou « neutre ».
• confidence: Un champ numérique pour le score de confiance du modèle.
• required: Les deux champs doivent être présents dans la réponse - le modèle ne peut pas les ignorer.
• strict: True: Assure une conformité stricte avec la structure du schéma.

Sans résultats structurés, vous pourriez obtenir des réponses telles que « Le sentiment est très négatif avec un niveau de confiance élevé » ou « Négatif (95 % de certitude) ». Grâce au schéma, vous obtenez toujours un JSON analysable que vous pouvez immédiatement utiliser dans votre code.

La configuration d'strict: True applique rigoureusement le schéma : le modèle ne peut pas s'écarter de votre structure. Le tableau d'required s spécifie les champs qui doivent être présents. Vous pouvez utiliser enum pour limiter les valeurs à des choix spécifiques, array pour les listes et les types object imbriqués pour les données complexes.

Compatibilité des modèles

Tous les modèles ne prennent pas en charge les sorties structurées, mais la plupart des modèles modernes le font. Vous pouvez consulter la page des modèles pour vérifier la compatibilité. Lorsqu'un modèle ne prend pas en charge nativement les sorties structurées, OpenRouter gère souvent le formatage en interne.

Les sorties structurées transforment les réponses de l'IA issues de textes imprévisibles en données fiables sur lesquelles vos applications peuvent s'appuyer. Cette fonctionnalité est indispensable pour tout cas d'utilisation en production nécessitant une extraction cohérente des données.

Conclusion

Nous avons appris à accéder à des centaines de modèles d'IA via l'API unifiée d'OpenRouter, depuis la première requête jusqu'à la mise en œuvre de fonctionnalités telles que le streaming, les jetons de raisonnement et les sorties structurées.

Les solutions de secours automatiques et le routage des modèles de la plateforme garantissent la fiabilité de vos applications, même lorsque certains fournisseurs rencontrent des difficultés. Grâce à des modèles de code identiques, nous pouvons comparer des modèles, changer de fournisseur et trouver la solution idéale pour chaque tâche sans avoir à gérer plusieurs clés API.

Commencez par tester des demandes simples, puis essayez progressivement d'autres fonctionnalités à mesure que vos besoins évoluent. Testez différents modèles pour différents types de tâches : certains sont plus adaptés à la rédaction créative, tandis que d'autres sont plus performants pour l'analyse de données ou les problèmes de raisonnement.

Les connaissances acquises ici vous fournissent les éléments nécessaires pour créer des applications d'IA qui ne sont pas liées à un seul fournisseur, ce qui vous offre la liberté de vous adapter à mesure que de nouveaux modèles et de nouvelles fonctionnalités deviennent disponibles.