API DeepSeek V4 pour le codage : Routage de deepseek-v4-pro et deepseek-v4-flash

Envoyer chaque étape d'une session de codage à un seul modèle est la politique de routage la plus simple, et généralement la plus coûteuse. Ce tutoriel montre comment utiliser l'API DeepSeek V4 pour le codage sur TokenLab en répartissant le travail entre deepseek-v4-pro et deepseek-v4-flash. Nous avons lu les deux fiches de modèles depuis l'API en direct le 03/10/2026, et tout ce qui suit provient de ces enregistrements et de la documentation de TokenLab. Vous trouverez un tableau comparatif, une estimation de coût détaillée, une requête d'appel d'outil, du code pour les tentatives de nouvelle connexion (retry) et le basculement (fallback), ainsi qu'une vérification préalable.

Points clés à retenir

• Les deux modèles indiquent une limite d'entrée de 1 000 000 de tokens, une limite de sortie de 384 000 tokens et les trois mêmes formats de requête. Le prix est la principale différence entre eux.
• Aux prix catalogue, deepseek-v4-pro coûte 4,4 fois plus cher que deepseek-v4-flash par token d'entrée et 3,3 fois plus cher par token de sortie.
• Dans notre exemple de 20 appels, router 4 appels vers pro et 16 vers flash coûte environ 0,18 $ en heures creuses. Envoyer les 20 vers pro coûte environ 0,46 $.
• Relancez sur 429 après Retry-After. Relancez sur 500–504 uniquement lorsque retryable est true. Ne relancez jamais 400, 401, 402, 403, 404 ou 413 sans modification.
• Le catalogue liste deepseek-v4.1-flash comme actif. Ni deepseek-v4-pro ni deepseek-v4-flash ne nomment de modèle de remplacement.
• Lisez les limites, les formats et les prix via GET /v1/models/:model avant de router. Ne codez pas en dur un tableau copié.

L'API DeepSeek V4 pour le codage : Ce que dit le catalogue

Nous avons récupéré les deux enregistrements le 03/10/2026. Le tableau ci-dessous les compare côte à côte. Les prix sont en USD pour 1 million de tokens, et la tarification du catalogue a été mise à jour pour la dernière fois le 02/10/2026 à 16:53:30.068Z.

Élément	deepseek-v4-pro	deepseek-v4-flash	Source, observée le 03/10/2026
Limite de contexte (max tokens d'entrée)	1 000 000	1 000 000	pro, flash
Limite de sortie (max tokens de sortie)	384 000	384 000	pro, flash
Formats de requête acceptés	anthropic_messages, openai_chat_completions, openai_responses	anthropic_messages, openai_chat_completions, openai_responses	pro, flash
Capacités	json-mode, prompt-cache, tool-use	json-mode, prompt-cache, tool-use	pro, flash
Entrée heures creuses	0,66 $	0,15 $	pro, flash
Sortie heures creuses	1,98 $	0,60 $	pro, flash
Lecture cache heures creuses	0,022 $	0,003 $	pro, flash
Écriture cache heures creuses	0,66 $	non listé	pro, flash
Entrée heures pleines	1,32 $	0,30 $	pro, flash
Sortie heures pleines	3,96 $	1,20 $	pro, flash
Lecture cache heures pleines	0,044 $	0,006 $	pro, flash
Phase du cycle de vie	actif, sorti le 24/04/2026	actif, sorti le 24/04/2026	pro, flash

Le bloc de prix par défaut dans chaque enregistrement correspond à l'entrée heures creuses. Les horaires des heures pleines diffèrent selon l'enregistrement. Pour deepseek-v4-pro, les prix des heures pleines s'appliquent de 09h00 à 12h00 et de 14h00 à 18h00, heure de Pékin. Pour deepseek-v4-flash, l'enregistrement indique que les fenêtres d'heures pleines s'appliquent en semaine, hors jours fériés en Chine. Il indique que les heures creuses incluent les week-ends et ces jours fériés, mais ne donne aucune heure précise. Vérifiez le point de terminaison de tarification avant d'établir votre budget autour de la fenêtre flash.

Cycle de vie et modèles DeepSeek plus récents

Les deux enregistrements indiquent lifecycle stage active, avec replacement model, deprecated_at et retired_at tous vides. Le catalogue ne prévoit donc le retrait d'aucun des deux modèles et ne nomme aucun successeur pour l'un ou l'autre.

Le catalogue liste également deepseek-v4.1-flash. Sa fiche, observée le 03/10/2026, est active sans date de sortie ni remplacement. Elle présente les mêmes limites, formats et prix catalogue que deepseek-v4-flash. Elle ajoute reasoning et vision à la liste des capacités et affiche un prix d'écriture en cache de 0,15 $ en heures creuses.

Il s'agit d'un ID de modèle distinct, donc cet article conserve son sujet. Nous vous conseillons de tester deepseek-v4.1-flash sur vos propres tâches avant de l'adopter. Le catalogue liste également deepseek-v4-flash-vision-exp, mais nous n'avons pas lu sa fiche. Vérifiez-la sur la page Modèles si vous en avez besoin.

Routage de deepseek-v4-pro et deepseek-v4-flash par tâche

Imaginez une session d'agent qui planifie un changement sur cinq modules, écrit les modifications, puis génère une douzaine de stubs de test. La première étape nécessite le plus de contexte et de soin. La dernière est répétitive et peu coûteuse à refaire. Le catalogue ne peut pas vous dire où se situe la limite de qualité. Le guide TokenLab sur les modèles d'agent de codage, observé le 03/10/2026, indique que les résultats des classements ne prédisent pas comment un modèle suivra vos propres instructions et outils.

Notre heuristique de départ suppose que le modèle le plus cher justifie son coût sur le travail multi-fichiers. Considérez cela comme une hypothèse à tester, et non comme une conclusion :

+-------------------------------------------------------------+
|                      Tâche entrante                         |
+-------------------------------------------------------------+
                               |
         [La tâche implique-t-elle un contexte multi-fichiers,
          la rétrocompatibilité ou une revue de sécurité ?]
                               |
               +---------------+---------------+
               |                               |
             [Oui]                            [Non]
               |                               |
               v                               v
       deepseek-v4-pro                 deepseek-v4-flash

Critères qui orientent une étape vers deepseek-v4-pro :

• Modification de la logique sur plusieurs fichiers importés.
• Évaluations de sécurité ou de vulnérabilité.
• Rétrocompatibilité stricte sur les interfaces publiques.
• Travail multi-tours où la précision compte plus que le délai d'exécution.

L'échafaudage de tests autonomes, le formatage de schémas, les docstrings et la complétion de syntaxe vont vers deepseek-v4-flash.

Pour tester l'heuristique, suivez le même guide. Donnez à chaque modèle le même état de référentiel, les mêmes instructions, outils et limite de temps. Comparez ensuite l'exactitude, les tests réussis, les changements inutiles, le nombre total de tokens, le coût final et la fréquence à laquelle une intervention humaine a été nécessaire. Conservez les résultats par type de tâche, car un modèle peut bien réviser mais mal implémenter.

Estimation du coût d'une boucle d'agent de codage

Les agents renvoient les instructions, l'historique, le code et les résultats des outils à chaque appel. Le guide des coûts, observé le 03/10/2026, note que les sessions longues peuvent coûter beaucoup plus cher qu'une simple requête de chat. Nous avons effectué le calcul ci-dessous à partir des prix catalogue. Le résultat est une estimation, pas une facture mesurée.

Hypothèses (les nôtres, non mesurées) : une boucle de 20 appels de modèle, chacun avec 30 000 tokens d'entrée et 1 500 tokens de sortie. Cela donne un total de 600 000 tokens d'entrée et 30 000 tokens de sortie.

La formule est tokens_entrée / 1M × prix entrée + tokens_sortie / 1M × prix sortie. Les prix proviennent du tableau ci-dessus.

Tous les 20 appels vers deepseek-v4-pro :

• Heures creuses : 0,6 × 0,66 $ = 0,396 $ d'entrée, plus 0,03 × 1,98 $ = 0,0594 $ de sortie, soit 0,4554 $.
• Heures pleines : 0,6 × 1,32 $ = 0,792 $, plus 0,03 × 3,96 $ = 0,1188 $, soit 0,9108 $.

Tous les 20 appels vers deepseek-v4-flash :

• Heures creuses : 0,6 × 0,15 $ = 0,09 $, plus 0,03 × 0,60 $ = 0,018 $, soit 0,108 $.
• Heures pleines : 0,6 × 0,30 $ = 0,18 $, plus 0,03 × 1,20 $ = 0,036 $, soit 0,216 $.

Mixte : 4 appels vers pro, 16 vers flash. Pro gère 120 000 tokens d'entrée et 6 000 de sortie. Flash gère 480 000 tokens d'entrée et 24 000 de sortie.

• Heures creuses : pro est 0,12 × 0,66 $ + 0,006 × 1,98 $ = 0,0792 $ + 0,01188 $ = 0,09108 $. Flash est 0,48 × 0,15 $ + 0,024 × 0,60 $ = 0,072 $ + 0,0144 $ = 0,0864 $. Le total est 0,17748 $.
• Heures pleines : pro est 0,12 × 1,32 $ + 0,006 × 3,96 $ = 0,1584 $ + 0,02376 $ = 0,18216 $. Flash est 0,48 × 0,30 $ + 0,024 × 1,20 $ = 0,144 $ + 0,0288 $ = 0,1728 $. Le total est 0,35496 $.

Scénario	Estimation heures creuses	Estimation heures pleines
20 appels sur deepseek-v4-pro	0,4554 $	0,9108 $
20 appels sur deepseek-v4-flash	0,1080 $	0,2160 $
4 pro + 16 flash	0,1775 $	0,3550 $

Estimations basées sur les prix catalogue observés le 03/10/2026 (pro, flash).

Variante cache (heures creuses, hypothèse : 80 % des tokens d'entrée sont des lectures de cache). Cela signifie 480 000 tokens de lecture de cache et 120 000 tokens non mis en cache par boucle.

• Pro : 0,48 × 0,022 $ = 0,01056 $, plus 0,12 × 0,66 $ = 0,0792 $, plus 0,0594 $ de sortie, soit 0,14916 $.
• Flash : 0,48 × 0,003 $ = 0,00144 $, plus 0,12 × 0,15 $ = 0,018 $, plus 0,018 $ de sortie, soit 0,03744 $.

Cette variante facture les tokens non mis en cache au prix d'entrée standard et ignore les frais d'écriture en cache sur flash, que l'enregistrement ne liste pas. Confirmez le nombre de tokens mis en cache dans la réponse ou dans Usage avant de compter sur cette remise. Le guide de facturation avertit également que le prix le plus bas par token n'est pas toujours le coût le plus bas par tâche terminée, car les tentatives de nouvelle connexion s'accumulent.

Une requête d'appel d'outil pour un agent de codage

Les deux enregistrements listent tool-use, et les deux acceptent openai_chat_completions. La requête ci-dessous utilise uniquement les champs du guide d'appel d'outil (observé le 03/10/2026) : model, messages et tools avec type: "function". Nous avons ajouté max_tokens, que le guide de facturation liste comme un moyen de plafonner la longueur de la réponse. Nous avons omis tool_choice, car ce guide ne le documente que pour le format Réponses.

curl https://api.tokenlab.sh/v1/chat/completions \
  -H "Authorization: Bearer $TOKENLAB_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "max_tokens": 2000,
    "messages": [
      {"role": "system", "content": "You are a software engineering assistant."},
      {"role": "user", "content": "The pagination test in tests/test_api.py fails. Find the cause."}
    ],
    "tools": [
      {
        "type": "function",
        "function": {
          "name": "read_file",
          "description": "Read a file from the repository",
          "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
          }
        }
      },
      {
        "type": "function",
        "function": {
          "name": "run_tests",
          "description": "Run the test suite for one path",
          "parameters": {
            "type": "object",
            "properties": {"path": {"type": "string"}},
            "required": ["path"]
          }
        }
      }
    ]
  }'

Le modèle renvoie un nom de fonction et des arguments dans tool_calls. Votre backend exécute l'outil. La boucle s'exécute ensuite en cinq étapes :

1. Envoyer les messages plus les définitions d'outils.
2. Lire la réponse pour tool_calls.
3. Exécuter l'outil dans votre propre backend.
4. Ajouter le résultat de l'outil dans le même format API.
5. Continuer jusqu'à ce que le modèle renvoie une réponse finale.

Le guide ne montre pas la forme du message de résultat de l'outil en ligne. Prenez-la de la référence Créer une complétion de chat (/api-reference/chat/create-completion) plutôt que de deviner.

Avant d'exécuter tout appel, validez les arguments et appliquez vos propres contrôles d'autorisation. Rendez l'exécution idempotente, car une nouvelle tentative du client peut répéter le même appel d'outil. Gardez un format API pour tout l'échange, car les formats représentent l'état de l'outil différemment.

Tentatives, backoff et basculement entre les deux modèles

Le guide des erreurs et le guide des limites de débit, tous deux observés le 03/10/2026, définissent la politique. Segmentez selon le statut HTTP et le code, jamais selon le message.

Statut	Répéter la même requête ?	Action
400, 401, 402, 403, 404, 413	Non	Corrigez la requête, la clé, le solde, les permissions ou l'entrée
429	Oui	Attendez Retry-After ; si absent, utilisez un backoff exponentiel avec jitter
500–504	Uniquement si retryable est true	Respectez retry_after et plafonnez les tentatives
Connexion fermée avant une réponse	Parfois	Relancez avec précaution si un appel d'outil peut répéter un effet secondaire
Flux interrompu après l'arrivée de la sortie	Non	Traitez-le comme incomplet ; une répétition peut produire une sortie différente ou une seconde facturation

Deux cas nécessitent une attention particulière. Une erreur 503 all_channels_failed ou 503 delivery_tier_unavailable n'est pas toujours temporaire. Lorsque retryable est false et que retry_after est manquant, ne répétez pas la requête. Vérifiez GET /v1/models avant de choisir un autre modèle. De plus, context_length_exceeded ne sera pas résolu en basculant entre ces deux modèles, car les deux listent la même limite d'entrée de 1 000 000 de tokens.

Le code ci-dessous applique cette politique. Il définit max_retries=0 pour que le SDK ne relance pas dans votre dos. Chaque modèle bénéficie de quatre tentatives, et le basculement ne s'exécute qu'après que le premier modèle a épuisé les erreurs relançables.

import os
import random
import time
from openai import OpenAI, APIStatusError, APIConnectionError

client = OpenAI(
    api_key=os.environ["TOKENLAB_API_KEY"],
    base_url="https://api.tokenlab.sh/v1",
    timeout=30.0,
    max_retries=0,
)

FALLBACK = {
    "deepseek-v4-pro": "deepseek-v4-flash",
    "deepseek-v4-flash": "deepseek-v4-pro",
}

def error_fields(exc):
    body = getattr(exc, "body", None)
    if isinstance(body, dict):
        return body.get("error", body)
    return {}

def backoff(attempt):
    return min(30, 2 ** attempt + random.random())

def retry_delay(exc, attempt):
    """Secondes à attendre, ou None lorsque la requête ne doit pas être répétée."""
    if isinstance(exc, APIConnectionError):
        return backoff(attempt)
    fields = error_fields(exc)
    header = exc.response.headers.get("Retry-After")
    if exc.status_code == 429:
        return float(header) if header else backoff(attempt)
    if exc.status_code >= 500 and fields.get("retryable") is True:
        wait = fields.get("retry_after") or header
        return float(wait) if wait else backoff(attempt)
    return None

def chat_with_fallback(model, messages, tools=None, attempts=4):
    last_exc = None
    for candidate in (model, FALLBACK[model]):
        kwargs = {"model": candidate, "messages": messages}
        if tools:
            kwargs["tools"] = tools
        for attempt in range(attempts):
            try:
                return candidate, client.chat.completions.create(**kwargs)
            except (APIStatusError, APIConnectionError) as exc:
                delay = retry_delay(exc, attempt)
                if delay is None:
                    raise  # 4xx ou 5xx non relançable : ne pas répéter ou basculer
                last_exc = exc
                if attempt < attempts - 1:
                    time.sleep(delay)
        print(f"{candidate} a épuisé les tentatives, essai avec {FALLBACK[candidate]}")
    raise last_exc

def pick_model(is_complex):
    return "deepseek-v4-pro" if is_complex else "deepseek-v4-flash"

used, response = chat_with_fallback(
    pick_model(is_complex=False),
    [{"role": "user", "content": "Write a pytest case: an empty list returns 0 for sum_items()."}],
)
print(used, response.choices[0].message.content)

Enregistrez toujours quel modèle a répondu. Le guide de l'agent de codage avertit qu'un basculement peut modifier le prix, la limite de contexte, le format d'outil ou le style de sortie, alors informez l'utilisateur lorsque le modèle change. Basculer de flash vers pro multiplie environ par quatre le coût d'entrée aux prix catalogue, alors soyez vigilant. Enregistrez l'ID de requête des en-têtes de réponse avec chaque appel afin que le support puisse tracer une défaillance.

Lire les limites, les formats et le prix avant de router

La référence Obtenir un modèle, observée le 03/10/2026, décrit GET /v1/models/:model. La réponse contient un objet tokenlab avec capabilities, pricing, max_input_tokens, max_output_tokens, accepted_request_formats et lifecycle. Un modèle inconnu renvoie 404 model_not_found. Le guide de facturation pointe également vers GET /v1/models/:model/pricing pour le prix actuel.

import json
import urllib.request

def read_model(model_id):
    url = f"https://api.tokenlab.sh/v1/models/{model_id}"
    with urllib.request.urlopen(url, timeout=10) as resp:
        meta = json.load(resp)["tokenlab"]
    return {
        "max_input_tokens": meta.get("max_input_tokens"),
        "max_output_tokens": meta.get("max_output_tokens"),
        "formats": meta.get("accepted_request_formats"),
        "capabilities": meta.get("capabilities"),
        "lifecycle": meta.get("lifecycle"),
        "pricing": meta.get("pricing"),
    }

def preflight(model_id, input_tokens):
    info = read_model(model_id)
    problems = []
    if "openai_chat_completions" not in (info["formats"] or []):
        problems.append("chat completions not accepted")
    if "tool-use" not in (info["capabilities"] or []):
        problems.append("no tool-use capability")
    if info["max_input_tokens"] and input_tokens > info["max_input_tokens"]:
        problems.append("input exceeds max_input_tokens")
    return info, problems

for model_id in ("deepseek-v4-pro", "deepseek-v4-flash"):
    info, problems = preflight(model_id, input_tokens=30_000)
    print(model_id, json.dumps(info, indent=2), problems)

Nous imprimons lifecycle et pricing bruts car les preuves de cet article ne montrent pas leur disposition JSON exacte à l'intérieur de cette réponse. Inspectez la sortie une fois, puis analysez les champs dont vous avez besoin. La documentation déconseille de coder en dur des tableaux de prix copiés, alors exécutez la vérification au démarrage ou selon un calendrier. Les points de terminaison de découverte publics tels que GET /v1/models ont leurs propres limites de débit, alors mettez le résultat en cache au lieu de l'appeler par requête.

Pour les limites de débit, le niveau Utilisateur standard autorise 1 000 requêtes par minute par clé API, tel qu'observé le 03/10/2026. Le guide indique que la configuration active peut différer. Sur une erreur 429, faites confiance aux valeurs X-RateLimit-Limit et Retry-After renvoyées plutôt qu'à tout nombre copié.

FAQ

Puis-je appeler deepseek-v4-pro via le format Anthropic Messages ?

Oui. Les deux enregistrements listent anthropic_messages parmi les formats acceptés, observé le 03/10/2026. Le guide de l'agent de codage donne l'URL de base Anthropic Messages comme https://api.tokenlab.sh, sans le suffixe /v1 que Chat Completions utilise. Les schémas d'outils diffèrent selon le format, alors gardez un seul format pour toute la conversation.

Dois-je relancer une erreur 503 de deepseek-v4-pro ou deepseek-v4-flash ?

Uniquement si le corps de l'erreur indique que retryable est true, et attendez alors retry_after. Une erreur 503 all_channels_failed avec retryable: false signifie que la requête n'a pas d'offre dans le niveau de livraison sélectionné. La répéter ne servira à rien. Vérifiez GET /v1/models avant de choisir un autre modèle, comme le décrit le guide des erreurs.

deepseek-v4.1-flash remplace-t-il deepseek-v4-flash ?

Le catalogue ne le dit pas. Le 03/10/2026, l'enregistrement deepseek-v4-flash n'indiquait aucun modèle de remplacement, et deepseek-v4.1-flash indiquait un statut actif. Les deux partagent les limites et les prix catalogue, et le plus récent ajoute les capacités reasoning et vision. Testez-le sur vos tâches et basculez délibérément par ID de modèle.

Les tokens mis en cache rendent-ils deepseek-v4-flash moins cher dans une boucle d'agent ?

Ils le peuvent. L'enregistrement liste un prix de lecture de cache en heures creuses de 0,003 $ par 1M de tokens, contre 0,15 $ pour une entrée simple. Le guide des coûts indique de confirmer l'utilisation des tokens mis en cache dans la réponse ou dans Usage avant de compter sur une remise. Le comportement du cache et les prix diffèrent selon le modèle.

Routage vers deepseek-v4-flash augmentera-t-il ma limite de débit ?

Non. Le guide des limites de débit indique qu'un modèle plus rapide n'augmente pas la limite de requêtes de votre compte. La vitesse du modèle, les limites de tokens et les limites de débit du compte sont des contraintes distinctes, et les limites s'appliquent par clé API.

Vérifiez les entrées actuelles de deepseek-v4-pro et deepseek-v4-flash sur la page des modèles TokenLab avant de configurer votre routeur.