Comment utiliser l'API DeepSeek V4 Pro 0813 ?

DeepSeek V4 Pro a quitté la préversion le 12 août 2026. La version GA, identifiée par l’instantané 0813, alimente désormais le point d’API deepseek-v4-pro. Elle annonce une fenêtre de contexte d’un million de jetons, jusqu’à 384 000 jetons en sortie et un tarif d’entrée de 0,003625 $ par million de jetons lors d’un accès au cache. Comme l’a rapporté Unite.AI, le modèle passé quatre mois en préversion devient le produit phare de DeepSeek.

Essayez Apidog dès aujourd’hui

Ce guide se concentre sur l’implémentation : première requête avec le SDK OpenAI, modes de réflexion et champ reasoning_content, streaming SSE, appel d’outils et optimisation du cache de prompt. Pour le contexte architectural, consultez d’abord Qu’est-ce que DeepSeek V4.

TL;DR

• deepseek-v4-pro cible l’instantané GA 0813 depuis le 12 août 2026.
• L’API est compatible OpenAI : configurez le SDK openai avec https://api.deepseek.com.
• Le modèle accepte jusqu’à 1 million de jetons en contexte et produit jusqu’à 384 000 jetons.
• Trois niveaux de raisonnement sont disponibles : non-think, think high et think max.
• Les réponses en mode réflexion incluent reasoning_content, séparé de content.
• Les entrées coûtent 0,435 $/M sur manque de cache et 0,003625 $/M sur accès au cache ; les sorties coûtent 0,87 $/M.
• Le cache de prompt est automatique : stabilisez le préfixe de vos messages pour réduire les coûts.
• Testez les requêtes, le streaming et les métriques usage dans Apidog avant le déploiement.

Ce que la version GA 0813 change pour les développeurs

La préversion a ouvert en avril 2026. DeepSeek V4 Flash est arrivé en juillet, puis V4 Pro est passé en disponibilité générale le 12 août sous la version 0813, selon la convention de versionnage de DeepSeek.

Concrètement, la GA apporte trois garanties opérationnelles :

1. Un instantané stable
   
   Les modèles de préversion peuvent évoluer sans avertissement, ce qui invalide évaluations, prompts et comportements observés. 0813 devient une cible fixe jusqu’à la publication d’un nouvel instantané.

2. Un alias de production
   
   Appelez deepseek-v4-pro sur l’API officielle. Pour épingler explicitement l’instantané, OpenRouter référence deepseek/deepseek-v4-pro-0813.

3. Les fonctionnalités disponibles sur le point d’accès GA
   
   Modes de réflexion, appels de fonctions, sorties structurées, cache de prompt et formats OpenAI, Anthropic Messages et DeepSeek Responses sont disponibles.

V4 Pro est un modèle de mélange d’experts avec 1,6 trillion de paramètres au total et 49 milliards de paramètres actifs par jeton. Selon DeepSeek, Compressed Sparse Attention et Heavily Compressed Attention réduisent le calcul d’inférence à 27 % de celui de V3.2, et le cache KV à 10 %. Cette réduction du cache KV rend le contexte d’un million de jetons plus exploitable en pratique.

DeepSeek V4 Pro 0813 : spécifications

Spécification	DeepSeek V4 Pro 0813
Date de sortie	GA le 12 août 2026, instantané 0813
Architecture	Mélange d’experts, 1,6 billion de paramètres au total, 49 milliards actifs par jeton
Attention	Compressed Sparse Attention + Heavily Compressed Attention
Coût d’inférence vs V3.2	27 % du calcul d’un jeton, 10 % du cache KV
Fenêtre contextuelle	1 000 000 de jetons
Sortie maximale	384 000 jetons
Modes de réflexion	non-think, think high, think max
Entrée sans cache	0,435 $/M jetons
Entrée avec cache	0,003625 $/M jetons
Sortie	0,87 $/M jetons
Formats API	OpenAI Chat Completions, Anthropic Messages, DeepSeek Responses
ID de modèle	deepseek-v4-pro
Modèle plus petit	deepseek-v4-flash : 284 milliards au total / 13 milliards actifs, 0,14 $/M en entrée, 0,28 $/M en sortie

DeepSeek annonce notamment SWE-bench Verified à 80,6 %, Terminal Bench 2.0 à 67,9 %, GPQA Diamond à 90,1 % et LiveCodeBench à 93,5 % pour V4-Pro-Max. Ces résultats sont auto-déclarés : validez le modèle avec vos propres jeux d’évaluation avant toute migration critique.

Obtenir une clé API et envoyer une première requête

1. Créer et exporter la clé

1. Créez un compte sur platform.deepseek.com.
2. Ajoutez du crédit : l’API est prépayée.
3. Générez une clé API et copiez-la immédiatement.
4. Stockez-la dans une variable d’environnement :

export DEEPSEEK_API_KEY="sk-..."

2. Installer le SDK OpenAI

pip install openai

DeepSeek utilise le protocole OpenAI Chat Completions. Utilisez https://api.deepseek.com ou https://api.deepseek.com/v1 comme URL de base ; /v1 est un chemin de compatibilité, pas une version de modèle.

3. Appeler deepseek-v4-pro en Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {
            "role": "system",
            "content": "You are a concise technical assistant.",
        },
        {
            "role": "user",
            "content": "Explain idempotency in REST APIs in two sentences.",
        },
    ],
)

print(response.choices[0].message.content)
print(response.usage)

Inspectez systématiquement response.usage. Avec un écart de prix important entre un manque de cache et un accès au cache, cette donnée doit faire partie de vos logs, métriques et tests de charge.

4. Tester avec cURL

Utilisez cette requête pour un test de fumée ou pour l’importer dans un client API :

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [
      {
        "role": "user",
        "content": "List three ways to version a REST API."
      }
    ]
  }'

Consultez la documentation officielle de DeepSeek pour les paramètres complets, le point d’accès Anthropic Messages et l’API DeepSeek Responses.

Utiliser les modes de réflexion

V4 Pro expose le raisonnement par niveau d’effort plutôt que via des modèles distincts :

• non-think : réponse directe. À privilégier pour l’extraction, la classification, le formatage et les résumés.
• think high : raisonnement avant la réponse. Adapté au code, au débogage et aux analyses multi-étapes.
• think max : budget de raisonnement maximal. À réserver aux problèmes complexes et aux tâches où le coût et la latence sont acceptables.

Utilisez le paramètre reasoning_effort :

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    reasoning_effort="high",  # "none" | "high" | "max"
    messages=[
        {
            "role": "user",
            "content": (
                "Our API returns 502s under load but only behind the CDN. "
                "Walk through likely causes in order of probability."
            ),
        },
    ],
)

message = response.choices[0].message

print("--- Reasoning ---")
print(message.reasoning_content)

print("--- Answer ---")
print(message.content)

Deux règles à appliquer :

1. Ne réinjectez pas reasoning_content dans l’historique de conversation.
   
   Pour les tours suivants, réutilisez uniquement content.

2. Comptez les jetons de raisonnement comme des jetons de sortie.
   
   Ils sont facturés à 0,87 $/M. think max peut donc augmenter le coût et la latence de manière significative.

Diffuser les réponses en streaming

Pour les réponses longues et les modes de réflexion, activez le streaming afin d’éviter d’attendre la réponse complète.

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    reasoning_effort="high",
    stream=True,
    messages=[
        {
            "role": "user",
            "content": (
                "Design a rate limiter for a public API. "
                "Compare token bucket and sliding window."
            ),
        },
    ],
)

for chunk in stream:
    if not chunk.choices:
        # Le dernier événement peut ne contenir que les métriques d'usage.
        continue

    delta = chunk.choices[0].delta

    if getattr(delta, "reasoning_content", None):
        print(delta.reasoning_content, end="", flush=True)
    elif delta.content:
        print(delta.content, end="", flush=True)

Dans les modes de réflexion, les deltas reasoning_content arrivent avant les deltas content.

Côté interface, affichez par exemple un indicateur « Réflexion en cours », sans forcément exposer le raisonnement complet. Passez à l’affichage normal dès que les deltas content commencent. Le transport repose sur des événements SSE standard ; consultez ce guide sur le streaming des réponses API avec SSE pour les détails du protocole.

Appel d’outils et sorties structurées

V4 Pro prend en charge les appels de fonctions de style OpenAI. Vous pouvez donc conserver la structure habituelle d’une boucle d’agent :

1. Déclarer les outils.
2. Envoyer la requête.
3. Lire tool_calls.
4. Exécuter l’outil côté application.
5. Ajouter le résultat dans les messages.
6. Répéter jusqu’à obtenir une réponse finale.

Exemple de définition d’outil :

tools = [{
    "type": "function",
    "function": {
        "name": "get_endpoint_status",
        "description": "Check the health of an internal API endpoint",
        "parameters": {
            "type": "object",
            "properties": {
                "endpoint": {
                    "type": "string",
                    "description": "Path, e.g. /v1/orders",
                },
            },
            "required": ["endpoint"],
        },
    },
}]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {
            "role": "user",
            "content": "Is /v1/orders healthy right now?",
        },
    ],
    tools=tools,
)

print(response.choices[0].message.tool_calls)

Pour les réponses JSON parsables, utilisez le paramètre standard response_format. La documentation officielle détaille les structures de messages et les formats attendus pour les boucles d’outils.

Optimiser le cache de prompt

Le cache de prompt est probablement la caractéristique qui doit le plus influencer votre architecture.

DeepSeek met automatiquement en cache les préfixes de prompt répétés, sans en-tête de contrôle de cache ni TTL à configurer :

• Manque de cache : 0,435 $/M jetons d’entrée
• Accès au cache : 0,003625 $/M jetons d’entrée

Cela représente une réduction d’environ 120× pour les entrées déjà présentes dans le cache.

Exemple de coût

Supposons un agent de code qui conserve 200 000 jetons de contexte de dépôt et effectue 50 appels au cours d’une session.

• Sans cache :
  
  50 × 200 000 × 0,435 $/M ≈ 4,35 $

• Avec cache :
  
  Un manque de cache : 0,087 $
  
  Puis 49 accès au cache : ≈ 0,0007 $ chacun
  
  Total : ≈ 0,12 $

La même session coûte donc environ 35 fois moins cher.

Structurer les messages pour maximiser les accès au cache

Placez les éléments stables au début :

1. Prompt système stable
2. Instructions de l’application
3. Documentation et conventions
4. Contexte de dépôt ou base de connaissances
5. Historique stable de la conversation
6. Dernier message utilisateur
7. Données volatiles : date, ID de requête, trace, état courant

Évitez d’insérer une valeur volatile au début du prompt, par exemple :

Date actuelle : 2026-08-12T10:02:17Z

Si cette date est placée dans le message système, elle modifie le préfixe à chaque requête et peut provoquer un manque de cache complet.

Un contexte de 1 million de jetons coûte 0,435 $ lors d’un manque de cache, mais environ un tiers de centime par appel lorsqu’il est réutilisé comme préfixe stable. Pour approfondir, consultez Qu’est-ce que le cache de prompt.

Tester deepseek-v4-pro dans Apidog

Avant d’intégrer V4 Pro dans un service de production, validez les requêtes, le streaming et les métriques de coût dans un client API. L’API étant compatible OpenAI, Apidog peut être utilisé directement.

Procédure recommandée :

1. Importez la requête cURL
   
   Collez la commande cURL précédente dans Apidog. Les en-têtes, l’authentification et le corps JSON sont convertis en requête éditable.

2. Créez des environnements Pro et Flash
   
   Définissez des variables telles que :

   • base_url
   • api_key
   • model

Vous pouvez ensuite comparer deepseek-v4-pro et deepseek-v4-flash en changeant simplement d’environnement.

1. Inspectez le streaming SSE Envoyez une requête contenant :

   {
     "stream": true
   }

Vérifiez l’ordre des événements : les deltas reasoning_content doivent précéder les deltas content en mode réflexion.

1. Enregistrez les requêtes dans une collection Lorsqu’un nouvel instantané DeepSeek sera disponible, relancez les mêmes prompts et comparez le comportement, les réponses, la latence et les métriques usage.

La réponse inclut le bloc usage, utile pour vérifier votre taux réel d’accès au cache pendant l’optimisation des prompts.

Tarification actuelle et augmentation annoncée

Modèle	Entrée : manque de cache	Entrée : accès au cache	Sortie
deepseek-v4-pro	0,435 $/M	0,003625 $/M	0,87 $/M
deepseek-v4-flash	0,14 $/M	—	0,28 $/M

Le 6 août 2026, DeepSeek a annoncé qu’une augmentation de prix « significative » de l’API était à venir, sans montant ni date d’application.

En attendant plus de détails, appliquez ces mesures :

• Mesurez le coût réel par tâche à partir de usage.
• Conservez des métriques distinctes pour les entrées mises en cache et non mises en cache.
• Structurez les prompts pour réutiliser les préfixes stables.
• Gardez deepseek-v4-flash comme option de routage pour les tâches simples et à fort volume.
• Réservez V4 Pro au code agentique, aux contextes longs et aux requêtes nécessitant un raisonnement approfondi.

Pour une comparaison détaillée des coûts, consultez le guide de tarification de l’API DeepSeek V4.

FAQ

Mon code avec le SDK OpenAI fonctionnera-t-il sans modification ?

Presque. Modifiez trois éléments :

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

Puis utilisez :

model="deepseek-v4-pro"

Les chat completions, le streaming, les outils et les sorties structurées suivent les formats OpenAI. Les équipes utilisant le SDK Anthropic peuvent utiliser le point d’accès Anthropic Messages de DeepSeek.

Quand utiliser V4 Flash plutôt que V4 Pro ?

Utilisez V4 Flash pour :

• la classification ;
• l’extraction ;
• le chat simple ;
• les tâches à fort volume ;
• les charges sensibles à la latence ;
• les tâches qui ne nécessitent pas de raisonnement poussé.

Utilisez V4 Pro pour :

• le codage agentique ;
• le débogage complexe ;
• l’analyse de longs contextes ;
• les workflows nécessitant think high ou think max.

Routez les requêtes selon la tâche et les résultats de vos évaluations, pas selon un choix unique de modèle.

Puis-je utiliser V4 Pro 0813 dans Cursor ?

Oui. Cursor accepte les points d’accès personnalisés compatibles OpenAI. Configurez l’URL de base de DeepSeek et utilisez le modèle GA comme modèle personnalisé. Consultez Comment utiliser DeepSeek V4 Pro avec Cursor.

En résumé

Pour intégrer DeepSeek V4 Pro proprement :

1. Créez une clé et testez un appel minimal.
2. Activez reasoning_effort uniquement lorsque la tâche le justifie.
3. Gérez séparément reasoning_content et content.
4. Utilisez stream=True pour les réponses longues.
5. Mesurez response.usage sur des charges réelles.
6. Stabilisez le début des prompts pour profiter du cache automatique.
7. Conservez une collection Apidog pour comparer les instantanés, les modèles Pro/Flash et les changements de prix.