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.
Essayez Apidog 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.
En deux jours, plus de 400 millions de tokens de complétion, sur environ 400 000 requêtes. Les développeurs l'ont trouvé rapide.
Ce guide propose les étapes concrètes pour démarrer immédiatement : création de compte, gestion des clés API, exemples de code en cURL, Python et Node.js, et des conseils sur les cas d'usage où ce modèle excelle.
💡 Astuce : Pour tester et déboguer vos requêtes API d'IA de manière fiable, Apidog est un choix pertinent. Gratuit, il fonctionne avec toute API REST, dont OpenRouter.
À la fin de ce guide, vous saurez exactement comment appeler Qwen 3.6 gratuitement, ses points forts et ses limites.
Ce que Qwen 3.6 apporte par rapport à la série 3.5
La mise à jour de 3.5 à 3.6 introduit trois évolutions majeures :
1. Fenêtre de contexte à 1 million de tokens
Qwen 3.5 acceptait 32K à 128K tokens. Qwen 3.6 supporte 1 million de tokens d'entrée.
En pratique : 1 million de tokens équivalent à environ 750 000 mots. Cela permet d'envoyer une base de code complète, une année de logs Slack, une bibliothèque de documents juridiques ou un vaste corpus de recherche en une seule requête.
La plupart des modèles gratuits plafonnent à 8K ou 32K. Ici, 1M de tokens est accessible sans frais.
2. Raisonnement intégré, non optionnel
Qwen 3.6 génère systématiquement une chaîne de pensée avant de répondre. Il n'est pas nécessaire de le "forcer" avec des instructions type "réfléchis étape par étape".
C'est similaire à DeepSeek R1, mais Qwen 3.6 applique ce process à des tâches de codage, développement front-end et résolution de problèmes, pas seulement aux maths.
3. Comportement d'agent plus fiable
Dans la série 3.5, les appels d'outils étaient parfois erronés ou fantaisistes. Qwen 3.6 améliore la fiabilité : moins d'appels incorrects dans les workflows multi-étapes.
Le modèle est particulièrement adapté à :
- Génération de code multi-étapes avec outils
- Génération de composants front-end (HTML, CSS, JS)
- Recherche, analyse, résumé sur des contextes longs
Comment accéder à Qwen 3.6 gratuitement
Deux prérequis : un compte OpenRouter, une clé API. Aucun paiement requis pour les modèles gratuits.
Étape 1 : Créer votre compte OpenRouter
Rendez-vous sur openrouter.ai et inscrivez-vous (email ou Google). En moins de deux minutes, votre accès est opérationnel.
Étape 2 : Générer une clé API
- Cliquez sur votre avatar (coin supérieur droit)
- Sélectionnez Clés API
- Cliquez sur Créer une clé
- Donnez-lui un nom (ex :
qwen-test), validez - Copiez la clé commençant par
sk-or-v1-...
Stockez-la en lieu sûr. Elle ne sera plus affichée.
Étape 3 : Envoyer votre première requête
L'ID du modèle : qwen/qwen3.6-plus-preview:free
OpenRouter utilise le même format que l'API OpenAI. Tout client compatible fonctionne sans adaptation.
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 (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 SDK OpenAI :
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 un point fort de Qwen 3.6, même au niveau gratuit. Exemple pratique :
from openai import OpenAI
import json
client = OpenAI(
base_url="https://openrouter.ai/api/v1",
api_key="sk-or-v1-YOUR_KEY_HERE",
)
# Définition des outils disponibles
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
# Vérifier si le modèle veut appeler un outil
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ère un appel de fonction structuré. Exécutez la fonction côté code, renvoyez le résultat lors du tour suivant, et bouclez jusqu'à la fin du workflow.
Utiliser la fenêtre de contexte d'un million de tokens
Cette capacité est conçue pour les tâches nécessitant beaucoup de contexte. Trois scénarios clés :
Examen complet de la base de code
Envoyez toute votre base de code (dans la limite de tokens) pour une analyse sécurité, cohérence, documentation.
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:
"""Charge tous les fichiers source d'un dossier en une seule chaîne."""
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
Analysez des documents juridiques, financiers, ou scientifiques volumineux.
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 de toute la conversation, utile pour de longues sessions de debug ou d'entretien.
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
# Session longue de debug
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
Déboguer des requêtes échouées sur OpenRouter peut vite devenir fastidieux. Pour accélérer vos tests, Apidog centralise la construction des requêtes, l'inspection des réponses et l'automatisation des tests.
Pour tester Qwen 3.6 dans Apidog :
- Créez une requête POST vers
https://openrouter.ai/api/v1/chat/completions - Ajoutez l'en-tête
Authorization: Bearer sk-or-v1-... - Définissez le corps en JSON (champs
model,messages) - Envoyez la requête, inspectez la réponse.
Enregistrez la requête en collection, comparez des modèles, écrivez des tests qui valident la structure ou la présence de fonctions d'outils dans la réponse.
Pour toute application utilisant OpenRouter, prévoir ces tests dans Apidog dès le début vous fera gagner du temps lors de comportements inattendus.
Limites du niveau gratuit à connaître
Qwen 3.6 est actuellement gratuit, mais quelques contraintes s'appliquent :
Limites de débit partagées
Tous les utilisateurs gratuits partagent la capacité. Aux heures de pointe (soirée US), attendez-vous à plus de latence ou des erreurs (rate limit). Implémentez systématiquement une logique de retry.
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,
)
Collecte de données
OpenRouter indique que les prompts et complétions sont enregistrés à des fins d'amélioration. N'envoyez pas d'informations sensibles.
Statut de prévisualisation
Le comportement du modèle peut évoluer. Si vous l'utilisez en production, fixez vos tests sur l'ID de modèle et surveillez les changements.
Texte uniquement
Qwen 3.6 accepte uniquement du texte en entrée et sortie. Pas d'images, audio ou fichiers.
Cas d'utilisation concrets
- Agent de revue de code : En alimentant Qwen 3.6 avec les diffs complets d'une PR (plus de 10 000 lignes), l'équipe a obtenu des feedbacks détaillés sur la logique, les tests manquants et la sécurité. La fenêtre de 1M tokens a évité la segmentation.
- Génération de composants front-end : Un développeur a généré des composants React TypeScript propres avec CSS réactif à partir de specs design, sans multiples itérations.
- Synthèse de documentation API : Pour migrer entre deux APIs de paiement, une équipe a envoyé les docs complètes de chaque API (100K tokens chacune) et obtenu une comparaison structurée en moins de 30s.
Inscrivez-vous sur openrouter.ai, récupérez votre clé, et testez qwen/qwen3.6-plus-preview:free à la place de tout modèle payant.
FAQ
Qwen 3.6 est-il réellement gratuit ?
Oui. En mars 2026, le modèle est à 0 $ par million de tokens d'entrée ou de sortie sur OpenRouter. Ce statut peut évoluer. Vérifiez la page de tarification avant de construire un projet dépendant du gratuit.
Quelle est la limite de débit pour le niveau gratuit ?
OpenRouter ne publie pas de chiffres précis. Les modèles gratuits sont soumis à un partage de capacité, donc en cas de trafic important, attendez-vous à du throttling. Commencez avec une requête à la fois et ajoutez un système de retry.
Puis-je utiliser Qwen 3.6 pour des projets commerciaux ?
Oui, l'usage commercial est autorisé par OpenRouter. Vérifiez la licence Qwen d'Alibaba Cloud pour des éventuelles restrictions, surtout si vous redistribuez les sorties.
Pourquoi Qwen 3.6 est-il parfois plus lent que d'autres modèles ?
Le raisonnement obligatoire ajoute de la latence. Pour des prompts simples, cela peut prendre quelques secondes de plus. Pour des tâches complexes, la qualité du raisonnement compense ce délai. Utilisez le streaming pour afficher la sortie au fur et à mesure.
Peut-on désactiver les tokens de raisonnement ?
Non, actuellement c'est obligatoire. Pour des réponses plus rapides, essayez une variante différente ou un modèle plus petit (ex : LLaMA 3.1 8B) quand disponible.
La fenêtre de contexte d'1M tokens a-t-elle un impact sur le coût ?
Au niveau gratuit, aucun impact : 0 $ quelle que soit la taille. Notez que les requêtes très volumineuses sont plus lentes et peuvent expirer. Prévoyez un timeout de 30 à 60 secondes, plus si la requête dépasse 100 000 tokens.
Top comments (0)