# DeepSeek V4.1 Flash vs Claude Opus 5.5 : paies-tu Claude 23 fois trop cher ?

> DeepSeek V4.1 Flash vs Claude Opus 5.5 : benchmarks bien lus, facture d'un mois calculée, données, local, et DeepSeek dans Claude Code pas à pas.

Page : https://iatechnologie.com/deepseek-vs-claude-opus/
Mise à jour : 25 octobre 2026
Par Vincent Oliviero (https://iatechnologie.com/auteur/vincent-oliviero/), IA Technologie. Méthode et affiliation : https://iatechnologie.com/a-propos/#methode

**Pas tout à fait : DeepSeek V4.1 Flash 1017 coûte environ 23 fois moins cher que Claude Opus 5.5 par tâche, mais il reste un cran en dessous.** Sur le classement indépendant d'Artificial Analysis, une tâche coûte en moyenne 0,26 $ avec DeepSeek et 5,98 $ avec Opus 5.5, pour 45 points contre 58. Entre les deux modèles, c'est donc un choix de tâches plutôt qu'un remplacement : DeepSeek pour le volume, Opus pour ce qui doit être juste du premier coup. Et tu n'as pas à changer d'outil : DeepSeek V4.1 Flash tourne dans Claude Code, l'agent de code d'Anthropic, grâce au guide officiel de DeepSeek. Cette page te donne [l'installation pas à pas](#installer), [ma config prête à copier pour basculer d'un modèle à l'autre](#config), [la facture calculée](#facture), les benchmarks bien lus, ce que deviennent tes données et ce que vaut le local.

> **Vérifié le 25 octobre 2026** : annonce, tarifs, guide Claude Code, guide Anthropic API, codes d'erreur et cache de l'API DeepSeek ; documentation de Claude Code (installation, connexion à une passerelle) ; tarifs de l'API Claude ; pages Artificial Analysis de DeepSeek V4.1 Flash 1017, Claude Opus 5.5 et Claude Sonnet 5.5 ; pages OpenCode Go et OpenCode Zen (modèles gratuits) ; README de Strata. Les prix bougent vite chez DeepSeek : vérifie la page des tarifs avant un gros chantier.

**La vidéo en chapitres** : [c'est quoi](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=46s) · [les benchmarks](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=79s) · [le prix par tâche](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=121s) · [la cybersécurité](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=139s) · [les démos](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=171s) · [la même consigne](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=201s) · [pourquoi si peu cher](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=223s) · [tes données](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=256s) · [en local](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=274s) · [dans Claude Code](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=311s) · [la recherche web gratuite](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=347s) · [OpenCode Go](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=364s) · [mon avis](https://www.youtube.com/watch?v=dRmd3hQvGVY&t=380s)

**Sommaire** : [le verdict](#deepseek-v41-flash-vs-claude-opus-55--le-verdict-en-30-secondes) · [installer DeepSeek dans Claude Code](#installer) ([vérifier](#vérifier-que-claude-code-tourne-bien-sur-deepseek), [erreurs fréquentes](#les-erreurs-fréquentes-et-leur-solution), [revenir à Claude](#revenir-à-claude-en-une-commande)) · [bonus : ma config et la checklist](#config) · [c'est quoi V4.1 Flash 1017](#deepseek-v41-flash-1017-cest-quoi-) · [les benchmarks](#benchmarks-deepseek-vs-claude--les-lire-sans-se-faire-avoir) · [la facture](#facture) · [les accès gratuits et pas chers](#gratuit) · [tes données](#donnees) · [en local](#local) · [quand prendre lequel](#deepseek-ou-claude--le-choix-cas-par-cas)

## DeepSeek V4.1 Flash vs Claude Opus 5.5 : le verdict en 30 secondes

**Pour coder au quotidien avec un agent, DeepSeek V4.1 Flash 1017 fait le travail courant pour quelques centimes ; Claude Opus 5.5 reste devant dès que la tâche est difficile ou que la finition compte.** Les deux modèles tournent dans le même outil, Claude Code, donc tu peux garder les deux et choisir par tâche.

| | DeepSeek V4.1 Flash 1017 | Claude Opus 5.5 |
|---|---|---|
| Indice Artificial Analysis (25 oct. 2026) | 45 points (2e de sa catégorie, sur 121 modèles) | 58 points (1er sur 215 modèles) |
| Coût moyen d'une tâche du classement | 0,26 $ | 5,98 $ |
| Prix API (par million de tokens) | 0,30 $ entrée, 1,20 $ sortie, moitié prix hors heures pleines | 4 $ entrée, 20 $ sortie |
| Relecture en cache (par million) | 0,006 $ | 0,20 $ |
| Contexte | 1 million de tokens | 1 million de tokens |
| Dans Claude Code | Oui, guide officiel de DeepSeek | Oui, nativement |
| Données (accès officiel) | Stockées en Chine, entraînement possible | Politique d'Anthropic |
| Poids publics, local possible | Oui, licence MIT | Non |

Le « 23 fois moins cher » est un rapport de prix par tâche, mesuré au réglage maximal des deux modèles. Il ne dit pas que DeepSeek fait aussi bien : il dit qu'il fait un peu moins bien pour beaucoup moins cher. La vraie question, c'est donc la part de ton travail qui n'a pas besoin du meilleur modèle. Je la tranche [cas par cas plus bas](#deepseek-ou-claude--le-choix-cas-par-cas).

Utiliser DeepSeek V4.1 Flash dans Claude Code : installation pas à pas

**Claude Code, l'agent de code d'Anthropic, n'est pas un modèle : c'est l'outil qui pilote le modèle dans ton terminal. Et il accepte d'autres modèles que Claude : il suffit de lui donner une autre adresse d'API et une autre clé.** DeepSeek propose une API au format d'Anthropic, et publie lui-même la marche à suivre dans son [guide officiel Claude Code](https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code). Voici ce guide, complété par la documentation de Claude Code et par les pièges que la page de DeepSeek ne détaille pas.

### Avant de commencer : clé, crédit et Claude Code

1. **Crée un compte et recharge** sur [platform.deepseek.com](https://platform.deepseek.com/). L'API se paie sur un solde rechargé à l'avance : quelques dollars suffisent pour tester. À 0,30 $ le million de tokens, 5 $ représentent des dizaines de millions de tokens lus.
2. **Crée une clé API** dans la même console et copie-la : elle commence par `sk-` et ne s'affiche qu'une fois.
3. **Installe Claude Code** si ce n'est pas fait. La méthode recommandée par Anthropic est l'installeur natif : `curl -fsSL https://claude.ai/install.sh | bash` sur Mac et Linux, `irm https://claude.ai/install.ps1 | iex` dans PowerShell sous Windows. Le guide de DeepSeek passe par npm (`npm install -g @anthropic-ai/claude-code`) : ça marche aussi, avec Node.js 22 ou plus récent selon la [documentation de Claude Code](https://code.claude.com/docs/en/setup). Vérifie avec `claude --version`.

Tu n'as pas besoin d'abonnement Claude pour utiliser Claude Code avec DeepSeek : c'est ta clé DeepSeek qui paie.

### Mac et Linux : les lignes à coller

Ouvre un terminal, colle ces lignes en remplaçant ``, puis lance Claude Code dans ton projet :

```bash
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN=
export ANTHROPIC_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-flash[1m]
export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-flash
export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-flash
export CLAUDE_CODE_EFFORT_LEVEL=max
export CLAUDE_CODE_AUTO_COMPACT_WINDOW=786432
cd /chemin/vers/ton-projet
claude
```

Sous zsh (le terminal par défaut du Mac), si `deepseek-flash[1m]` provoque l'erreur `no matches found`, mets la valeur entre guillemets : `export ANTHROPIC_MODEL="deepseek-flash[1m]"`. Les crochets sont lus comme un motif de fichiers par zsh.

### Windows : la version PowerShell

Dans PowerShell (ton invite commence par `PS C:\`), la syntaxe change mais les valeurs sont les mêmes :

```powershell
$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN=""
$env:ANTHROPIC_MODEL="deepseek-flash[1m]"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-flash[1m]"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-flash[1m]"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-flash"
$env:CLAUDE_CODE_SUBAGENT_MODEL="deepseek-flash"
$env:CLAUDE_CODE_EFFORT_LEVEL="max"
$env:CLAUDE_CODE_AUTO_COMPACT_WINDOW="786432"
cd C:\chemin\vers\ton-projet
claude
```

Dans l'invite de commandes classique (`C:\` sans `PS`), ni `export` ni `$env:` ne marchent : ouvre PowerShell. Et sous WSL, utilise la version Linux.

### Ce que fait chaque ligne (et pourquoi deepseek-flash partout)

- **`ANTHROPIC_BASE_URL`** envoie les requêtes de Claude Code vers DeepSeek au lieu d'Anthropic.
- **`ANTHROPIC_AUTH_TOKEN`** porte ta clé DeepSeek. Selon la documentation de Claude Code, cette variable passe devant ta connexion claude.ai, qui reste enregistrée mais inutilisée tant que la variable existe.
- **Les quatre variables de modèle** remplacent les noms de modèles que Claude Code demande. C'est le point que je souligne dans la vidéo : DeepSeek traduit lui-même les noms de Claude qu'il reçoit, et **tout nom qui commence par `claude-opus` part sur `deepseek-v4-pro`**, facturé au prix de V4 Pro (1,32 $ en entrée et 3,96 $ en sortie, au lieu de 0,30 $ et 1,20 $), alors que Flash 1017 le bat au classement d'Artificial Analysis. Les noms Sonnet et Haiku, eux, partent sur Flash.
- **`[1m]`** demande à Claude Code d'utiliser une fenêtre de contexte d'un million de tokens, celle du modèle.
- **`CLAUDE_CODE_SUBAGENT_MODEL`** fixe le modèle des sous-agents, ces assistants que Claude Code lance en parallèle pour explorer ou tester.
- **`CLAUDE_CODE_EFFORT_LEVEL=max`** pousse le raisonnement au maximum. C'est le réglage auquel Artificial Analysis a mesuré les 45 points ; un niveau plus bas (`high`) fait réfléchir moins longtemps, donc consomme moins de tokens de sortie, sans chiffre officiel sur la perte de qualité.
- **`CLAUDE_CODE_AUTO_COMPACT_WINDOW`** (786432) dit à Claude Code de résumer la conversation vers 768 000 tokens, avant la limite du million.

Ces lignes ne valent que pour le terminal où tu les tapes : ferme-le, elles disparaissent. Pour un réglage durable sans perdre Claude, va directement au [bonus](#config).

### Vérifier que Claude Code tourne bien sur DeepSeek

Ne demande pas au modèle « qui es-tu ? » : il peut se tromper sur son propre nom. Fais plutôt ces trois contrôles.

1. **Dans Claude Code, tape `/status`.** La ligne `Anthropic base URL` doit afficher `https://api.deepseek.com/anthropic`, et une ligne `Auth token` doit citer `ANTHROPIC_AUTH_TOKEN`. Si tu vois plutôt une ligne de connexion à ton compte claude.ai, la variable n'est pas arrivée jusqu'à la session.
2. **Envoie une petite consigne**, par exemple « liste les fichiers de ce dossier et résume le README ».
3. **Ouvre la page d'utilisation de la console DeepSeek** : la consommation doit apparaître sous `deepseek-flash`. Si tu vois `deepseek-v4-pro`, une des variables de modèle manque.

Pour tester la clé avant même d'ouvrir Claude Code, cette requête d'un seul token suffit (Mac et Linux, avec les exports ci-dessus) :

```bash
curl -sS -X POST "$ANTHROPIC_BASE_URL/v1/messages" \
  -H "Authorization: Bearer $ANTHROPIC_AUTH_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"deepseek-flash","max_tokens":1,"messages":[{"role":"user","content":"."}]}'
```

Une réponse qui commence par `{"id":` prouve que l'adresse et la clé marchent. Un `401` veut dire que la clé est refusée.

### Les erreurs fréquentes et leur solution

| Ce que tu vois | Cause | Solution |
|---|---|---|
| Claude Code te demande de te connecter | La variable `ANTHROPIC_AUTH_TOKEN` n'est pas lue (autre terminal, ou placée dans le `.claude/settings.json` d'un projet pas encore approuvé) | Lance `claude` depuis le terminal où tu as fait les exports, ou mets les variables dans le bloc `env` de `~/.claude/settings.json` |
| Avertissement au démarrage citant deux sources d'identification (« auth may not work as expected ») | Ta connexion claude.ai et la clé DeepSeek sont toutes les deux actives | Les requêtes passent par la clé. Pour faire disparaître l'avertissement : `/logout`, ou utilise la [fonction du bonus](#config) |
| `401` (Authentication Fails) | Clé fausse, révoquée, ou copiée avec un espace | Recopie la clé ou crée-en une nouvelle |
| `402` (Insufficient Balance) | Solde DeepSeek à zéro | Recharge sur la console ; le solde offert éventuel est consommé en premier |
| `400` citant des champs inconnus (`Extra inputs are not permitted`…) | Claude Code envoie un champ expérimental que l'API de DeepSeek refuse | Ajoute `export CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1`, puis relance |
| `429` (Rate Limit Reached) | Trop de requêtes simultanées, souvent avec beaucoup de sous-agents | Attends quelques secondes ; DeepSeek autorise 2 500 requêtes simultanées sur Flash |
| `503` (Server Overloaded) | Serveurs de DeepSeek saturés | Réessaie plus tard ; les heures creuses sont aussi moins chargées |
| `zsh: no matches found: deepseek-flash[1m]` | zsh lit les crochets comme un motif | Mets la valeur entre guillemets |
| Facture plus haute que prévu, lignes `deepseek-v4-pro` | Une variable de modèle manque : un nom « opus » est parti sur V4 Pro | Vérifie les quatre variables de modèle et la variable des sous-agents |
| L'extension VS Code ignore DeepSeek | Elle lit ses propres réglages | Ajoute les variables dans `claudeCode.environmentVariables` des réglages de VS Code |

Les codes `401`, `402`, `429` et `503` et leurs causes viennent de la [page des erreurs de DeepSeek](https://api-docs.deepseek.com/quick_start/error_codes) ; les erreurs côté Claude Code, de sa [documentation de connexion à une passerelle](https://code.claude.com/docs/en/llm-gateway-connect). Deux réglages de l'API Anthropic sont ignorés par DeepSeek, selon son [guide de compatibilité](https://api-docs.deepseek.com/guides/anthropic_api) : `cache_control` (DeepSeek met en cache tout seul, rien à faire de ton côté) et `mcp_servers`. Tes serveurs MCP locaux, eux, continuent de marcher : c'est Claude Code qui les fait tourner sur ta machine.

### Revenir à Claude en une commande

Si tu as collé les exports dans un terminal, le plus simple est de **fermer ce terminal et d'en ouvrir un nouveau**. Pour rester dans le même, une commande suffit sur Mac et Linux :

```bash
unset ANTHROPIC_BASE_URL ANTHROPIC_AUTH_TOKEN ANTHROPIC_MODEL ANTHROPIC_DEFAULT_OPUS_MODEL ANTHROPIC_DEFAULT_SONNET_MODEL ANTHROPIC_DEFAULT_HAIKU_MODEL CLAUDE_CODE_SUBAGENT_MODEL CLAUDE_CODE_EFFORT_LEVEL CLAUDE_CODE_AUTO_COMPACT_WINDOW
```

Et dans PowerShell :

```powershell
"ANTHROPIC_BASE_URL","ANTHROPIC_AUTH_TOKEN","ANTHROPIC_MODEL","ANTHROPIC_DEFAULT_OPUS_MODEL","ANTHROPIC_DEFAULT_SONNET_MODEL","ANTHROPIC_DEFAULT_HAIKU_MODEL","CLAUDE_CODE_SUBAGENT_MODEL","CLAUDE_CODE_EFFORT_LEVEL","CLAUDE_CODE_AUTO_COMPACT_WINDOW" | ForEach-Object { Remove-Item "Env:$_" -ErrorAction SilentlyContinue }
```

Relance `claude` : ta connexion claude.ai reprend la main, sans te reconnecter.

Bonus : ma config DeepSeek + Claude dans Claude Code, prête à copier

**Le guide officiel transforme Claude Code en DeepSeek pour tout le terminal. Ma version ajoute une seule commande, `claude-ds` : `claude` lance Claude comme avant, `claude-ds` lance DeepSeek.** Les variables ne vivent que le temps de la commande, donc il n'y a jamais rien à défaire, et ta clé n'est pas écrite en clair dans un script.

### Mac : clé dans le trousseau, commande dans ~/.zshrc

Enregistre d'abord ta clé dans le trousseau du Mac (la commande te la demande, rien n'apparaît à l'écran) :

```bash
security add-generic-password -a "$USER" -s deepseek-api -w
```

Puis ajoute ce bloc à la fin de `~/.zshrc` (ou de `~/.bashrc` sous Linux, en remplaçant la ligne `security` par `export DEEPSEEK_API_KEY="sk-..."` dans un fichier lisible par toi seul) :

```bash
# DeepSeek V4.1 Flash dans Claude Code : "claude" = Claude, "claude-ds" = DeepSeek
# Guide : https://iatechnologie.com/deepseek-vs-claude-opus/
claude-ds() {
  local key
  key="$(security find-generic-password -s deepseek-api -w 2>/dev/null)" || { echo "Clé DeepSeek introuvable dans le trousseau"; return 1; }
  ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic" \
  ANTHROPIC_AUTH_TOKEN="$key" \
  ANTHROPIC_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-flash[1m]" \
  ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-flash" \
  CLAUDE_CODE_SUBAGENT_MODEL="deepseek-flash" \
  CLAUDE_CODE_EFFORT_LEVEL="${DS_EFFORT:-max}" \
  CLAUDE_CODE_AUTO_COMPACT_WINDOW="786432" \
  claude "$@"
}
```

Recharge le fichier avec `source ~/.zshrc`, puis lance `claude-ds` dans ton projet. Pour une tâche simple, `DS_EFFORT=high claude-ds` réduit le raisonnement.

### Windows : la même commande dans ton profil PowerShell

Ouvre ton profil avec `notepad $PROFILE` (crée-le s'il n'existe pas) et colle :

```powershell
# DeepSeek V4.1 Flash dans Claude Code : "claude" = Claude, "claude-ds" = DeepSeek
# Guide : https://iatechnologie.com/deepseek-vs-claude-opus/
function claude-ds {
  $vars = [ordered]@{
    ANTHROPIC_BASE_URL              = "https://api.deepseek.com/anthropic"
    ANTHROPIC_AUTH_TOKEN            = $env:DEEPSEEK_API_KEY
    ANTHROPIC_MODEL                 = "deepseek-flash[1m]"
    ANTHROPIC_DEFAULT_OPUS_MODEL    = "deepseek-flash[1m]"
    ANTHROPIC_DEFAULT_SONNET_MODEL  = "deepseek-flash[1m]"
    ANTHROPIC_DEFAULT_HAIKU_MODEL   = "deepseek-flash"
    CLAUDE_CODE_SUBAGENT_MODEL      = "deepseek-flash"
    CLAUDE_CODE_EFFORT_LEVEL        = "max"
    CLAUDE_CODE_AUTO_COMPACT_WINDOW = "786432"
  }
  if (-not $env:DEEPSEEK_API_KEY) { Write-Host "Définis d'abord DEEPSEEK_API_KEY"; return }
  foreach ($k in $vars.Keys) { Set-Item "Env:$k" $vars[$k] }
  try { claude @args }
  finally { foreach ($k in $vars.Keys) { Remove-Item "Env:$k" -ErrorAction SilentlyContinue } }
}
```

Enregistre ta clé une fois pour ton compte Windows :

```powershell
[Environment]::SetEnvironmentVariable("DEEPSEEK_API_KEY", "sk-...", "User")
```

Ferme PowerShell, rouvre-le, et lance `claude-ds`.

### Variante : DeepSeek dans un seul projet

Pour qu'un projet précis tourne toujours sur DeepSeek, mets le bloc `env` dans `.claude/settings.local.json` à la racine de ce projet. Ce fichier est personnel : Claude Code l'ajoute à ton gitignore global quand il l'écrit lui-même, mais si tu le crées à la main, ajoute-le à ton `.gitignore` avant tout commit. Ne mets jamais ta clé dans `.claude/settings.json`, qui est partagé avec tous ceux qui clonent le dépôt.

```json
{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "sk-ta-cle",
    "ANTHROPIC_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-flash",
    "CLAUDE_CODE_SUBAGENT_MODEL": "deepseek-flash",
    "CLAUDE_CODE_EFFORT_LEVEL": "max",
    "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "786432"
  }
}
```

### La checklist de bascule

- [ ] Solde rechargé sur la console DeepSeek, clé créée et rangée hors de tout dépôt Git.
- [ ] `claude --version` répond.
- [ ] Les quatre variables de modèle et celle des sous-agents disent `deepseek-flash`.
- [ ] `/status` affiche `https://api.deepseek.com/anthropic` et `ANTHROPIC_AUTH_TOKEN`.
- [ ] Première consigne envoyée, consommation visible sous `deepseek-flash` dans la console.
- [ ] Aucun code client ni secret dans le projet si tu passes par l'API officielle ([pourquoi](#donnees)).
- [ ] Les gros traitements programmés hors de 7 h–11 h en semaine, heure de Paris (moitié prix).
- [ ] Les tâches critiques gardées pour `claude` (Opus 5.5).

DeepSeek V4.1 Flash 1017, c'est quoi ?

**DeepSeek V4.1 Flash 1017 est la mise à jour du 17 octobre 2026 du modèle rapide et bon marché de DeepSeek, le labo chinois de Hangzhou qui avait secoué la Silicon Valley début 2025.** « 1017 », c'est sa date de sortie. Ce n'est pas un nouveau modèle : selon sa fiche [Hugging Face](https://huggingface.co/deepseek-ai/DeepSeek-V4.1-Flash-1017), c'est une mise à jour mineure de V4.1 Flash, sorti le 10 septembre. Elle a remplacé l'ancienne version sur le site, l'appli et l'API le jour même, sous le même nom d'API : `deepseek-flash`. Si tu l'utilisais déjà, tu es passé dessus sans rien changer.

- **552 milliards de paramètres, 16 milliards actifs.** C'est un mélange d'experts : pour chaque morceau de mot, il ne réveille qu'une petite partie de ses réglages. Moins de calcul par mot, donc moins cher à faire tourner.
- **1 million de tokens de contexte, 384 000 en sortie au maximum**, et il comprend les images.
- **Poids publics sous licence MIT** : tu peux le télécharger, le modifier et t'en servir dans un produit commercial. C'est pour ça qu'une vingtaine d'hébergeurs le proposent déjà.
- **Ce qui change par rapport à septembre**, selon l'[annonce de DeepSeek](https://api-docs.deepseek.com/news/news261017) : de meilleurs scores, des tâches finies plus vite et des réponses plus courtes, grâce à un entraînement où le modèle juge son propre travail sur des projets entiers. DeepSeek ne donne pas de pourcentage pour les réponses plus courtes ; Artificial Analysis le classe d'ailleurs encore « très verbeux ».

Pour un avis général sur DeepSeek (le chat, les autres modèles, l'appli), j'ai une [fiche DeepSeek complète](/outils/deepseek/). Ici, on parle du modèle de code et de son duel avec Claude.

## Benchmarks DeepSeek vs Claude : les lire sans se faire avoir

**Le tableau officiel de DeepSeek le montre devant Claude, le classement indépendant le met un cran derrière : les deux sont vrais, parce qu'ils ne comparent pas la même chose.** Même écart sur [Mistral Large 4 face à DeepSeek](/outils/mistral-large-4/) : un même test, deux classements opposés.

### Le tableau officiel : face à Opus 5, pas Opus 5.5

Sur son tableau, DeepSeek bat Claude sur DeepSWE, un gros examen de code : **77,0 contre 74,0**. Sauf que la colonne Claude, c'est **Claude Opus 5**, l'ancien modèle. Opus 5.5, le dernier, n'y figure pas. Même chose côté OpenAI : la colonne compare GPT 5.6 Sol, pas GPT-6.

Et même face à l'ancien Opus, j'ai compté : **il gagne 4 épreuves sur 11** (DeepSWE, Automation-Bench, Agents' Last Exam, Apex). Il perd les 7 autres, dont Terminal-Bench, qui mesure le travail en ligne de commande : 42,3 contre 51,8. Un tableau d'éditeur choisit ses adversaires : celui-ci est exact, mais incomplet.

### Artificial Analysis : 45 contre 58

[Artificial Analysis](https://artificialanalysis.ai/models/deepseek-v4-1-flash-1017) fait passer les mêmes dix épreuves à tous les modèles, au réglage maximal. Au 25 octobre 2026 :

| Modèle (réglage maximal) | Indice Artificial Analysis | Coût moyen par tâche |
|---|---|---|
| Claude Opus 5.5 | 58 | 5,98 $ |
| Claude Sonnet 5.5 | 56 | 5,46 $ |
| DeepSeek V4.1 Flash 1017 | 45 | 0,26 $ |
| DeepSeek V4.1 Flash (septembre) | environ 40 | — |

Trois lectures utiles. DeepSeek a gagné environ 5 points en un mois, à prix identique. Il reste à 13 points d'Opus 5.5 : un cran en dessous, pas le même niveau. Et le point que la plupart des comparatifs ratent : **au réglage maximal, Sonnet 5.5 coûte presque autant par tâche qu'Opus**, parce qu'il écrit beaucoup plus de tokens (420 millions sur l'indice, contre 260 millions pour Opus 5.5 et 210 millions pour DeepSeek). Remplacer Sonnet par DeepSeek pour tes tâches courantes fait donc économiser autant que remplacer Opus.

### Le prix par tâche et la « frontière de Pareto »

DeepSeek affirme qu'à ce prix, personne ne fait mieux : c'est ce qu'il appelle avancer la frontière de Pareto, la ligne des modèles qu'on ne peut pas battre sans payer plus. Son graphique officiel le place ainsi sur DeepSWE. C'est une revendication de l'éditeur, mais les chiffres indépendants vont dans le même sens : 45 points pour 0,26 $ la tâche. Autre point : ce Flash bat aussi **DeepSeek V4 Pro**, leur grand modèle, quatre fois plus cher en entrée.

### Cybersécurité : 2e, parce que Claude refuse

Artificial Analysis vient de lancer un [indice de cybersécurité](https://artificialanalysis.ai/evaluations/artificial-analysis-cyber-index) qui mesure si une IA sait trouver et réparer des failles dans du code. Il ne mesure que la défense : aucune épreuve ne demande d'exploiter une faille. Au 25 octobre 2026, **DeepSeek V4.1 Flash 1017 y est 2e avec 57 points**, derrière Kimi K3.1 Pro (64) et devant Grok 4.7 (56) et tous les modèles américains accessibles au public.

Une partie de l'écart vient des refus : sur l'épreuve CyberGym, GPT-6 Astra, GPT-6 Sol, Claude Fable 5.1 et Claude Opus 5.5 refusent au moins 98 % des exercices, selon Artificial Analysis. Si tu utilises Claude, ça t'est sûrement arrivé : une demande classée « cyber » et Claude bloque. Les modèles chinois sont plus permissifs. Pour un développeur qui audite son propre code, c'est un vrai avantage pratique ; pour le reste, c'est une politique de sécurité, pas un manque d'intelligence de Claude.

### Les démos et le duel Mellow

DeepSeek a publié quatre démos réalisées par le modèle : un jeu de course, la Cité interdite en 3D, Portal 2 refait dans le moteur Godot et une scène sur l'évolution humaine. Des testeurs sont allés plus loin. Un développeur lui a demandé une ville médiévale assiégée en petits cubes, dans un seul fichier : plus de 2 millions de cubes, une armée qui attaque les remparts et un dragon qu'on appelle d'un bouton. La démo, « Seek Kingdom », est en ligne.

Le même développeur a donné **exactement la même consigne aux deux modèles** : créer Mellow, un personnage 3D interactif. D'après lui, Opus 5.5 a mis 20 minutes pour environ 6 $, DeepSeek 1 heure pour 0,23 $. Et de près, Opus gagne : animations plus vivantes, du son, des détails partout ; DeepSeek s'en approche avec quelques erreurs. Un seul test, rapporté par son auteur, mais il résume bien le modèle : un peu moins bon, plus lent sur ce test, des dizaines de fois moins cher.

Combien tu paies vraiment : DeepSeek vs Claude, le calcul

**Sur une journée de code type, Claude Opus 5.5 coûte environ 20 $ en API, DeepSeek environ 1,09 $ en heures pleines et 0,55 $ en heures creuses.** Ces chiffres viennent d'un calcul, pas d'une mesure : voici les hypothèses, pour que tu puisses refaire le tien.

**L'hypothèse d'une journée** : 300 requêtes d'agent, avec en moyenne 60 000 tokens de contexte relus à chaque fois (ton projet, la conversation, les résultats d'outils), soit 18 millions de tokens en entrée, dont 95 % déjà en cache. Le modèle écrit 2 000 tokens par requête, soit 600 000 tokens en sortie. Les deux modèles reçoivent les mêmes volumes, ce qui avantage plutôt Claude : sur l'indice d'Artificial Analysis, Opus 5.5 écrit plus de tokens que DeepSeek. Un mois = 20 jours de travail.

| Scénario | Claude Opus 5.5 (API) | DeepSeek, heures pleines | DeepSeek, heures creuses | OpenCode Go |
|---|---|---|---|---|
| 1 tâche du classement Artificial Analysis | 5,98 $ | 0,26 $ | environ 0,13 $ | inclus |
| 1 journée de code (hypothèse ci-dessus) | 19,92 $ | 1,09 $ | 0,55 $ | inclus |
| 1 mois (20 jours) | 398 $ | 21,85 $ | 10,93 $ | 10 $ |

Le détail de la journée, aux tarifs officiels du 25 octobre 2026 :

- **DeepSeek, heures pleines** : 17,1 millions de tokens lus en cache × 0,006 $ = 0,10 $ ; 0,9 million lus sans cache × 0,30 $ = 0,27 $ ; 0,6 million écrits × 1,20 $ = 0,72 $. Total : 1,09 $. En heures creuses, tout est divisé par deux : 0,55 $.
- **Claude Opus 5.5** : 17,1 millions lus en cache × 0,20 $ = 3,42 $ ; 0,9 million écrits dans le cache × 5 $ = 4,50 $ ; 0,6 million écrits × 20 $ = 12 $. Total : 19,92 $. Les tarifs viennent de la [grille officielle de l'API Claude](https://platform.claude.com/docs/en/about-claude/pricing).
- **OpenCode Go** : 10 $ par mois, avec un plafond d'usage de DeepSeek V4.1 Flash d'une valeur de 80 $ par mois, découpé en 20 % par tranche de 5 heures et 50 % par semaine. La journée type (environ 1 $ de valeur) y tient largement.

Deux remarques qui changent la décision. D'abord, **ce sont les tokens de sortie qui font la facture d'Opus** : 12 $ sur 20. Ensuite, **la comparaison avec l'abonnement Claude n'est pas la même** : Claude Pro coûte 20 $ par mois (17 $ en paiement annuel) et Max à partir de 100 $, Claude Code compris, avec des limites d'usage au lieu d'une facture au token. Les abonnements d'Anthropic ne suivent pas le prix de l'API, en tout cas pas actuellement. Si tu codes une heure par jour, l'abonnement Pro peut te suffire ; si tu fais tourner des agents des heures, DeepSeek évite d'atteindre les limites ou de payer l'API Claude.

DeepSeek gratuit, API, OpenCode Go : tous les accès

**Discuter avec DeepSeek est gratuit ; coder avec lui se paie à l'usage, en centimes, sauf une version gratuite temporaire réservée à l'agent OpenCode.**

### Le site et l'appli : gratuits

Pour discuter, poser des questions ou faire relire un texte, [chat.deepseek.com](https://chat.deepseek.com/) et l'appli officielle sont gratuits, un peu comme ChatGPT, et tournent sur V4.1 Flash 1017 depuis le 17 octobre. Méfie-toi des sites au nom proche, comme deepseek.fr, qui arrivent en tête de Google sur « deepseek gratuit » : ils ne sont pas édités par DeepSeek. Les seules adresses officielles sont deepseek.com et ses sous-domaines.

### Coder gratuitement : DeepSeek V4.1 Flash Free dans OpenCode

C'est le seul vrai gratuit pour coder que j'ai pu vérifier. [La documentation d'OpenCode](https://opencode.ai/docs/zen) liste au 25 octobre 2026 un modèle **« DeepSeek V4.1 Flash Free »** (identifiant `deepseek-v4.1-flash-free`), « gratuit sur OpenCode pour une durée limitée ». Trois points à connaître avant de foncer :

- **Seulement dans OpenCode.** La doc le dit noir sur blanc : les modèles gratuits ne marchent que dans l'agent OpenCode, pas depuis un autre outil. Tu ne peux donc pas le brancher dans Claude Code ; il faut passer sur OpenCode, un agent de code open source qui ressemble beaucoup à Claude Code. Il s'installe avec `curl -fsSL https://opencode.ai/install | bash` (ou `npm install -g opencode-ai`), puis tu choisis le modèle avec `/models`.
- **Tes données, en mieux que l'API officielle.** Selon OpenCode, les modèles sont hébergés aux États-Unis et en Europe, et le fournisseur de cette version gratuite ne conserve rien et n'entraîne rien sur tes requêtes.
- **Pour une durée limitée, sans date de fin ni quota publiés.** La doc ne précise pas non plus s'il s'agit exactement de la version 1017. Parfait pour essayer le modèle sans sortir la carte, pas pour bâtir ton travail dessus.

### L'API officielle : prix, cache et heures creuses

| Par million de tokens (25 oct. 2026) | Heures pleines | Heures creuses |
|---|---|---|
| Entrée déjà en cache | 0,006 $ | 0,003 $ |
| Entrée hors cache | 0,30 $ | 0,15 $ |
| Sortie | 1,20 $ | 0,60 $ |

Source : la [page des modèles et tarifs de DeepSeek](https://api-docs.deepseek.com/quick_start/pricing). Le prix vient de trois choses.

1. **Le mélange d'experts** : 16 milliards de réglages au travail sur 552.
2. **Le cache, le plus important.** Quand une IA code pour toi, elle relit le projet à chaque étape, 100 ou 200 fois. Ce qu'elle a déjà lu, DeepSeek le garde en mémoire, et le relire coûte 50 fois moins cher (0,006 $ au lieu de 0,30 $). Le cache est automatique, sans réglage, selon le [guide du cache de DeepSeek](https://api-docs.deepseek.com/guides/kv_cache). Exemple : 10 millions de tokens relus coûtent 3 $ sans cache, 6 centimes avec.
3. **L'heure.** DeepSeek facture plein tarif du lundi au vendredi de 01 h à 04 h et de 06 h à 10 h UTC, sauf jours fériés chinois.

| En heure de Paris | Heures pleines (plein tarif) | Tout le reste |
|---|---|---|
| Heure d'hiver (depuis le 25 octobre 2026) | Lundi–vendredi, 2 h–5 h et 7 h–11 h | Moitié prix : après-midi, soir, week-end |
| Heure d'été (dès le 28 mars 2027) | Lundi–vendredi, 3 h–6 h et 8 h–12 h | Moitié prix |

Concrètement, si tu lances tes gros chantiers l'après-midi ou le soir, tu paies moitié prix sans rien changer.

### La recherche web gratuite jusqu'au 31 octobre, 17 h

Quand Claude Code fait une recherche sur internet pour toi avec DeepSeek branché, elle passe par le moteur de recherche maison de DeepSeek. Pareil dans Codex et dans DeepSeek Harness, leur propre appli pour coder. Selon le [guide Search & Fetch](https://api-docs.deepseek.com/guides/search) et l'annonce du 17 octobre, **ces recherches sont gratuites jusqu'au 31 octobre 2026 à 16 h UTC, soit 17 h à Paris**. Ensuite, 0,75 $ les 1 000 recherches, et 0,75 $ les 1 000 pages lues. N'oublie pas le coût caché : chaque recherche ajoute aussi des tokens, le temps que le modèle résume ce qu'il a trouvé.

### OpenCode Go : DeepSeek à 10 $ par mois, sans conservation

Si tu préfères un forfait sans surprise, [OpenCode Go](https://opencode.ai/go) coûte 10 $ par mois (Go Plus : 40 $, limites plus hautes) et donne accès à une trentaine de modèles de code, dont DeepSeek V4.1 Flash, Kimi K3.1 Pro et GLM. Il s'utilise dans OpenCode ou dans n'importe quel autre agent. Pour DeepSeek, la page indique un usage d'une valeur de 80 $ par mois (160 $ avec Go Plus), et surtout **« entraînement : non, conservation : 0 jour »**. Un détail à surveiller : cet accord de non-conservation avec DeepSeek est renouvelé chaque mois, et l'actuel court jusqu'au 31 octobre 2026. Vérifie la page en novembre.

### Les autres hébergeurs

Comme les poids sont publics, d'autres le proposent : Artificial Analysis recense **22 fournisseurs d'API** au 25 octobre 2026, avec des prix et des vitesses qui varient. OpenRouter, qui les regroupe derrière une seule clé, permet de les trier par prix. Avant d'envoyer du code sensible, lis la politique de conservation de chacun : un prix bas ne dit rien de ce qu'il fait de tes requêtes. Et méfie-toi des revendeurs inconnus aux prix cassés : pour un essai, une petite recharge, jamais de code client.

DeepSeek danger : ce que deviennent tes données

**Par le site, l'appli ou l'API officielle, tes données partent en Chine, et DeepSeek l'écrit lui-même.** Sa [politique de confidentialité](https://cdn.deepseek.com/policies/en-US/deepseek-privacy-policy.html), mise à jour le 10 février 2026, dit trois choses claires :

- les données personnelles sont collectées, traitées et **stockées en République populaire de Chine** ;
- elles peuvent servir à **entraîner et améliorer** ses modèles ;
- tu peux t'y **opposer** en écrivant à l'adresse privacy@deepseek.com ; un représentant dans l'Union européenne (Prighter) est désigné.

Trie donc ce que tu lui envoies. Un script perso, un site vitrine, un projet open source : le risque est faible. Du code client, des secrets, des données personnelles : pas par l'accès officiel. Les parades existent :

| Accès | Où vont tes requêtes | Pour quoi |
|---|---|---|
| Site, appli, API officielle | Serveurs de DeepSeek en Chine, entraînement possible | Projets perso, code déjà public |
| OpenCode Go | Accord avec DeepSeek : pas d'entraînement, 0 jour de conservation (accord mensuel) | Code de travail non critique |
| OpenCode, modèle gratuit | Hébergé aux États-Unis et en Europe, sans conservation ni entraînement selon OpenCode | Essayer gratuitement, dans OpenCode seulement |
| Autre hébergeur | Selon sa politique, à lire avant | Variable |
| En local (Strata) | Rien ne sort de ta machine | Code confidentiel, si tu as le matériel |

Et dans Claude Code, n'oublie pas que tout ce que l'agent lit pour travailler (fichiers, sorties de commandes, fichiers `.env` s'il les ouvre) part chez le fournisseur du modèle. Exclure les fichiers sensibles de la lecture de l'agent est une bonne habitude, avec n'importe quel modèle.

DeepSeek en local avec Strata : quelle machine ?

**Faire tourner DeepSeek V4.1 Flash 1017 chez toi est possible, mais c'est un projet de passionné.** Le modèle complet pèse environ 508 Go. Pour le faire entrer dans un PC, on le compresse : on arrondit ses réglages pour qu'ils prennent moins de place, en acceptant un peu de qualité en moins.

[Strata](https://github.com/Niko1221/Strata), un outil gratuit sous licence MIT, le fait tourner avec une carte graphique de 12 Go et 46 à 64 Go de mémoire vive. Il garde en mémoire les parties qui servent le plus et va lire le reste sur ton SSD. Au 25 octobre 2026, son README annonce :

| Machine | Vitesse d'écriture mesurée par Strata |
|---|---|
| RTX 5070 12 Go + 64 Go de RAM | 4 à 6 tokens par seconde |
| RTX 3060 12 Go + 46 Go de RAM | 9 à 11 tokens par seconde |
| 1 Radeon AI PRO R9700 + 251 Go de RAM | 21 à 25 tokens par seconde |
| 4 Radeon AI PRO R9700 | 74 à 77 tokens par seconde |

Ce qu'il faut savoir avant de télécharger :

- **Le disque** : 239 à 274 Go libres selon la version compressée choisie, idéalement sur un SSD NVMe rapide, car le modèle y lit à chaque mot.
- **Le matériel** : cartes Nvidia RTX 30, 40 et 50 (Windows et Linux) ou AMD Radeon AI PRO R9700 (Linux). Pas de Mac pour ce modèle à cette date, même si Strata tourne sur Mac pour d'autres modèles.
- **La qualité** : la version 2 bits recommandée perd un peu (le fichier de Strata indique +8,6 % de perplexité sur le code).
- **Le contexte** : 8 192 tokens par défaut. Claude Code envoie bien plus que ça à chaque requête ; il faut l'augmenter, ce qui demande encore plus de mémoire.
- **Claude Code** : Strata expose une API compatible Anthropic, donc la même méthode marche en remplaçant l'adresse de DeepSeek par celle de ton serveur local.

À 5 ou 10 tokens par seconde, un agent qui travaille des heures devient très long. Pour la plupart d'entre nous, l'API reste la bonne option ; le local vaut le coup si tu as déjà une grosse machine et du code qui ne doit pas sortir. Pour choisir un modèle plus léger adapté à ton PC, mon [guide de l'IA en local](/ia-locale/) part de ta mémoire disponible.

## DeepSeek ou Claude : le choix cas par cas

**Garde Claude pour ce qui doit être juste et fini du premier coup ; passe à DeepSeek pour le volume, les essais et tout ce qu'un humain relira de toute façon.**

| Ta situation | Mon choix | Pourquoi |
|---|---|---|
| Petites tâches répétées : tests, scripts, refactorisation simple, documentation | DeepSeek | 20 fois moins cher, niveau suffisant |
| Prototype, jeu, démo à itérer beaucoup | DeepSeek | Beaucoup d'essais, chaque essai coûte des centimes |
| Agents qui tournent des heures, automatisations | DeepSeek, en heures creuses | Le cache et la moitié prix font la différence |
| Audit de sécurité de ton propre code | DeepSeek | Claude refuse plus souvent les demandes « cyber » |
| Architecture, bug difficile, gros projet existant | Claude Opus 5.5 | 13 points d'écart sur le classement indépendant |
| Interface soignée, animations, finition | Claude Opus 5.5 | C'est là qu'Opus gagne dans le duel Mellow |
| Code client ou confidentiel | Claude, ou DeepSeek via OpenCode Go ou en local | Pas l'API officielle de DeepSeek |
| Tu as déjà un abonnement Claude et tu n'atteins pas les limites | Claude | Tu as déjà payé |

Personnellement, je garde Claude pour mes gros projets, et je passe DeepSeek dans Claude Code pour tout le reste, avec la [commande `claude-ds`](#config) : changer de modèle prend une seconde, donc aucune raison de payer Opus pour écrire des tests. Pour situer DeepSeek face aux autres agents et modèles de code, mon classement des [meilleures IA pour coder](/outils/code/) et mon guide des [agents de code gratuits](/agents-ia-code-modeles-ia-gratuits/) complètent cette page. Et si tu ne l'as pas encore vue, [ma vidéo sur DeepSeek V4.1 Flash](https://www.youtube.com/watch?v=dRmd3hQvGVY) montre les démos et le duel en images, en sept minutes.

Les prix de DeepSeek, la recherche web gratuite et les accords des hébergeurs changent d'un mois à l'autre. Pour être prévenu quand un modèle de ce genre sort, inscris-toi à [la newsletter](/newsletter/) : chaque jeudi, la synthèse des actus IA de la semaine, et en option un mail à chaque nouvelle vidéo.