En bref
Qwen 3.6 Plus Preview a été lancé le 30 mars 2026, avec une fenêtre de contexte d'un million de tokens, un raisonnement par chaîne de pensée obligatoire et un support d'utilisation d'outils. Il est actuellement entièrement gratuit sur OpenRouter. Utilisez l'ID de modèle qwen/qwen3.6-plus-preview:free avec n'importe quel client compatible OpenAI pour commencer à envoyer des requêtes dès aujourd'hui.
Le modèle qui a fait son apparition discrètement
Alibaba Cloud a lancé Qwen 3.6 Plus Preview le 30 mars 2026. Aucune annonce spectaculaire. Pas de liste d'attente. Juste un nouveau modèle disponible sur OpenRouter à 0 $ par million de tokens.
Au cours de ses deux premiers jours, il a traité plus de 400 millions de tokens de complétion sur environ 400 000 requêtes. Les développeurs l'ont trouvé rapide.
Cet article vous guide à travers tout ce dont vous avez besoin pour démarrer : la configuration du compte, les clés API, des exemples de code fonctionnels en cURL, Python et Node.js, et des conseils spécifiques sur les domaines où ce modèle est le plus performant.
À la fin de ce guide, vous saurez exactement comment appeler Qwen 3.6 gratuitement, ce dont il est capable et où il présente des lacunes.
Ce que Qwen 3.6 apporte par rapport à la série 3.5
Le passage de 3.5 à 3.6 n'est pas incrémental. Trois choses ont changé de manière significative.
1. La fenêtre de contexte est passée à 1 million de tokens
Qwen 3.5 avait une fenêtre de contexte de 32K à 128K selon la variante. Qwen 3.6 prend en charge une entrée d'un million de tokens.
Pour le dire en termes pratiques : 1 million de tokens représentent environ 750 000 mots. C'est suffisant pour alimenter le modèle avec une base de code entière, une année de journaux Slack, une bibliothèque complète de documents juridiques ou un vaste corpus de recherche en une seule requête.
La plupart des modèles gratuits plafonnent à 8K ou 32K. Obtenir 1M de tokens gratuitement est rare.
2. Le raisonnement est intégré, non optionnel
Qwen 3.6 utilise des tokens de raisonnement obligatoires. Avant que le modèle ne produise sa réponse finale, il génère une chaîne de pensée interne. Vous n'avez pas besoin de le solliciter avec « réfléchissez étape par étape » ou toute autre instruction spéciale.
C'est le même modèle que DeepSeek R1 a popularisé. La différence est que Qwen 3.6 l'applique aux tâches de codage, de développement front-end et de résolution de problèmes généraux, pas seulement aux mathématiques.
3. Le comportement d'agent est plus fiable
L'appel d'outils dans la série 3.5 était incohérent. Les fonctions étaient appelées avec des types d'arguments incorrects, ou le modèle hallucinant un appel de fonction qui n'existait pas.
Qwen 3.6 y répond directement. Selon la propre description d'Alibaba Cloud, il « offre un raisonnement plus puissant et un comportement d'agent plus fiable par rapport à la série 3.5 ». En pratique, cela signifie moins d'appels d'outils défectueux dans les flux de travail multi-étapes.
Le modèle est spécifiquement réglé pour trois tâches :
- Codage agentique (génération de code multi-étapes avec utilisation d'outils)
- Développement front-end (génération de composants HTML, CSS, JavaScript)
- Résolution de problèmes complexes (recherche, analyse, résumé de contexte long)
Comment accéder à Qwen 3.6 gratuitement
Vous avez besoin de deux choses : un compte OpenRouter et une clé API. Aucune carte de crédit n'est requise pour les modèles gratuits.
Étape 1 : Créez votre compte OpenRouter
Allez sur openrouter.ai et inscrivez-vous avec un e-mail ou un compte Google. L'ensemble du processus prend moins de deux minutes.
Les modèles gratuits ne vous obligent pas à ajouter un mode de paiement. Vous obtenez un accès immédiat après la vérification de l'e-mail.
Étape 2 : Générez une clé API
- Cliquez sur votre avatar de profil dans le coin supérieur droit
- Sélectionnez Clés API dans le menu déroulant
- Cliquez sur Créer une clé
- Donnez-lui un nom (par exemple,
qwen-test) et cliquez sur Créer - Copiez la clé. Elle commence par
sk-or-v1-...
Stockez-la dans un endroit sûr. OpenRouter ne vous la montrera plus.
Étape 3 : Envoyez votre première requête
L'ID du modèle est qwen/qwen3.6-plus-preview:free.
OpenRouter utilise le même format de requête que l'API OpenAI, donc tout client compatible OpenAI fonctionne sans modification.
cURL :
curl https://openrouter.ai/api/v1/chat/completions \
-H "Authorization: Bearer sk-or-v1-YOUR_KEY_HERE" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [
{
"role": "user",
"content": "Write a Python function that parses a JWT token and returns the payload as a dictionary."
}
]
}'
Python (bibliothèque requests) :
import requests
def call_qwen(prompt: str, api_key: str) -> str:
response = requests.post(
"https://openrouter.ai/api/v1/chat/completions",
headers={
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json",
},
json={
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [{"role": "user", "content": prompt}],
},
timeout=60,
)
response.raise_for_status()
return response.json()["choices"][0]["message"]["content"]
result = call_qwen(
"Write a Python function that parses a JWT token and returns the payload.",
api_key="sk-or-v1-YOUR_KEY_HERE"
)
print(result)
Node.js (fetch) :
async function callQwen(prompt, apiKey) {
const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
method: "POST",
headers: {
"Authorization": `Bearer ${apiKey}`,
"Content-Type": "application/json",
},
body: JSON.stringify({
model: "qwen/qwen3.6-plus-preview:free",
messages: [{ role: "user", content: prompt }],
}),
});
if (!response.ok) {
throw new Error(`OpenRouter error: ${response.status} ${await response.text()}`);
}
const data = await response.json();
return data.choices[0].message.content;
}
callQwen(
"Write a JavaScript function that validates an email address.",
"sk-or-v1-YOUR_KEY_HERE"
).then(console.log);
Python avec le SDK OpenAI :
Si vous utilisez déjà le SDK Python d'OpenAI, vous pouvez le diriger vers OpenRouter sans autre modification :
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-YOUR_KEY_HERE",
)
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "system",
"content": "You are a senior backend engineer. Write clean, production-ready code."
},
{
"role": "user",
"content": "Write a Python function that retries a failed HTTP request up to 3 times with exponential backoff."
}
],
)
print(response.choices[0].message.content)
Utilisation d'outils et workflows agentiques
L'utilisation d'outils est l'un des points forts de Qwen 3.6 au niveau gratuit. Voici un exemple fonctionnel :
from openai import OpenAI
import json
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-YOUR_KEY_HERE",
)
# Define the tools available to the model
tools = [
{
"type": "function",
"function": {
"name": "search_api_docs",
"description": "Search the API documentation for a specific endpoint or parameter",
"parameters": {
"type": "object",
"properties": {
"query": {
"type": "string",
"description": "The search query"
},
"version": {
"type": "string",
"enum": ["v1", "v2", "v3"],
"description": "API version to search"
}
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "run_api_test",
"description": "Execute a test request against an API endpoint",
"parameters": {
"type": "object",
"properties": {
"endpoint": {"type": "string"},
"method": {"type": "string", "enum": ["GET", "POST", "PUT", "DELETE"]},
"body": {"type": "object"}
},
"required": ["endpoint", "method"]
}
}
}
]
messages = [
{
"role": "user",
"content": "Find documentation for the /users endpoint and run a test GET request against it."
}
]
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=messages,
tools=tools,
tool_choice="auto",
)
message = response.choices[0].message
# Check whether the model wants to call a tool
if message.tool_calls:
for tool_call in message.tool_calls:
print(f"Tool: {tool_call.function.name}")
args = json.loads(tool_call.function.arguments)
print(f"Arguments: {json.dumps(args, indent=2)}")
else:
print(message.content)
Le modèle générera un appel de fonction structuré plutôt que d'halluciner une réponse libre. Vous exécutez ensuite la fonction dans votre propre code et renvoyez le résultat lors du tour suivant.
C'est ainsi que sont construits les workflows agentiques multi-étapes : le modèle appelle des outils, votre code les exécute, et vous bouclez jusqu'à ce que la tâche soit terminée.
Utiliser la fenêtre de contexte d'un million de tokens
Un contexte d'1M de tokens n'est pas utile pour des questions simples. Il est conçu pour les tâches où vous devez fournir au modèle une grande quantité de contexte en une seule fois.
Voici trois scénarios où cela est réellement important :
Examen complet de la base de code
Alimentez le modèle avec l'intégralité de votre base de code (dans la limite des tokens) et demandez-lui d'identifier les problèmes de sécurité, les modèles incohérents ou les fonctions non documentées.
import os
from pathlib import Path
from openai import OpenAI
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-YOUR_KEY_HERE",
)
def load_codebase(directory: str, extensions: list[str]) -> str:
"""Load all source files from a directory into a single string."""
content_parts = []
for path in Path(directory).rglob("*"):
if path.suffix in extensions and path.is_file():
try:
text = path.read_text(encoding="utf-8", errors="ignore")
content_parts.append(f"--- FILE: {path} ---\n{text}\n")
except Exception:
continue
return "\n".join(content_parts)
codebase = load_codebase("./src", [".py", ".js", ".ts"])
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "user",
"content": f"Review this codebase and identify:\n1. Security vulnerabilities\n2. Functions with no error handling\n3. Inconsistent naming conventions\n\nCodebase:\n{codebase}"
}
],
)
print(response.choices[0].message.content)
Analyse de documents volumineux
Fournissez un long document juridique, un rapport financier ou un article de recherche et posez des questions spécifiques à ce sujet.
with open("annual_report_2025.txt", "r") as f:
document = f.read()
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=[
{
"role": "user",
"content": f"Extract all mentions of API rate limits and pricing changes from this document:\n\n{document}"
}
],
)
Conversation multi-tours avec historique complet
Gardez l'historique complet de la conversation en contexte sans troncation, utile pour les longues sessions de débogage ou les entretiens techniques.
conversation = []
def chat(user_message: str) -> str:
conversation.append({"role": "user", "content": user_message})
response = client.chat.completions.create(
model="qwen/qwen3.6-plus-preview:free",
messages=conversation,
)
assistant_message = response.choices[0].message.content
conversation.append({"role": "assistant", "content": assistant_message})
return assistant_message
# Long back-and-forth debugging session
print(chat("I'm getting a 401 error from the GitHub API. Here's my code..."))
print(chat("I added the token but now I get a 403. The token has repo scope."))
print(chat("The repo is private. What scopes do I actually need?"))
Tester les requêtes API OpenRouter avec Apidog
Lorsque vous construisez sur l'API OpenRouter, le débogage des requêtes échouées devient rapidement fastidieux. Vous effectuez des requêtes HTTP, vérifiez les réponses JSON et itérez sur vos invites. Faire cela depuis la ligne de commande ou Postman est lent.
Apidog vaut la peine d'être essayé ici. C'est un client API gratuit qui gère la construction des requêtes, l'inspection des réponses et l'automatisation des tests en un seul endroit.
Pour tester le point de terminaison Qwen 3.6 dans Apidog :
- Créez une nouvelle requête POST vers
https://openrouter.ai/api/v1/chat/completions - Ajoutez votre en-tête
Authorization: Bearer sk-or-v1-... - Définissez le corps en JSON avec vos champs
modeletmessages - Envoyez la requête et inspectez la réponse
Vous pouvez l'enregistrer en tant que collection, basculer entre les ID de modèle pour comparer les sorties, et écrire des tests automatisés qui vérifient la structure de la réponse, s'assurent que choices[0].message.content n'est pas vide, ou affirment que les appels d'outils contiennent le nom de fonction attendu.
Si vous construisez une application qui appelle OpenRouter, écrire quelques tests de requêtes dans Apidog dès le début vous fera gagner du temps lorsque le modèle se comporte de manière inattendue.
Limites du niveau gratuit à connaître avant de développer avec ce modèle
Qwen 3.6 est gratuit maintenant. Cela ne durera pas indéfiniment, et il y a des contraintes pratiques à prendre en compte.
Les limites de débit sont partagées. Les modèles gratuits sur OpenRouter partagent leur capacité entre tous les utilisateurs. Pendant les heures de pointe (généralement le soir aux États-Unis), vous constaterez une latence plus élevée et des erreurs occasionnelles de limite de débit. Intégrez une logique de réessai dans tout code de production.
import time
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=2,
status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
response = session.post(
"https://openrouter.ai/api/v1/chat/completions",
headers={"Authorization": "Bearer sk-or-v1-YOUR_KEY_HERE"},
json={
"model": "qwen/qwen3.6-plus-preview:free",
"messages": [{"role": "user", "content": "Hello"}],
},
timeout=30,
)
Les données sont enregistrées. La page du modèle d'OpenRouter indique que « le modèle collecte des données d'invite et de complétion qui peuvent être utilisées pour améliorer le modèle ». N'envoyez pas de clés API, de mots de passe ou d'informations personnellement identifiables via ce point de terminaison.
Statut de prévisualisation. Ceci est une version préliminaire. Le comportement du modèle peut changer. Si vous l'utilisez pour l'inférence en production, épinglez vos tests d'intégration à l'ID de modèle actuel et surveillez les régressions.
Texte uniquement. Qwen 3.6 accepte une entrée textuelle et produit une sortie textuelle. Pas d'images, pas d'audio, pas de téléchargements de fichiers.
Cas d'utilisation concrets
Construire un agent de revue de code. Une équipe développant un outil interne de revue de PR a alimenté Qwen 3.6 avec l'intégralité des différences de leurs requêtes de tirage (parfois plus de 10 000 lignes) et a obtenu des commentaires détaillés sur les erreurs logiques, les tests manquants et les problèmes de sécurité. La fenêtre de 1M de tokens a rendu cela possible sans segmentation.
Génération de composants front-end. Un développeur solo construisant un tableau de bord SaaS a utilisé Qwen 3.6 pour générer des composants React à partir de spécifications de conception. Le modèle a produit du TypeScript propre avec des types de props appropriés et un CSS réactif sans nécessiter de multiples passes de correction.
Synthèse de documentation API. Une équipe migrant entre des API de paiement tierces a transmis la documentation complète des deux API (chacune environ 100 000 tokens) en une seule requête et a demandé une comparaison côte à côte des méthodes d'authentification, des formats de webhook et des limites de débit. Le modèle a renvoyé un tableau structuré en moins de 30 secondes.
Inscrivez-vous sur openrouter.ai, obtenez votre clé, et remplacez qwen/qwen3.6-plus-preview:free par tout modèle pour lequel vous payez actuellement.
FAQ
Qwen 3.6 est-il réellement gratuit ?
Oui. En mars 2026, le modèle est listé à 0 $ par million de tokens d'entrée et 0 $ par million de tokens de sortie sur OpenRouter. Le statut gratuit peut changer à la fin de la période de prévisualisation, alors vérifiez la page de tarification d'OpenRouter avant de construire quoi que ce soit qui dépende du maintien du coût à zéro.
Quelle est la limite de débit pour le niveau gratuit ?
OpenRouter ne publie pas de limites de débit exactes pour les modèles du niveau gratuit. En pratique, les modèles gratuits partagent leur capacité et sont soumis à des limitations de débit en cas de trafic intense. Commencez par une seule requête à la fois et ajoutez une logique de réessai avant d'augmenter la concurrence.
Puis-je utiliser Qwen 3.6 pour des projets commerciaux ?
Oui, OpenRouter autorise l'utilisation commerciale. Vérifiez la licence du modèle Qwen d'Alibaba Cloud pour toute restriction sur le modèle sous-jacent lui-même, en particulier si vous distribuez des sorties.
Pourquoi Qwen 3.6 met-il plus de temps à répondre que d'autres modèles ?
Les tokens de raisonnement obligatoires ajoutent de la latence. Avant de générer une réponse, le modèle passe par une chaîne de pensée interne. Pour des invites simples, cela peut ajouter quelques secondes. Pour des tâches de raisonnement complexes, la latence supplémentaire en vaut la peine. Utilisez le streaming si vous souhaitez afficher une sortie partielle au fur et à mesure de sa génération.
Existe-t-il un moyen de désactiver les tokens de raisonnement ?
Dans la prévisualisation actuelle, le raisonnement est obligatoire et ne peut pas être désactivé. Si vous avez besoin de réponses plus rapides sans chaîne de pensée, essayez une variante de modèle différente lorsqu'elle sera disponible, ou utilisez un modèle gratuit plus petit comme LLaMA 3.1 8B pour les tâches sensibles à la latence.
Comment la fenêtre de contexte d'1M de tokens affecte-t-elle le coût ?
Au niveau gratuit, cela n'a pas d'impact. Vous payez 0 $ quel que soit le nombre de tokens que vous envoyez. Gardez à l'esprit que les requêtes très volumineuses prennent plus de temps à être traitées et peuvent expirer sur le niveau gratuit. Commencez avec un délai d'attente de 30 à 60 secondes et augmentez-le pour les requêtes de plus de 100 000 tokens.