Authentification

Qwen Code prend en charge trois méthodes d’authentification. Choisissez celle qui correspond à votre façon d’utiliser la CLI :

• Qwen OAuth : connectez-vous avec votre compte qwen.ai dans un navigateur. Gratuit avec un quota quotidien.
• Alibaba Cloud Coding Plan : utilisez une clé API d’Alibaba Cloud. Abonnement payant avec un large choix de modèles et des quotas plus élevés.
• API Key : utilisez votre propre clé API. Flexible selon vos besoins — prend en charge OpenAI, Anthropic, Gemini et d’autres endpoints compatibles.

Option 1 : Qwen OAuth (Gratuit)

Choisissez cette option si vous souhaitez la configuration la plus simple et que vous utilisez des modèles Qwen.

• Fonctionnement : au premier démarrage, Qwen Code ouvre une page de connexion dans le navigateur. Une fois l’opération terminée, les identifiants sont mis en cache localement, ce qui évite généralement de devoir se reconnecter.
• Prérequis : un compte qwen.ai + un accès Internet (au moins pour la première connexion).
• Avantages : aucune gestion de clé API, rafraîchissement automatique des identifiants.
• Coût et quota : gratuit, avec un quota de 60 requêtes/minute et 1 000 requêtes/jour.

Démarrez la CLI et suivez le flux dans le navigateur :

qwen

Ou authentifiez-vous directement sans démarrer de session :

qwen auth qwen-oauth

💳 Option 2 : Alibaba Cloud Coding Plan

Choisissez cette option si vous souhaitez des coûts prévisibles, un large choix de modèles et des quotas d’utilisation plus élevés.

• Fonctionnement : abonnez-vous au Coding Plan avec un tarif mensuel fixe, puis configurez Qwen Code pour utiliser l’endpoint dédié et votre clé API d’abonnement.
• Prérequis : obtenez un abonnement Coding Plan actif depuis Alibaba Cloud ModelStudio(Beijing)  ou Alibaba Cloud ModelStudio(intl) , selon la région de votre compte.
• Avantages : large choix de modèles, quotas d’utilisation plus élevés, coûts mensuels prévisibles, accès à une vaste gamme de modèles (Qwen, GLM, Kimi, Minimax et autres).
• Coût et quota : consultez la documentation du Coding Plan Aliyun ModelStudio Beijing  intl .

Le Alibaba Cloud Coding Plan est disponible dans deux régions :

Configuration interactive

Vous pouvez configurer l’authentification Coding Plan de deux manières :

Option A : Depuis le terminal (recommandé pour une première configuration)

# Interactive — prompts for region and API key
qwen auth coding-plan
 
# Or non-interactive — pass region and key directly
qwen auth coding-plan --region china --key sk-sp-xxxxxxxxx

Option B : Dans une session Qwen Code

Saisissez qwen dans le terminal pour lancer Qwen Code, puis exécutez la commande /auth et sélectionnez Alibaba Cloud Coding Plan. Choisissez votre région, puis saisissez votre clé sk-sp-xxxxxxxxx.

Après l’authentification, utilisez la commande /model pour basculer entre tous les modèles pris en charge par le Alibaba Cloud Coding Plan (y compris qwen3.5-plus, qwen3-coder-plus, qwen3-coder-next, qwen3-max, glm-4.7 et kimi-k2.5).

Alternative : configurer via settings.json

Si vous préférez ignorer le flux interactif /auth, ajoutez ce qui suit à ~/.qwen/settings.json :

{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3-coder-plus",
        "name": "qwen3-coder-plus (Coding Plan)",
        "baseUrl": "https://coding.dashscope.aliyuncs.com/v1",
        "description": "qwen3-coder-plus from Alibaba Cloud Coding Plan",
        "envKey": "BAILIAN_CODING_PLAN_API_KEY"
      }
    ]
  },
  "env": {
    "BAILIAN_CODING_PLAN_API_KEY": "sk-sp-xxxxxxxxx"
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "qwen3-coder-plus"
  }
}

🚀 Option 3 : API Key (Flexible)

Choisissez cette option si vous souhaitez vous connecter à des fournisseurs tiers tels qu’OpenAI, Anthropic, Google, Azure OpenAI, OpenRouter, ModelScope ou un endpoint auto-hébergé. Prend en charge plusieurs protocoles et fournisseurs.

Recommandé : configuration en un seul fichier via settings.json

La méthode la plus simple pour commencer avec l’authentification par clé API est de tout regrouper dans un seul fichier ~/.qwen/settings.json. Voici un exemple complet et prêt à l’emploi :

{
  "modelProviders": {
    "openai": [
      {
        "id": "qwen3-coder-plus",
        "name": "qwen3-coder-plus",
        "baseUrl": "https://dashscope.aliyuncs.com/compatible-mode/v1",
        "description": "Qwen3-Coder via Dashscope",
        "envKey": "DASHSCOPE_API_KEY"
      }
    ]
  },
  "env": {
    "DASHSCOPE_API_KEY": "sk-xxxxxxxxxxxxx"
  },
  "security": {
    "auth": {
      "selectedType": "openai"
    }
  },
  "model": {
    "name": "qwen3-coder-plus"
  }
}

Rôle de chaque champ :

Après avoir enregistré le fichier, exécutez simplement qwen — aucune configuration interactive /auth n’est nécessaire.

Le concept clé est celui des Model Providers (modelProviders) : Qwen Code prend en charge plusieurs protocoles API, pas seulement OpenAI. Vous configurez les fournisseurs et modèles disponibles en modifiant ~/.qwen/settings.json, puis vous basculez entre eux à l’exécution avec la commande /model.

Protocoles pris en charge

Étape 1 : Configurer les modèles et fournisseurs dans ~/.qwen/settings.json

Définissez les modèles disponibles pour chaque protocole. Chaque entrée de modèle nécessite au minimum un id et un envKey (le nom de la variable d’environnement contenant votre clé API).

Modifiez ~/.qwen/settings.json (créez-le s’il n’existe pas). Vous pouvez combiner plusieurs protocoles dans un seul fichier — voici un exemple multi-fournisseurs montrant uniquement la section modelProviders :

{
  "modelProviders": {
    "openai": [
      {
        "id": "gpt-4o",
        "name": "GPT-4o",
        "envKey": "OPENAI_API_KEY",
        "baseUrl": "https://api.openai.com/v1"
      }
    ],
    "anthropic": [
      {
        "id": "claude-sonnet-4-20250514",
        "name": "Claude Sonnet 4",
        "envKey": "ANTHROPIC_API_KEY"
      }
    ],
    "gemini": [
      {
        "id": "gemini-2.5-pro",
        "name": "Gemini 2.5 Pro",
        "envKey": "GEMINI_API_KEY"
      }
    ]
  }
}

Champs ModelConfig (chaque entrée dans modelProviders) :

Pour le schéma complet modelProviders et les options avancées comme generationConfig, customHeaders et extra_body, consultez la Référence des Model Providers.

Étape 2 : Définir les variables d’environnement

Qwen Code lit les clés API depuis les variables d’environnement (spécifiées par envKey dans votre configuration de modèle). Il existe plusieurs façons de les fournir, listées ci-dessous de la priorité la plus élevée à la plus basse :

1. Environnement shell / export (priorité la plus élevée)

Définissez-les directement dans votre profil shell (~/.zshrc, ~/.bashrc, etc.) ou en ligne avant le lancement :

 
# Alibaba Dashscope
export DASHSCOPE_API_KEY="sk-..."
 
# OpenAI / OpenAI-compatible
export OPENAI_API_KEY="sk-..."
 
# Anthropic
export ANTHROPIC_API_KEY="sk-ant-..."
 
# Google GenAI
export GEMINI_API_KEY="AIza..."

2. Fichiers .env

Qwen Code charge automatiquement le premier fichier .env qu’il trouve (les variables ne sont pas fusionnées entre plusieurs fichiers). Seules les variables absentes de process.env sont chargées.

Ordre de recherche (depuis le répertoire courant, en remontant vers /) :

1. .qwen/.env (recommandé — isole les variables Qwen Code des autres outils)
2. .env

Si aucun fichier n’est trouvé, il se rabat sur votre répertoire personnel :

3. ~/.qwen/.env
4. ~/.env

3. Champ env dans settings.json (priorité la plus basse)

Vous pouvez également définir les clés API directement dans ~/.qwen/settings.json sous la clé env. Elles sont chargées comme solution de secours de priorité la plus basse — appliquées uniquement si la variable n’est pas déjà définie par l’environnement système ou les fichiers .env.

{
  "env": {
    "DASHSCOPE_API_KEY": "sk-...",
    "OPENAI_API_KEY": "sk-...",
    "ANTHROPIC_API_KEY": "sk-ant-..."
  }
}

C’est l’approche utilisée dans l’exemple de configuration en un seul fichier ci-dessus. C’est pratique pour tout centraliser, mais gardez à l’esprit que settings.json peut être partagé ou synchronisé — privilégiez les fichiers .env pour les secrets sensibles.

Résumé des priorités :

Étape 3 : Changer de modèle avec /model

Après avoir lancé Qwen Code, utilisez la commande /model pour basculer entre tous les modèles configurés. Les modèles sont regroupés par protocole :

/model

Le sélecteur affichera tous les modèles de votre configuration modelProviders, regroupés par protocole (ex. openai, anthropic, gemini). Votre sélection est conservée entre les sessions.

Vous pouvez également changer de modèle directement via un argument en ligne de commande, ce qui est pratique lorsque vous travaillez sur plusieurs terminaux.

# In one terminal
 
qwen --model "qwen3-coder-plus"
 
# In another terminal
 
qwen --model "qwen3.5-plus"

Commande CLI qwen auth

En plus de la commande slash /auth en session, Qwen Code propose la commande CLI autonome qwen auth pour gérer l’authentification directement depuis le terminal — sans avoir à démarrer une session interactive au préalable.

Mode interactif

Exécutez qwen auth sans arguments pour afficher un menu interactif :

qwen auth

Un sélecteur avec navigation par flèches s’affiche :

Select authentication method:

> Qwen OAuth - Free · Up to 1,000 requests/day · Qwen latest models
  Alibaba Cloud Coding Plan - Paid · Up to 6,000 requests/5 hrs · All Alibaba Cloud Coding Plan Models

(Use ↑ ↓ arrows to navigate, Enter to select, Ctrl+C to exit)

Sous-commandes

Exemples :

# Authenticate with Qwen OAuth directly
qwen auth qwen-oauth
 
# Set up Coding Plan interactively (prompts for region and key)
qwen auth coding-plan
 
# Set up Coding Plan non-interactively (useful for CI/scripting)
qwen auth coding-plan --region china --key sk-sp-xxxxxxxxx
 
# Check your current auth configuration
qwen auth status

Notes de sécurité

• Ne commitez pas de clés API dans le contrôle de version.
• Privilégiez .qwen/.env pour les secrets locaux au projet (et excluez-le de git).
• Considérez la sortie de votre terminal comme sensible si elle affiche des identifiants pour vérification.