Documentation de l’API DeepSeek : configuration complète, tarifs, modèles et exemples de code

Dernière vérification des informations : 5 juillet 2026

La documentation de l’API DeepSeek s’adresse surtout aux développeurs qui veulent intégrer les modèles DeepSeek dans une application, un outil interne, un assistant IA, un agent, un workflow RAG ou un produit SaaS. L’essentiel à retenir : l’API DeepSeek est utilisable via un format compatible OpenAI ou Anthropic, avec une base URL OpenAI https://api.deepseek.com, une base URL Anthropic https://api.deepseek.com/anthropic, et deux modèles API principaux au moment de cette vérification : deepseek-v4-flash et deepseek-v4-pro.

Avant toute mise en production, vérifiez toujours la page officielle Models & Pricing : DeepSeek précise que les prix peuvent varier et recommande de consulter régulièrement la page de tarification la plus récente.

Table des matières

Résumé rapide pour intégrer l’API DeepSeek

Pour une intégration standard, utilisez le format OpenAI avec le SDK OpenAI, configurez base_url sur https://api.deepseek.com, stockez votre clé dans la variable d’environnement DEEPSEEK_API_KEY, puis choisissez deepseek-v4-flash pour les usages rapides/économiques ou deepseek-v4-pro pour les tâches plus exigeantes. Le endpoint principal pour générer une réponse conversationnelle est POST /chat/completions.

Élément	Valeur actuelle à utiliser
Documentation officielle	DeepSeek API Docs
Base URL OpenAI	`https://api.deepseek.com`
Base URL Anthropic	`https://api.deepseek.com/anthropic`
Endpoint chat	`POST /chat/completions`
Modèles actuels	`deepseek-v4-flash`, `deepseek-v4-pro`
SDK le plus simple	SDK OpenAI avec `base_url` personnalisé
Clé API	À créer depuis DeepSeek Platform
Ancien alias à éviter	`deepseek-chat`, `deepseek-reasoner`

Les anciens noms deepseek-chat et deepseek-reasoner sont encore documentés comme alias de compatibilité, mais ils doivent être remplacés : DeepSeek indique qu’ils seront dépréciés le 24 juillet 2026 à 15:59 UTC et qu’ils correspondent actuellement aux modes non-thinking et thinking de deepseek-v4-flash.

À quoi sert l’API DeepSeek ?

L’API DeepSeek permet d’envoyer des requêtes à des modèles de langage DeepSeek depuis une application. Elle peut servir à créer un chatbot, résumer des documents, générer du code, analyser des textes longs, structurer des données en JSON, connecter un modèle à des outils externes ou construire des agents IA.

Le point fort côté développeur est la compatibilité de format : DeepSeek indique que son API peut être utilisée avec les SDKs ou logiciels compatibles OpenAI/Anthropic en modifiant principalement la configuration, notamment la base URL, la clé API et le nom du modèle.

Pré-requis avant la configuration

Avant d’appeler l’API, préparez ces éléments :

Un compte DeepSeek Platform pour créer une clé API.
Une clé API stockée dans une variable d’environnement, jamais en dur dans le code.
Un environnement de développement : terminal, Python, Node.js ou outil HTTP.
Un modèle cible : deepseek-v4-flash ou deepseek-v4-pro.
Un budget de test : l’API est facturée selon les tokens d’entrée, les tokens de sortie et le statut cache hit/cache miss.

Stocker la clé API correctement

Sur macOS/Linux :

export DEEPSEEK_API_KEY="YOUR_DEEPSEEK_API_KEY"

Sur Windows PowerShell, pour la session actuelle :

$env:DEEPSEEK_API_KEY = "YOUR_DEEPSEEK_API_KEY"

Pour définir la variable de façon persistante dans les prochaines sessions PowerShell :

setx DEEPSEEK_API_KEY "YOUR_DEEPSEEK_API_KEY"

Ne mettez jamais une vraie clé API dans un dépôt Git, un front-end public, une application mobile décompilable ou un fichier partagé. En production, utilisez un gestionnaire de secrets, une rotation périodique des clés et des environnements séparés pour le développement, le staging et la production.

Configuration de l’API DeepSeek avec cURL, Python et Node.js

La documentation officielle montre que l’API DeepSeek peut être appelée via le format OpenAI en utilisant https://api.deepseek.com comme base URL, puis le endpoint /chat/completions. Les exemples ci-dessous utilisent les noms de modèles actuels et évitent les anciens alias.

Premier appel API avec cURL

Cet exemple vérifie rapidement que la clé API fonctionne. Il utilise deepseek-v4-flash avec le thinking mode désactivé pour obtenir une réponse simple et directe.

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [
      {
        "role": "system",
        "content": "Tu es un assistant technique concis."
      },
      {
        "role": "user",
        "content": "Explique l’API DeepSeek en une phrase."
      }
    ],
    "thinking": {
      "type": "disabled"
    },
    "stream": false
  }'

Si vous recevez une erreur 401, la cause la plus probable est une clé API absente, incorrecte ou mal transmise dans l’en-tête Authorization.

Configuration Python avec le SDK OpenAI

Installez d’abord le SDK OpenAI :

pip install openai

Puis créez un appel simple :

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-flash",
    messages=[
        {"role": "system", "content": "Tu es un assistant technique clair."},
        {"role": "user", "content": "Donne-moi trois cas d’usage de l’API DeepSeek."}
    ],
    extra_body={
        "thinking": {"type": "disabled"}
    },
    stream=False,
)

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

Le champ usage est important en production : il permet de suivre les tokens consommés, y compris les tokens de prompt en cache hit ou cache miss selon la réponse retournée par l’API.

Configuration Node.js avec le SDK OpenAI

Installez le SDK :

npm install openai

Exemple minimal :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.DEEPSEEK_API_KEY,
  baseURL: "https://api.deepseek.com",
});

const completion = await client.chat.completions.create({
  model: "deepseek-v4-flash",
  messages: [
    {
      role: "system",
      content: "Tu es un assistant technique concis.",
    },
    {
      role: "user",
      content: "Explique la différence entre API et SDK.",
    },
  ],
  thinking: {
    type: "disabled",
  },
  stream: false,
});

console.log(completion.choices[0].message.content);

Lister les modèles disponibles

Pour éviter d’utiliser un modèle supprimé ou renommé, vous pouvez appeler GET /models. La référence officielle précise que ce endpoint liste les modèles actuellement disponibles et renvoie notamment l’identifiant du modèle.

curl https://api.deepseek.com/models \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}"

Au moment de cette vérification, l’exemple officiel de réponse liste deepseek-v4-flash et deepseek-v4-pro.

Modèles DeepSeek disponibles et tarifs officiels

La page officielle Models & Pricing présente actuellement deux modèles API principaux : deepseek-v4-flash et deepseek-v4-pro. Les deux utilisent les bases URL OpenAI et Anthropic documentées, supportent le thinking mode, disposent d’une longueur de contexte de 1M, et affichent un maximum de sortie documenté à 384K.

Modèle	Usage recommandé	Contexte	Max output	Entrée cache hit / 1M tokens	Entrée cache miss / 1M tokens	Sortie / 1M tokens	Limite de concurrence
`deepseek-v4-flash`	Réponses rapides, coût bas, assistants, tâches fréquentes	1M	384K	$0.0028	$0.14	$0.28	2500
`deepseek-v4-pro`	Raisonnement plus exigeant, agents, tâches complexes, analyse approfondie	1M	384K	$0.003625	$0.435	$0.87	500

Ces tarifs sont affichés par million de tokens. DeepSeek indique que la facturation dépend du total de tokens d’entrée et de sortie, et que les prix peuvent changer : vérifiez donc la page officielle avant de publier un prix ou de déployer un budget de production.

Comment choisir entre deepseek-v4-flash et deepseek-v4-pro ?

Choisissez deepseek-v4-flash si votre priorité est le coût, la vitesse ou le volume. C’est généralement le meilleur point de départ pour un chatbot, une FAQ, de la classification, de la génération de brouillons, de l’extraction simple, des tests d’intégration et des boucles d’automatisation fréquentes.

Choisissez deepseek-v4-pro lorsque l’enjeu justifie un coût plus élevé : raisonnement plus difficile, architecture logicielle, analyse de documents longs, workflows agentiques, tâches multi-étapes ou situations où une réponse incorrecte coûte plus cher qu’un appel API plus onéreux. La différence de prix entre les deux modèles est visible dans la grille officielle, avec un coût d’entrée et de sortie plus élevé pour deepseek-v4-pro.

Cas d’usage	Modèle conseillé	Pourquoi
Chatbot support client simple	`deepseek-v4-flash`	Coût plus faible et suffisant pour des réponses fréquentes
Résumé de tickets ou emails	`deepseek-v4-flash`	Bon choix pour les tâches répétitives
Génération JSON structurée	`deepseek-v4-flash` ou `deepseek-v4-pro`	Selon la complexité du schéma
Agent avec outils	`deepseek-v4-pro` pour tâches complexes	Meilleur choix quand le raisonnement et les tool calls sont centraux
Analyse longue avec contexte réutilisé	Les deux, selon budget	Le context caching peut réduire le coût des préfixes répétés
Debugging ou raisonnement multi-fichiers	`deepseek-v4-pro`	Plus adapté aux tâches où la qualité prime sur le coût

Migration depuis deepseek-chat et deepseek-reasoner

Si votre code utilise encore deepseek-chat ou deepseek-reasoner, planifiez la migration immédiatement. La documentation indique que ces deux noms seront dépréciés le 24 juillet 2026 à 15:59 UTC. Ils correspondent actuellement, pour compatibilité, aux modes non-thinking et thinking de deepseek-v4-flash.

Ancienne configuration à éviter

{
  "model": "deepseek-chat"
}

ou :

{
  "model": "deepseek-reasoner"
}

Nouvelle configuration recommandée

Pour remplacer deepseek-chat, utilisez deepseek-v4-flash avec le thinking mode désactivé :

{
  "model": "deepseek-v4-flash",
  "thinking": {
    "type": "disabled"
  }
}

Pour remplacer un usage de type raisonnement, utilisez deepseek-v4-flash ou deepseek-v4-pro avec le thinking mode activé selon votre besoin de qualité et votre budget :

{
  "model": "deepseek-v4-pro",
  "thinking": {
    "type": "enabled"
  },
  "reasoning_effort": "high"
}

Le point important : ne remplacez pas mécaniquement deepseek-reasoner par deepseek-v4-pro dans tous les cas. L’ancien alias est documenté comme correspondant au thinking mode de deepseek-v4-flash; deepseek-v4-pro est un autre choix de modèle, plus coûteux, à réserver aux cas où il apporte une valeur réelle.

Tokens, cache et calcul des coûts

DeepSeek facture l’usage en tokens. La documentation explique qu’un token est l’unité de base utilisée par les modèles pour représenter du texte et qu’elle sert aussi d’unité de facturation. Le nombre réel de tokens doit être lu dans le résultat usage retourné par l’API, car la tokenisation varie selon les modèles.

Comprendre cache hit et cache miss

Le context caching de DeepSeek est activé par défaut. Quand plusieurs requêtes réutilisent un préfixe commun déjà persisté dans le cache, la partie réutilisée peut être comptée en cache hit. Les tokens non trouvés dans le cache sont comptés en cache miss. La réponse API peut indiquer prompt_cache_hit_tokens et prompt_cache_miss_tokens dans usage.

En pratique, le cache est utile si vous envoyez souvent les mêmes instructions système, le même contexte documentaire, le même prompt de classification ou le même bloc de référence. Pour maximiser les chances de cache hit :

gardez les instructions stables au début du prompt ;
évitez de modifier inutilement les premiers messages ;
mettez les variables utilisateur après le contexte stable ;
réutilisez exactement les mêmes préfixes lorsque c’est possible ;
surveillez prompt_cache_hit_tokens et prompt_cache_miss_tokens.

DeepSeek précise toutefois que le cache fonctionne en “best effort”, qu’il ne garantit pas un taux de hit de 100 %, et qu’un cache inutilisé est généralement supprimé après une période allant de quelques heures à quelques jours.

Formule simple de coût

Pour estimer un appel :

coût =
(tokens_input_cache_hit / 1 000 000 × prix_cache_hit)
+ (tokens_input_cache_miss / 1 000 000 × prix_cache_miss)
+ (tokens_output / 1 000 000 × prix_output)

Exemple avec deepseek-v4-flash, selon les tarifs vérifiés le 5 juillet 2026 :

80 000 tokens d’entrée en cache hit ;
20 000 tokens d’entrée en cache miss ;
50 000 tokens de sortie.

coût =
(80 000 / 1 000 000 × 0.0028)
+ (20 000 / 1 000 000 × 0.14)
+ (50 000 / 1 000 000 × 0.28)

coût = 0.000224 + 0.0028 + 0.014
coût = 0.017024 $

Cet exemple montre pourquoi le context caching peut devenir important dans les usages longs ou répétitifs. Vérifiez toujours le prix officiel avant de baser un budget client ou une marge produit sur ces calculs.

Fonctionnalités avancées : thinking mode, streaming, JSON output et tool calls

Thinking mode

Le thinking mode permet au modèle de produire un contenu de raisonnement avant la réponse finale. Dans la documentation actuelle, le paramètre OpenAI-format est thinking: {"type": "enabled"} ou thinking: {"type": "disabled"}, et le niveau d’effort peut être contrôlé avec reasoning_effort: "high" ou "max". Le mode thinking est documenté comme activé par défaut.

Exemple 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": "user",
            "content": "Analyse les risques techniques d’une migration API en production."
        }
    ],
    reasoning_effort="high",
    extra_body={
        "thinking": {"type": "enabled"}
    },
)

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

Point d’attention : la documentation indique que, dans le thinking mode, certains paramètres comme temperature, top_p, presence_penalty et frequency_penalty ne sont pas pris en charge et peuvent être ignorés sans déclencher d’erreur. Ne construisez donc pas une logique métier qui dépend de ces paramètres lorsque le thinking mode est activé.

Streaming

Le streaming est utile pour afficher progressivement une réponse dans une interface utilisateur. Le endpoint Chat Completions accepte stream: true et envoie des événements SSE, avec une terminaison data: [DONE]. La référence indique aussi que stream_options.include_usage peut ajouter un chunk final contenant les statistiques d’usage de la requête.

Exemple Python simplifié :

import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "user", "content": "Écris une checklist de déploiement API."}
    ],
    extra_body={
        "thinking": {"type": "disabled"}
    },
    stream=True,
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="")

Si vous parsez vous-même les réponses HTTP, prévoyez aussi les keep-alive : DeepSeek documente des lignes vides pour les requêtes non-streaming et des commentaires SSE : keep-alive pour les requêtes streaming.

JSON Output

Le mode JSON Output est utile quand vous voulez une sortie strictement exploitable par votre application : extraction de champs, scoring, classification, résumé structuré, génération d’objets métier, etc. Pour l’activer, DeepSeek indique de définir response_format sur {"type": "json_object"}, d’inclure le mot “json” dans le prompt système ou utilisateur, de fournir un exemple du format attendu et de fixer un max_tokens raisonnable.

import json
import os
from openai import OpenAI

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

messages = [
    {
        "role": "system",
        "content": (
            "Réponds uniquement en JSON valide. "
            "Format attendu : "
            '{"intent": "string", "priority": "low|medium|high", "summary": "string"}'
        ),
    },
    {
        "role": "user",
        "content": "Le client demande un remboursement urgent après une double facturation.",
    },
]

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=messages,
    response_format={"type": "json_object"},
    max_tokens=300,
    extra_body={
        "thinking": {"type": "disabled"}
    },
)

data = json.loads(response.choices[0].message.content)
print(data)

Même avec JSON Output, validez toujours le JSON côté application : types, champs obligatoires, valeurs autorisées, taille maximale et données inattendues.

Tool calls / function calling

Les tool calls permettent au modèle de demander l’appel d’une fonction externe : météo, base de données, moteur de recherche interne, CRM, outil de facturation, système de tickets, etc. La documentation précise que le modèle ne lance pas lui-même la fonction : il renvoie un appel structuré, puis votre application exécute réellement l’outil et renvoie le résultat au modèle.

Exemple minimal de définition d’outil :

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "Récupère le statut d’une commande à partir de son identifiant.",
            "parameters": {
                "type": "object",
                "properties": {
                    "order_id": {
                        "type": "string",
                        "description": "Identifiant de commande"
                    }
                },
                "required": ["order_id"]
            }
        }
    }
]

Lorsque le modèle renvoie des arguments de fonction, ne les exécutez jamais aveuglément. La référence API rappelle que les arguments générés peuvent ne pas être du JSON valide ou contenir des paramètres non définis par votre schéma ; vous devez donc les valider dans votre code avant d’appeler une vraie fonction.

Anthropic API

Si votre stack utilise l’écosystème Anthropic, DeepSeek documente aussi une base URL Anthropic : https://api.deepseek.com/anthropic. La page officielle précise que l’API supporte ce format pour faciliter l’intégration avec des outils compatibles Anthropic.

Exemple d’environnement :

export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_API_KEY="${DEEPSEEK_API_KEY}"

Attention : la compatibilité n’est pas identique à une reproduction complète de toutes les fonctionnalités Anthropic. La documentation détaille les champs supportés, ignorés ou non supportés ; vérifiez-la si vous utilisez des fonctionnalités avancées comme les messages multimodaux, les tool fields ou des paramètres spécifiques.

Erreurs fréquentes et solutions

DeepSeek publie une page dédiée aux codes d’erreur. Les erreurs les plus utiles à surveiller en intégration sont 401, 402, 422, 429, 500 et 503.

Code	Signification	Cause probable	Action recommandée
400	Invalid Format	Corps de requête invalide	Corriger le JSON et vérifier le format attendu
401	Authentication Fails	Clé API absente ou incorrecte	Vérifier `DEEPSEEK_API_KEY` et l’en-tête `Authorization`
402	Insufficient Balance	Solde insuffisant	Vérifier le solde du compte et recharger si nécessaire
422	Invalid Parameters	Paramètre invalide	Lire le message d’erreur et corriger le champ concerné
429	Rate Limit Reached	Trop de requêtes ou limite de concurrence dépassée	Ralentir, mettre en file d’attente, backoff, réduire la concurrence
500	Server Error	Erreur serveur	Retenter après un court délai
503	Server Overloaded	Serveur surchargé	Retenter avec backoff et prévoir un fallback

Résoudre une erreur 429

Une erreur 429 peut survenir si vous dépassez les limites de concurrence. DeepSeek indique que les limites sont calculées au niveau du compte, quel que soit le nombre de clés API utilisées. Un appel compte comme connexion concurrente depuis l’envoi de la requête jusqu’à la fin de la réponse.

Actions utiles :

limitez le nombre de requêtes simultanées côté application ;
appliquez un backoff exponentiel ;
utilisez une file de jobs ;
diminuez la taille des prompts si les réponses prennent trop longtemps ;
surveillez séparément les appels streaming et non-streaming ;
demandez une extension de capacité si votre usage métier le justifie.

Utiliser `user_id` sans exposer de données personnelles

DeepSeek permet de transmettre un paramètre user_id pour l’isolation de sécurité, de cache et de scheduling. La documentation précise que ce champ doit respecter le format [a-zA-Z0-9\-_]+, avoir une longueur maximale de 512 caractères, et ne pas contenir d’informations privées de l’utilisateur.

Bon exemple :

{
  "user_id": "tenant_42_user_789"
}

Mauvais exemple :

{
  "user_id": "[email protected]"
}

Checklist de production

Avant de déployer l’API DeepSeek dans une application réelle, vérifiez les points suivants.

Sécurité

La clé API est stockée dans un gestionnaire de secrets.
Aucune clé n’est présente dans le front-end, les logs ou Git.
Les environnements dev, staging et production utilisent des clés séparées.
Les erreurs retournées à l’utilisateur ne révèlent pas de secrets.
Les paramètres de tool calls sont validés avant exécution.

Coûts

Les prix sont vérifiés sur la page officielle le jour du déploiement.
Les champs usage, prompt_cache_hit_tokens et prompt_cache_miss_tokens sont logués.
Un budget quotidien ou mensuel est défini.
Les alertes de consommation sont configurées.
Les prompts longs sont structurés pour favoriser le cache hit.

Fiabilité

Les timeouts HTTP sont définis.
Les erreurs 429, 500 et 503 déclenchent un retry avec backoff.
Un fallback est prévu pour les flux critiques.
Les réponses JSON sont validées côté serveur.
Les changements de modèles sont suivis via la documentation officielle et le change log.

Qualité

Les prompts système sont versionnés.
Les résultats sont testés sur des cas réels.
Les sorties sensibles sont contrôlées.
Le modèle choisi correspond au niveau de complexité : deepseek-v4-flash pour le volume, deepseek-v4-pro pour les tâches plus exigeantes.
Les anciens noms deepseek-chat et deepseek-reasoner sont retirés du code, des variables d’environnement, des dashboards et des tests.

FAQ

Où trouver la documentation officielle de l’API DeepSeek ?

La documentation officielle se trouve sur DeepSeek API Docs. Elle regroupe le quickstart, les modèles, les prix, les tokens, les limites, les erreurs, les guides API et la référence des endpoints.

Quelle est la base URL de l’API DeepSeek ?

Pour le format OpenAI, utilisez https://api.deepseek.com. Pour le format Anthropic, utilisez https://api.deepseek.com/anthropic.

Quels modèles DeepSeek utiliser actuellement via API ?

Au moment de cette vérification, les modèles API actuels documentés sont deepseek-v4-flash et deepseek-v4-pro. Le endpoint GET /models permet aussi de lister les modèles disponibles.

deepseek-chat et deepseek-reasoner fonctionnent-ils encore ?

Ils sont documentés comme anciens alias de compatibilité, mais DeepSeek indique qu’ils seront dépréciés le 24 juillet 2026 à 15:59 UTC. Il est préférable de migrer vers deepseek-v4-flash ou deepseek-v4-pro avec le paramètre thinking approprié.

Combien coûte l’API DeepSeek ?

Les prix sont facturés par million de tokens et varient selon le modèle, les tokens d’entrée cache hit, les tokens d’entrée cache miss et les tokens de sortie. Le 5 juillet 2026, la page officielle indiquait par exemple $0.14 / 1M tokens d’entrée cache miss et $0.28 / 1M tokens de sortie pour deepseek-v4-flash, mais ces prix doivent être revérifiés avant usage.

Comment réduire le coût des appels API ?

Réduisez les sorties inutiles, choisissez le modèle adapté, surveillez le champ usage, structurez les prompts longs pour favoriser les préfixes réutilisables et exploitez le context caching lorsque vos requêtes partagent un contexte stable.

L’API DeepSeek est-elle compatible avec le SDK OpenAI ?

Oui, DeepSeek documente un format compatible OpenAI. Dans la plupart des cas, il faut configurer le SDK avec votre clé API DeepSeek, base_url="https://api.deepseek.com" et un nom de modèle DeepSeek valide.

Que faire en cas d’erreur 429 ?

Une erreur 429 indique généralement un rythme de requêtes trop élevé ou une limite de concurrence dépassée. Réduisez la concurrence, ajoutez une file d’attente, appliquez un backoff exponentiel et surveillez le nombre d’appels simultanés au niveau du compte.

Le JSON Output garantit-il un objet directement exploitable ?

DeepSeek indique que response_format={"type":"json_object"} aide à obtenir une sortie JSON valide, mais vous devez aussi demander explicitement du JSON dans le prompt, fournir un exemple de format et définir un max_tokens raisonnable. En production, validez toujours le résultat côté application.

Les tool calls exécutent-ils automatiquement mes fonctions ?

Non. Le modèle peut générer un appel d’outil, mais c’est votre application qui exécute réellement la fonction et renvoie le résultat au modèle. Vous devez valider les arguments avant toute exécution.