OpenRouter en Python : utilisez n’importe quel LLM avec une seule clé API

Écrit par

0 minutes de lecture

La création d’applications d’IA implique souvent de jongler entre plusieurs clés API, d’apprendre les spécificités de différents services et de gérer diverses méthodes d’authentification. Et si vous pouviez accéder à des dizaines de LLM de premier plan avec une seule clé API ? C’est la promesse d’OpenRouter. Dans cet article, je vous montre la manière la plus simple de l’utiliser en Python. Dans les prochains articles, nous verrons également comment OpenRouter peut fonctionner de concert avec LangChain et comment l’utiliser avec LangChain pour appeler des outils. Le code source de cet article est disponible ici.

Un graphique à barres représentant le nombre de tokens transmis via OpenRouter à différents LLM.

Qu’est-ce qu’OpenRouter ?

OpenRouter sert de passerelle unifiée vers les principaux modèles de langage du monde, qu’ils soient commerciaux ou open source. Il vous permet d’accéder aux modèles d’OpenAI, d’Anthropic, de Google, de Meta, de Mistral et d’autres fournisseurs via une API unique et standardisée.

Au lieu de créer des comptes séparés auprès de chaque fournisseur et de jongler avec plusieurs SDK, OpenRouter vous offre une interface qui vous permet d’accéder à n’importe quel grand modèle de langage de n’importe quel fournisseur avec une seule ligne de code. Cela peut considérablement simplifier votre flux de développement si vous créez des applications faisant appel à plusieurs LLM différents, ou si vous souhaitez simplement tester différents modèles pour déterminer celui qui convient le mieux à votre cas d’usage.

Pourquoi utiliser OpenRouter ?

Nous avons déjà mentionné quelques avantages : une seule API pour accéder à des dizaines de modèles, comme GPT-4, Claude, Gemini, Llama et bien d’autres. De plus, OpenRouter propose :

Routage vers le meilleur modèle : plusieurs options vous permettent de router les prompts vers différents modèles en fonction de leur contenu. Par exemple, en définissant « model » sur « openrouter/auto », vous utilisez AutoRouter pour déterminer le modèle le mieux adapté à votre prompt.
Fiabilité et redondance : OpenRouter offre des capacités de basculement, permettant à votre application de se rabattre sur d’autres fournisseurs en cas de panne.
API compatible avec OpenAI : si vous utilisez déjà le SDK d’OpenAI, vous pouvez passer à OpenRouter en apportant un minimum de modifications au code.

Implémentation minimale d’OpenRouter

Voici la manière la plus simple d’utiliser OpenRouter en Python. Le code du fichier openrouter_simple.py fournit un exemple minimal pour démarrer rapidement. Voici le script complet :

"""
Minimal example for using OpenRouter with the OpenAI client directly.
This is the simplest way to get started with OpenRouter.
"""
import os
import pathlib
from dotenv import load_dotenv
from openai import OpenAI

# Get the current directory and load .env file
current_dir = pathlib.Path(__file__).parent.absolute()
env_path = current_dir / '.env'
load_dotenv(dotenv_path=env_path)

# Get API key from environment
api_key = os.environ.get("OPENROUTER_API_KEY")

# Check if API key is available
if not api_key:
    raise ValueError("OpenRouter API key not found. Please set OPENROUTER_API_KEY in your .env file.")

# Create a client for OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=api_key,
    default_headers={"HTTP-Referer": "http://localhost:5000"}  # Required by OpenRouter
)

# Send a message to the model
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",  # You can change this to any supported model
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, who are you?"}
    ]
)

# Display the response
print(response.choices[0].message.content)

Ce script contient tout ce dont vous avez besoin pour commencer à utiliser OpenRouter. Vous pouvez le décomposer en quatre étapes :

1. Configuration de l’environnement

Le script commence par charger votre clé API à partir d’un fichier .env, ce qui permet de protéger vos identifiants :

# Get the current directory and load .env file
current_dir = pathlib.Path(__file__).parent.absolute()
env_path = current_dir / '.env'
load_dotenv(dotenv_path=env_path)

# Get API key from environment
api_key = os.environ.get("OPENROUTER_API_KEY")

# Check if API key is available
if not api_key:
    raise ValueError("OpenRouter API key not found. Please set OPENROUTER_API_KEY in your .env file.")

Vous devez créer un fichier .env contenant votre clé API OpenRouter :

OPENROUTER_API_KEY=your_openrouter_api_key

Vous pouvez obtenir une clé API en créant un compte sur openrouter.ai.

2. Configuration du client OpenAI

La magie opère dans ces quelques lignes :

# Create a client for OpenRouter
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=api_key,
    default_headers={"HTTP-Referer": "http://localhost:5000"}  # Required by OpenRouter
)

Remarquez que nous utilisons le client OpenAI standard, mais que nous le dirigeons vers le point de terminaison de l’API OpenRouter. Cela fonctionne parce qu’OpenRouter est entièrement compatible avec le format d’API d’OpenAI.

OpenRouter exige l’en-tête HTTP-Referer pour identifier l’origine de la requête. En production, vous devez y indiquer l’URL de votre application.

3. Sélection du modèle et requête

Lors d’une requête, vous indiquez le modèle à utiliser :

# Send a message to the model
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",  # You can change this to any supported model
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, who are you?"}
    ]
)

L’identifiant du modèle suit le format provider/model-name. En voici quelques exemples :

openai/gpt-4o-2024-11-20 - GPT-4o (Omni) d’OpenAI, avec une date limite de connaissances spécifique
anthropic/claude-sonnet-4 - Claude 4 Sonnet d’Anthropic
google/gemini-2.5-pro-preview - Gemini Pro 2.5 de Google (version préliminaire)
meta-llama/llama-4-maverick - Llama 4 17B Instruct de Meta

OpenRouter vous donne parfois accès à des modèles auxquels vous n’auriez pas accès autrement. Par exemple, vous avez pu accéder plus tôt à des modèles premium comme GPT-4 32K. Vous trouverez la liste complète des modèles disponibles sur openrouter.ai/models.

4. Traitement de la réponse

Enfin, nous extrayons et affichons la réponse :

1# Display the response
2print(response.choices[0].message.content)

La structure de la réponse suit le même format que l’API d’OpenAI, ce qui facilite son intégration au code existant.

Fonctionnalités et options d’OpenRouter

L’exemple de base ci-dessus vous permet de démarrer rapidement, mais OpenRouter offre de nombreuses fonctionnalités supplémentaires :

Contrôle du routage des modèles

OpenRouter propose de nombreuses options pour contrôler le fournisseur sous-jacent vers lequel votre requête est routée. Vous pouvez les spécifier au format JSON d’OpenRouter (voir extra_body) :

# Provider preference ordering
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"order": ["together", "fireworks", "perplexity"]}}
)

# Quantization preferences (only for open-source models)
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",  # Must use open-source model
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"quantizations": ["fp8"]}}
)

# Fallback control
response = client.chat.completions.create(
    model="meta-llama/llama-3.1-8b-instruct",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"allow_fallbacks": True}}
)

# Data collection control
response = client.chat.completions.create(
    model="openai/gpt-3.5-turbo",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_body={"provider": {"data_collection": "deny"}}
)

Cet exemple indique que vous souhaitez uniquement utiliser des fournisseurs prenant en charge la quantification fp8 pour ce modèle.

Streaming des réponses

OpenRouter prend en charge le streaming des réponses, une fonctionnalité utile pour les applications de chat :

stream = client.chat.completions.create(
    model="anthropic/claude-3-sonnet",
    messages=[
        {"role": "user", "content": "Tell me about renewable energy benefits"}
    ],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

Modèles de langage avec vision

OpenRouter prend en charge les modèles multimodaux capables de traiter des images :

import base64

# Method 1: Using local image files
def encode_image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

base64_image = encode_image_to_base64("your_image.png")

response = client.chat.completions.create(
    model="openai/gpt-4o",  # GPT-4o works reliably for vision
    messages=[
        {
            "role": "user", 
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{base64_image}"}}
            ]
        }
    ]
)

# Method 2: Using image URLs
response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {
            "role": "user", 
            "content": [
                {"type": "text", "text": "What's in this image?"},
                {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
            ]
        }
    ]
)

Tarification et gestion des coûts

OpenRouter fonctionne avec un système de crédits : chaque requête consomme un nombre de crédits variable selon le modèle. Des crédits gratuits sont disponibles pour les tests, mais vous devrez en acheter d’autres pour une utilisation en production.

Vous pouvez suivre votre utilisation depuis le tableau de bord OpenRouter et définir des limites de crédits pour vos clés API afin de maîtriser vos dépenses.

Bien démarrer

Pour utiliser le code de cet article :

Créez un compte OpenRouter sur openrouter.ai
Créez une clé API sur openrouter.ai/settings/keys

Configurez un environnement Python avec les packages requis :

pip install openai python-dotenv

Créez un fichier .env contenant votre clé API :

OPENROUTER_API_KEY=your_openrouter_api_key

Exécutez le script d’exemple :

python openrouter_simple.py

Pour conclure

OpenRouter comble une lacune dans l’écosystème de l’IA en servant de place de marché unifiée pour les modèles de langage. L’implémentation présentée ici a l’avantage d’être simple : quelques lignes de code suffisent pour passer d’un modèle de pointe à un autre parmi des dizaines, sans modifier la structure de votre application.

Pour les développeurs qui créent des applications d’IA, cela signifie que vous pouvez :

Tester différents modèles sans vous engager auprès d’un seul fournisseur
Utiliser le meilleur modèle pour chaque tâche
Mettre en place des solutions de repli pour gagner en fiabilité
Optimiser les coûts en sélectionnant le modèle le plus économique pour chaque cas d’usage

Le script openrouter_simple.py fourni constitue un bon point de départ. Vous pouvez ensuite créer des applications robustes qui exploitent tout le potentiel des modèles de langage modernes, sans la complexité liée à la gestion de plusieurs API.

Sécurisez vos implémentations d’IA avec Snyk

Lorsque vous créez des applications avec OpenRouter et d’autres outils d’IA, la sécurité devient un enjeu majeur. Snyk propose des solutions spécialement conçues pour le nouvel écosystème de l’IA.

Snyk AI Security Platform

La AI Security Platform de Snyk répond aux défis de sécurité propres au développement assisté par l’IA. Elle aide les développeurs à créer des applications d’IA sécurisées tout en conservant le rythme rapide que permet l’IA.

La AI Security Platform est conçue pour permettre aux organisations d’accélérer l’innovation portée par l’IA, de réduire les risques métier et de sécuriser l’IA agentique et générative. C’est d’autant plus important que des études indiquent que près de la moitié du code généré par l’IA contient des failles de sécurité.

La AI Security Platform de Snyk permet aux équipes de développer rapidement tout en assurant leur sécurité dans un environnement où l’IA est omniprésente — en réduisant les efforts humains et en améliorant l’efficacité des politiques de sécurité et de la gouvernance. Elle s’appuie sur les moteurs de test complets de Snyk, alimentés par DeepCode AI et enrichis par sa base de données de vulnérabilités de premier plan.

Snyk Secure Developer Program for Open Source

Si vous travaillez sur des projets open source utilisant des technologies d’IA comme OpenRouter, le Secure Developer Program de Snyk met à votre disposition des ressources précieuses. Lancé en février 2025, ce programme vise à renforcer la sécurité de l’écosystème open source. Le Snyk Secure Developer Program est le premier programme de ce type à aider les communautés open source à mettre en place des programmes de sécurité de niveau entreprise, capables de détecter et de corriger rapidement les vulnérabilités dans le code.

Le programme fournit aux projets open source admissibles :

Outils de sécurité de niveau entreprise : accès complet et gratuit à la plateforme de sécurité premium de Snyk
Assistance d’experts : accompagnement pratique de l’équipe des relations développeurs de Snyk
Ressources communautaires : accès à la communauté Discord de Snyk et à Partner Connect
Accès à l’API : capacités d’intégration pour automatiser les contrôles de sécurité

Snyk met gratuitement ces outils de sécurité de premier plan à la disposition des développeurs de projets open source admissibles. Pour être admissible, votre projet ne doit pas être soutenu par une entreprise et doit compter au moins 10 000 étoiles sur GitHub.

En associant la flexibilité d’OpenRouter aux outils de sécurité de Snyk, vous pouvez créer des applications d’IA à la fois performantes et sécurisées. Cette approche est particulièrement précieuse alors que le développement de l’IA s’accélère et que de nouveaux défis de sécurité apparaissent.

Pour en savoir plus sur ces offres et présenter votre candidature au Secure Developer Program.

Demandez une démonstration en direct de Snyk pour sécuriser l’open source

Échangez avec nos experts en sécurité pour découvrir comment Snyk vous aide à utiliser l’open source en toute sécurité

Réserver une démonstration en direct Ou commencez gratuitement

Envie de l’essayer par vous-même ?