Authentification

Le menu /auth de premier lancement de Qwen Code propose trois options principales. Choisissez celle qui correspond à la façon dont vous souhaitez exécuter le CLI :

• Alibaba ModelStudio : configuration officielle recommandée. Ouvre un sous-menu avec Coding Plan (pour les développeurs individuels · quota hebdomadaire inclus), Token Plan (pour les équipes et les entreprises · facturation à l’usage avec un endpoint dédié) ou Standard API Key (connectez-vous avec une clé API ModelStudio existante).
• Third-party Providers : choisissez un fournisseur intégré et connectez-vous avec une clé API (DeepSeek, MiniMax, Z.AI, Idealab, ModelScope, OpenRouter, Requesty).
• Custom Provider : connectez manuellement un serveur local, un proxy ou un fournisseur non pris en charge – compatible avec OpenAI, Anthropic, Gemini et d’autres endpoints compatibles.

Option 1 : Qwen OAuth (Abandonné)

• Fonctionnement : au premier démarrage, Qwen Code ouvre une page de connexion dans le navigateur. Après connexion, 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 : pas de gestion de clé API, actualisation automatique des identifiants.
• Coût et quota : l’offre gratuite a été interrompue à compter du 15/04/2026.

Lancez le CLI et suivez le flux du navigateur :

qwen

Qwen OAuth n’est plus proposé comme entrée sélectionnable dans la boîte de dialogue /auth ; exécutez /auth et choisissez l’une des options actuelles (Alibaba ModelStudio, Third-party Providers ou Custom Provider) à la place.

💳 Option 2 : Alibaba Cloud Coding Plan

Utilisez cette option si vous souhaitez des coûts prévisibles avec diverses options de modèles et des quotas d’utilisation plus élevés.

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

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

Configuration interactive

Exécutez qwen dans le terminal pour lancer Qwen Code, puis lancez la commande /auth, sélectionnez Alibaba ModelStudio et choisissez Coding Plan dans le sous-menu. Choisissez votre région, puis saisissez votre clé sk-sp-xxxxxxxxx.

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

Configuration sans tête ou scriptée

Pour CI, conteneurs ou scripts, configurez le Coding Plan avec des variables d’environnement ou settings.json au lieu de la commande supprimée qwen auth coding-plan.

export BAILIAN_CODING_PLAN_API_KEY="sk-sp-xxxxxxxxx"
export OPENAI_BASE_URL="https://coding.dashscope.aliyuncs.com/v1"
export OPENAI_MODEL="qwen3-coder-plus"

Utilisez https://coding.dashscope.aliyuncs.com/v1 pour l’endpoint Chine (Beijing), ou https://coding-intl.dashscope.aliyuncs.com/v1 pour l’endpoint international.

Alternative : configuration via settings.json

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

{
  "modelProviders": {
    "openai": {
      "protocol": "openai",
      "models": [
        {
          "id": "qwen3-coder-plus",
          "name": "qwen3-coder-plus (Coding Plan)",
          "baseUrl": "https://coding.dashscope.aliyuncs.com/v1",
          "description": "qwen3-coder-plus du 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 : Clé API (flexible)

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

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

Le moyen le plus simple de démarrer avec l’authentification par clé API est de tout mettre dans un seul fichier ~/.qwen/settings.json. Voici un exemple complet et prêt à l’emploi :

{
  "modelProviders": {
    "openai": {
      "protocol": "openai",
      "models": [
        {
          "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 éditant ~/.qwen/settings.json, puis 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 ; envKey (le nom de la variable d’environnement contenant votre clé API) est facultatif et recommandé – lorsqu’il est omis, le système utilise la clé d’environnement par défaut du type d’authentification (par ex. OPENAI_API_KEY pour openai).

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

{
  "modelProviders": {
    "openai": {
      "protocol": "openai",
      "models": [
        {
          "id": "gpt-4o",
          "name": "GPT-4o",
          "envKey": "OPENAI_API_KEY",
          "baseUrl": "https://api.openai.com/v1"
        }
      ]
    },
    "anthropic": {
      "protocol": "anthropic",
      "models": [
        {
          "id": "claude-sonnet-4-20250514",
          "name": "Claude Sonnet 4",
          "envKey": "ANTHROPIC_API_KEY"
        }
      ]
    },
    "gemini": {
      "protocol": "gemini",
      "models": [
        {
          "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 de modelProviders et les options avancées comme generationConfig, customHeaders et extra_body, consultez la Référence 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 haute à la plus basse :

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

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

# Alibaba Dashscope
export DASHSCOPE_API_KEY="sk-..."
 
# OpenAI / compatible OpenAI
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 non encore présentes dans process.env sont chargées.

Ordre de recherche (à partir du répertoire courant, en remontant vers /) :

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

Si rien n’est trouvé, le système utilise votre répertoire personnel :

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

3. settings.json → champ env (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 repli de la plus basse priorité – appliquées uniquement lorsqu’une 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 garder au même endroit, mais sachez que settings.json peut être partagé ou synchronisé – préférez les fichiers .env pour les secrets sensibles.

Récapitulatif des priorités :

Étape 3 : Basculer les modèles 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 (par ex. openai, anthropic, gemini). Votre sélection est conservée entre les sessions.

Vous pouvez également basculer directement les modèles avec un argument de ligne de commande, ce qui est pratique lorsque vous travaillez dans plusieurs terminaux.

# Dans un terminal
qwen --model "qwen3-coder-plus"
 
# Dans un autre terminal
qwen --model "qwen3.5-plus"

Commande CLI qwen auth supprimée

La commande CLI autonome qwen auth a été supprimée. Utilisez ces remplacements à la place :

Les invocations héritées comme qwen auth status affichent désormais un avis de suppression avec ces chemins de migration.

Notes de sécurité

• Ne commettez pas les clés API dans le contrôle de version.
• Préférez .qwen/.env pour les secrets propres au projet (et gardez-le hors de git).
• Traitez la sortie de votre terminal comme sensible si elle imprime des identifiants pour vérification.