API DeepSeek en français : guide complet avec Python, Node.js et cURL

Vérification factuelle : 22 juillet 2026. Cette page utilise les noms de modèles, paramètres, prix et limites publiés dans la documentation officielle DeepSeek à cette date. L’API évolue rapidement : vérifiez les liens officiels avant une mise en production.

Transparence : deepseek-fr.ai est un guide francophone indépendant. Il n’est ni exploité, ni approuvé, ni affilié à DeepSeek. Le site ne fournit aucun chatbot, ne crée aucune clé API, ne reçoit aucun prompt et ne transmet aucune requête à DeepSeek. Les exemples de cette page s’exécutent uniquement dans votre propre application avec une clé obtenue sur la plateforme officielle.

L’API DeepSeek permet d’intégrer les modèles deepseek-v4-flash et deepseek-v4-pro à un backend, un script ou une application. Elle expose notamment Chat Completions, le mode Thinking, le streaming, JSON Output et les Tool Calls. Son format Chat Completions est compatible avec celui d’OpenAI, ce qui facilite l’utilisation du SDK OpenAI avec une URL de base personnalisée, sans garantir une parité avec tous les endpoints, rôles et paramètres d’OpenAI.

API DeepSeek : les informations essentielles

Élément	Valeur documentée
URL de base au format OpenAI	https://api.deepseek.com
Chat Completions	POST /chat/completions
Modèles actuels	deepseek-v4-flash et deepseek-v4-pro
Mode par défaut	Thinking
Fenêtre de contexte	1 million de tokens
Sortie maximale	384 000 tokens, dans la limite du contexte total
Authentification	Authorization: Bearer VOTRE_CLE
Format Anthropic	https://api.deepseek.com/anthropic, avec compatibilité partielle

Pour un premier test, utilisez explicitement thinking: {"type":"disabled"} afin d’obtenir une réponse directe. Activez ensuite Thinking pour les tâches qui bénéficient d’un raisonnement plus poussé. Le choix entre Flash et Pro doit être validé sur vos propres données : Flash privilégie le coût et le débit, tandis que Pro constitue un point de départ pour les tâches plus exigeantes.

Sommaire

• Prérequis et sécurité de la clé
• Premier appel avec cURL
• Exemple Python
• Exemple Node.js et TypeScript
• Modèles, prix et anciens alias
• Thinking et paramètres sans effet
• Streaming SSE
• JSON Output
• Function Calling et Tool Calls
• Cache et conversations multi-tours
• Format Anthropic et FIM
• Limites, erreurs et nouvelles tentatives
• Checklist de production
• FAQ
• Sources officielles

Prérequis : créer et protéger la clé API

1. Créez un compte sur la plateforme officielle DeepSeek et générez une clé.
2. Stockez-la dans la variable d’environnement DEEPSEEK_API_KEY.
3. Appelez l’API depuis un backend, un serveur ou une fonction serverless contrôlée.
4. Ne placez jamais la clé dans une page HTML, une application mobile décompilable ou du JavaScript exécuté dans le navigateur.
5. Limitez les droits internes, surveillez les coûts et remplacez immédiatement une clé exposée.

# macOS ou Linux — valable pour le terminal courant
export DEEPSEEK_API_KEY="votre_cle_api"

# Vérifier que la variable existe sans afficher la clé
test -n "$DEEPSEEK_API_KEY" && echo "Clé chargée"

Notre guide détaillé explique comment obtenir et protéger une clé API DeepSeek. Une clé doit être considérée comme un secret de production, au même titre qu’un mot de passe de base de données.

Premier appel API DeepSeek avec cURL

L’URL de base officielle au format OpenAI est https://api.deepseek.com. L’exemple suivant appelle /chat/completions, désactive Thinking et vérifie la structure de la réponse avec jq. Il nécessite cURL et jq.

#!/usr/bin/env bash
set -euo pipefail

: "${DEEPSEEK_API_KEY:?Définissez DEEPSEEK_API_KEY}"

RESPONSE=$(curl --fail-with-body --silent --show-error \
  https://api.deepseek.com/chat/completions \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -H "Content-Type: application/json" \
  --data @- <<'JSON'
{
  "model": "deepseek-v4-pro",
  "messages": [
    {
      "role": "system",
      "content": "Réponds clairement et en français."
    },
    {
      "role": "user",
      "content": "Explique la mise en cache en deux phrases."
    }
  ],
  "thinking": {"type": "disabled"},
  "max_tokens": 300,
  "stream": false
}
JSON
)

jq -er '
  if (.choices | length) == 0 then
    error("Réponse sans choix")
  elif .choices[0].finish_reason == "length" then
    error("Réponse tronquée")
  elif .choices[0].finish_reason != "stop" then
    error("Génération interrompue")
  else
    .choices[0].message.content
  end
' <<<"$RESPONSE"

N’ajoutez pas /v1 comme une obligation dans votre configuration : la documentation actuelle donne https://api.deepseek.com comme URL de base. Utilisez les rôles documentés par DeepSeek — system, user, assistant et tool — et le paramètre max_tokens.

Utiliser l’API DeepSeek avec Python

Le SDK OpenAI peut envoyer des requêtes au format DeepSeek lorsque base_url est personnalisé. L’exemple ci-dessous active Thinking, fixe un délai maximal et refuse une réponse vide ou tronquée.

python -m pip install "openai==2.46.0"

import os

from openai import OpenAI


def ask(client: OpenAI) -> str:
    response = client.chat.completions.create(
        model="deepseek-v4-pro",
        messages=[
            {"role": "system", "content": "Réponds clairement et en français."},
            {
                "role": "user",
                "content": "Quelle est la différence entre HTTP et HTTPS ?",
            },
        ],
        max_tokens=600,
        reasoning_effort="high",
        # thinking est une extension DeepSeek : utilisez extra_body.
        extra_body={"thinking": {"type": "enabled"}},
    )

    if not response.choices:
        raise RuntimeError("Réponse DeepSeek vide")

    choice = response.choices[0]
    if choice.finish_reason == "length":
        raise RuntimeError("Réponse tronquée")
    if choice.finish_reason != "stop":
        raise RuntimeError(f"Génération interrompue : {choice.finish_reason}")
    if not choice.message.content:
        raise RuntimeError("Réponse sans contenu final")

    return choice.message.content


api_key = os.environ.get("DEEPSEEK_API_KEY")
if not api_key:
    raise RuntimeError("DEEPSEEK_API_KEY est manquante")

client = OpenAI(
    api_key=api_key,
    base_url="https://api.deepseek.com",
    timeout=120.0,
    max_retries=2,
)

# N’affichez que la réponse finale, pas reasoning_content.
print(ask(client))

Les niveaux reasoning_effort documentés sont high et max. Le champ thinking étant propre à DeepSeek, extra_body évite de faire croire qu’il s’agit d’un paramètre standard commun à tous les fournisseurs compatibles OpenAI.

Utiliser l’API DeepSeek avec Node.js et TypeScript

Cette version utilise le fetch intégré à Node.js 18 ou version ultérieure. Elle reste côté serveur, impose un timeout, contrôle le JSON et retente uniquement les erreurs temporaires. Le header Retry-After est respecté s’il est présent ; la documentation DeepSeek actuelle ne garantit pas qu’il sera toujours envoyé.

type ChatResult = {
  finishReason: string | null;
  content: string | null;
};

function isRecord(value: unknown): value is Record<string, unknown> {
  return typeof value === "object" && value !== null;
}

function parseResult(value: unknown): ChatResult {
  if (!isRecord(value) || !Array.isArray(value.choices)) {
    throw new Error("Format de réponse DeepSeek inattendu");
  }
  const choice = value.choices[0];
  if (!isRecord(choice) || !isRecord(choice.message)) {
    throw new Error("Réponse sans choix exploitable");
  }
  const finishReason = choice.finish_reason;
  const content = choice.message.content;
  if (finishReason !== null && typeof finishReason !== "string") {
    throw new Error("finish_reason invalide");
  }
  if (content !== null && typeof content !== "string") {
    throw new Error("content invalide");
  }
  return { finishReason, content };
}

const sleep = (ms: number) =>
  new Promise((resolve) => setTimeout(resolve, ms));

function retryDelayMs(response: Response, attempt: number): number {
  const retryAfter = response.headers.get("retry-after");
  if (retryAfter !== null) {
    const seconds = Number(retryAfter);
    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;

    const date = Date.parse(retryAfter);
    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
  }
  return Math.min(500 * 2 ** attempt + Math.random() * 250, 8000);
}

async function askDeepSeek(prompt: string): Promise<string> {
  // Code serveur uniquement : ne jamais exposer la clé au navigateur.
  const apiKey = process.env.DEEPSEEK_API_KEY;
  if (!apiKey) throw new Error("DEEPSEEK_API_KEY est manquante");
  if (!prompt.trim()) throw new Error("Le prompt est vide");

  const body = {
    model: "deepseek-v4-pro",
    messages: [{ role: "user", content: prompt }],
    thinking: { type: "disabled" },
    max_tokens: 600,
    stream: false,
  } as const;

  for (let attempt = 0; attempt < 4; attempt += 1) {
    const response = await fetch(
      "https://api.deepseek.com/chat/completions",
      {
        method: "POST",
        headers: {
          Authorization: `Bearer ${apiKey}`,
          "Content-Type": "application/json",
        },
        body: JSON.stringify(body),
        signal: AbortSignal.timeout(120_000),
      },
    );

    const raw = await response.text();
    if (response.ok) {
      let data: unknown;
      try {
        data = JSON.parse(raw) as unknown;
      } catch {
        throw new Error(`Réponse non JSON (HTTP ${response.status})`);
      }
      const result = parseResult(data);
      if (result.finishReason !== "stop") {
        throw new Error(`Génération interrompue : ${result.finishReason}`);
      }
      if (!result.content) throw new Error("Réponse finale vide");
      return result.content;
    }

    const retryable = [429, 500, 503].includes(response.status);
    if (!retryable || attempt === 3) {
      throw new Error(`DeepSeek HTTP ${response.status}: ${raw.slice(0, 500)}`);
    }
    await sleep(retryDelayMs(response, attempt));
  }
  throw new Error("Nombre maximal de tentatives atteint");
}

askDeepSeek("Résume OAuth 2.0 en trois points.")
  .then(console.log)
  .catch((error: unknown) => {
    console.error(error);
    process.exitCode = 1;
  });

Cet exemple n’effectue pas de requête payante tant que vous ne l’exécutez pas avec votre propre clé. Il faut encore ajouter dans une application réelle une limite par utilisateur, une journalisation sans secrets et un suivi des coûts.

Modèles DeepSeek V4, prix et anciens alias

Les deux identifiants actuellement documentés sont deepseek-v4-flash et deepseek-v4-pro. Les deux proposent les modes Thinking et non-thinking. La fenêtre de contexte atteint 1 million de tokens et la sortie peut atteindre 384 000 tokens au maximum, sans dépasser la fenêtre totale entrée plus sortie.

Prix de l’API au 22 juillet 2026

Modèle	Entrée, cache hit	Entrée, cache miss	Sortie	Concurrence par compte
deepseek-v4-flash	0,0028 $ / 1 M	0,14 $ / 1 M	0,28 $ / 1 M	2 500
deepseek-v4-pro	0,003625 $ / 1 M	0,435 $ / 1 M	0,87 $ / 1 M	500

Les montants sont facturés par million de tokens. Pour estimer une requête, additionnez le coût des tokens d’entrée avec cache, des tokens d’entrée sans cache et des tokens de sortie, chacun divisé par un million. Les tarifs peuvent évoluer : consultez la grille officielle et notre page sur les prix de l’API DeepSeek V4 avant d’établir un budget.

Migration urgente au 22 juillet 2026 : les alias deepseek-chat et deepseek-reasoner doivent être retirés le 24 juillet 2026 à 15 h 59 UTC. N’utilisez plus ces noms dans un nouveau projet. Migrez vers deepseek-v4-flash ou deepseek-v4-pro, contrôlez explicitement Thinking et vérifiez les identifiants disponibles avec GET /models.

curl --fail-with-body --silent --show-error \
  https://api.deepseek.com/models \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" | jq .

Pour comparer les capacités et les usages, consultez aussi notre fiche DeepSeek V4 Flash et Pro.

Mode Thinking : paramètres pris en charge et paramètres sans effet

Thinking est activé par défaut sur les modèles V4 actuels. Utilisez thinking: {"type":"enabled"} ou thinking: {"type":"disabled"} pour rendre le comportement explicite. Avec le SDK OpenAI pour Python, envoyez ce champ via extra_body. Les niveaux d’effort documentés sont high et max.

Règle à retenir : En mode Thinking, temperature et top_p sont ignorés. presence_penalty et frequency_penalty sont obsolètes et sans effet, quel que soit le mode. Consultez la référence API officielle Chat Completions.

La distinction est importante : temperature et top_p restent des paramètres documentés en mode non-thinking, mais n’agissent pas en Thinking. En revanche, presence_penalty et frequency_penalty sont marqués deprecated dans la référence générale et ne modifient plus la réponse dans aucun mode. Les transmettre peut ne pas provoquer d’erreur, mais cela ne les rend pas actifs.

En streaming Thinking, la réponse peut fournir reasoning_content avant le contenu final. Ne publiez pas ce raisonnement interne à l’utilisateur. Pour une chaîne de Tool Calls en Thinking, conservez le reasoning_content reçu dans le message assistant renvoyé à l’API, conformément au guide officiel, sous peine d’obtenir une erreur 400.

Streaming SSE avec l’API DeepSeek

Avec stream: true, l’API envoie des événements Server-Sent Events jusqu’au marqueur data: [DONE]. stream_options: {"include_usage": true} peut ajouter un dernier chunk d’utilisation sans élément dans choices. Un client personnalisé doit également tolérer les commentaires : keep-alive.

import os
import sys

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{
        "role": "user",
        "content": "Donne trois conseils concis pour sécuriser une API REST.",
    }],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=800,
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)

finish_reason = None
usage = None

for chunk in stream:
    if not chunk.choices:
        if chunk.usage is not None:
            usage = chunk.usage
        continue

    choice = chunk.choices[0]
    if choice.finish_reason is not None:
        finish_reason = choice.finish_reason

    # reasoning_content peut arriver avant content : ne l’affichez pas.
    _reasoning_piece = getattr(choice.delta, "reasoning_content", None)
    if choice.delta.content:
        sys.stdout.write(choice.delta.content)
        sys.stdout.flush()

print()
if finish_reason != "stop":
    raise RuntimeError(f"Streaming interrompu : {finish_reason}")
if usage is not None:
    print(f"Tokens totaux : {usage.total_tokens}", file=sys.stderr)

Le serveur peut envoyer des lignes vides en réponse non streamée. Si l’inférence n’a pas commencé au bout de dix minutes, la documentation indique que la connexion est fermée. Prévoyez donc un timeout côté client, mais adaptez-le aux tâches longues.

Obtenir un JSON valide avec JSON Output

Activez JSON Output avec response_format: {"type":"json_object"}. Le prompt doit demander explicitement du JSON et, de préférence, montrer le format attendu. Une sortie JSON syntaxiquement valide n’est pas une validation métier : parsez le texte, contrôlez les clés et types, puis refusez les valeurs inattendues. La documentation signale aussi que le contenu peut occasionnellement être vide.

import json
import os

from openai import OpenAI

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

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {
            "role": "system",
            "content": (
                "Réponds uniquement en JSON valide. Format attendu : "
                '{"language":"fr","confidence":0.95,"keywords":["mot"]}.'
            ),
        },
        {
            "role": "user",
            "content": "Analyse : Le chiffrement protège les données en transit.",
        },
    ],
    response_format={"type": "json_object"},
    max_tokens=500,
    extra_body={"thinking": {"type": "disabled"}},
)

if not response.choices or response.choices[0].finish_reason != "stop":
    raise RuntimeError("Sortie JSON absente ou interrompue")

content = response.choices[0].message.content
if not content:
    raise RuntimeError("Sortie JSON vide")

result = json.loads(content)
required = {"language", "confidence", "keywords"}
if not isinstance(result, dict) or set(result) != required:
    raise ValueError("Structure JSON inattendue")
if not isinstance(result["language"], str):
    raise ValueError("language est invalide")
if not isinstance(result["confidence"], (int, float)):
    raise ValueError("confidence est invalide")
if not isinstance(result["keywords"], list) or not all(
    isinstance(item, str) for item in result["keywords"]
):
    raise ValueError("keywords est invalide")

print(json.dumps(result, ensure_ascii=False, indent=2))

Pour un validateur complet avec contrôle de chaque type, consultez notre guide JSON Output avec DeepSeek.

Function Calling et Tool Calls

Dans un Tool Call, le modèle ne lance jamais lui-même une fonction. Il propose un nom et des arguments dans tool_calls ; votre backend décide si l’appel est autorisé, parse et valide la chaîne JSON, exécute l’outil réel puis renvoie le résultat avec le même tool_call_id. La référence documente jusqu’à 128 fonctions.

• Utilisez une allowlist de fonctions ; ne résolvez jamais un nom arbitraire généré par le modèle.
• Validez les types, formats, plages de valeurs, droits de l’utilisateur et règles métier.
• Exigez une confirmation pour une action destructive ou financière.
• Définissez un timeout et une limite de taille pour chaque outil.
• Ne placez aucun secret dans la description de l’outil ou son résultat.

Le strict mode reste en bêta, utilise https://api.deepseek.com/beta et impose des contraintes JSON Schema précises. Même en strict mode, votre serveur reste responsable de la sûreté et de la justesse métier. La documentation générale présente tool_choice, tandis qu’une autre page officielle indique que V4 le rejette en Thinking ; omettez-le dans ce mode tant que les pages ne sont pas harmonisées. Le guide Function Calling DeepSeek fournit la boucle complète et des exemples dédiés.

Cache de contexte et conversations multi-tours

Le cache de contexte sur disque est activé automatiquement et fonctionne sur les préfixes répétés. Un cache hit est fourni au mieux, jamais garanti. Les sorties ne sont pas rejouées depuis le cache : elles sont générées à chaque requête. Mesurez le résultat avec prompt_cache_hit_tokens et prompt_cache_miss_tokens dans usage. Les entrées inutilisées sont généralement supprimées après quelques heures à quelques jours.

L’API n’injecte pas automatiquement l’historique d’une conversation. Votre application doit renvoyer les messages utiles à chaque requête, tout en respectant la fenêtre de contexte. Ici, le terme « stateless » décrit la gestion du contexte conversationnel ; il ne signifie pas absence de journaux, de cache, de traitement ou de conservation des données.

Données sensibles : la politique de confidentialité de DeepSeek indique que des entrées, prompts et données de journal peuvent être collectés. Ne transmettez jamais de mot de passe, clé API, secret de production, donnée de santé ou autre donnée personnelle sensible dans un prompt. Si votre application traite les données de tiers, publiez vos propres informations de confidentialité et vérifiez votre base légale avant toute transmission.

Format Anthropic et FIM Completion

Compatibilité Anthropic partielle

DeepSeek propose un format Anthropic à l’adresse https://api.deepseek.com/anthropic. Il ne s’agit pas d’une reproduction complète de l’API Anthropic : plusieurs en-têtes, paramètres et blocs de contenu sont ignorés ou non pris en charge, notamment des fonctions liées aux images, documents, MCP et Code Execution. Consultez la matrice de compatibilité officielle avant une migration.

FIM Completion en bêta

FIM complète du code entre un préfixe et un suffixe via l’URL bêta https://api.deepseek.com/beta et POST /completions. La documentation n’est pas entièrement harmonisée au 22 juillet 2026 : le tableau des modèles affiche FIM pour Flash et Pro en non-thinking, tandis que la référence de /completions ne liste que deepseek-v4-pro. Utilisez Pro dans les exemples de production et considérez FIM sur Flash comme non confirmé jusqu’à clarification. Notre guide DeepSeek pour coder détaille ce mode.

Limites de concurrence, erreurs et stratégie de retry

La concurrence documentée est de 2 500 requêtes actives pour V4 Flash et de 500 pour V4 Pro. Ces limites sont calculées au niveau du compte : créer plusieurs clés n’augmente pas la capacité. Au-delà, l’API peut répondre avec HTTP 429.

Code	Signification documentée	Action recommandée
400	Format de requête invalide	Contrôler le JSON, les messages et, en Thinking avec Tool Calls, reasoning_content.
401	Authentification incorrecte	Vérifier ou remplacer la clé sans la journaliser.
402	Solde insuffisant	Vérifier le compte et la facturation.
422	Paramètres invalides	Comparer le payload à la référence du endpoint.
429	Rythme ou concurrence dépassés	Réduire la charge et appliquer un backoff exponentiel avec jitter.
500	Erreur serveur	Retenter brièvement avec un nombre maximal de tentatives.
503	Serveur surchargé	Retenter après une attente et prévoir un fallback.

Retentez uniquement les opérations idempotentes ou protégées contre les doublons. Si la réponse contient Retry-After, respectez sa valeur ; sinon, calculez votre propre délai avec exponentielle et jitter. Fixez un nombre maximal de tentatives, ouvrez un circuit breaker en cas d’échec persistant et n’effectuez pas de boucle infinie. Pour aller plus loin, consultez les limites de concurrence de l’API et les codes d’erreur DeepSeek.

Checklist avant la mise en production

• Modèle : utilisez un identifiant renvoyé par GET /models et testez Flash contre Pro sur votre jeu d’évaluation.
• Mode : envoyez explicitement thinking.type au lieu de dépendre d’un défaut susceptible d’évoluer.
• Secrets : conservez la clé côté serveur, dans un gestionnaire de secrets si possible.
• Entrées : limitez la longueur, filtrez les données sensibles et traitez les prompts comme des données non fiables.
• Sorties : contrôlez finish_reason, refusez une sortie vide ou tronquée et validez tout JSON.
• Outils : appliquez allowlist, permissions, validation et confirmation pour les actions sensibles.
• Résilience : ajoutez timeout, retry borné, jitter, circuit breaker et idempotence.
• Quotas : limitez l’usage par utilisateur et par projet ; un user_id pseudonyme peut aider au suivi, sans donnée personnelle.
• Observabilité : mesurez latence, codes HTTP, tokens, cache hits, coût et taux de troncature sans enregistrer les secrets.
• Confidentialité : documentez la transmission à DeepSeek et évitez les données personnelles sensibles.
• Maintenance : revérifiez prix, modèles et paramètres après chaque annonce de version.

Si l’API alimente une interface conversationnelle, consultez notre guide pour créer un chatbot avec l’API DeepSeek. Cette intégration appartient à votre application : deepseek-fr.ai n’héberge aucun chatbot.

Questions fréquentes sur l’API DeepSeek

Quelle URL de base utiliser pour l’API DeepSeek ?

Utilisez https://api.deepseek.com pour le format compatible OpenAI, puis /chat/completions pour une conversation. Le format Anthropic partiel utilise https://api.deepseek.com/anthropic.

Quels modèles faut-il utiliser en juillet 2026 ?

Les identifiants documentés sont deepseek-v4-flash et deepseek-v4-pro. Vérifiez toujours GET /models, surtout après le retrait annoncé des anciens alias deepseek-chat et deepseek-reasoner.

Thinking est-il activé par défaut ?

Oui, la documentation V4 actuelle indique que Thinking est activé par défaut. Pour un comportement reproductible, passez néanmoins {"thinking":{"type":"enabled"}} ou {"thinking":{"type":"disabled"}} explicitement.

presence_penalty et frequency_penalty fonctionnent-ils ?

Non. Les deux paramètres sont obsolètes et sans effet, aussi bien en Thinking qu’en non-thinking. Cette règle est distincte de temperature et top_p, qui sont ignorés spécifiquement en Thinking.

Pourquoi l’API renvoie-t-elle une erreur 429 ?

Une erreur 429 signale un rythme trop élevé ou un dépassement de la concurrence du compte. Réduisez la pression, mettez les requêtes en file et utilisez un backoff exponentiel avec jitter. Multiplier les clés d’un même compte n’augmente pas la limite.

L’API mémorise-t-elle automatiquement la conversation ?

Non. L’application renvoie les messages utiles à chaque tour. Cela ne constitue pas une promesse d’absence de collecte, de cache ou de conservation ; consultez les politiques officielles et ne transmettez pas de données sensibles.

deepseek-fr.ai fournit-il un chatbot ou une API ?

Non. deepseek-fr.ai est un guide indépendant en français. Il ne fournit ni chatbot, ni clé, ni endpoint API et ne traite aucun prompt. L’API décrite ici est celle de DeepSeek, accessible via la plateforme et la documentation officielles.

Sources officielles et méthode de vérification

Cette version a été contrôlée le 22 juillet 2026 à partir de sources primaires. Les exemples cURL, Python, JSON Output, streaming et TypeScript ont fait l’objet de vérifications syntaxiques et de tests locaux avec réponses simulées ; aucun appel payant n’a été effectué.

• Quick Start et URL de base
• Référence Chat Completions
• Modèles, fonctionnalités et prix
• Thinking Mode
• JSON Output
• Tool Calls
• Context Caching
• Conversations multi-tours
• Limites de concurrence
• Codes d’erreur
• Compatibilité Anthropic
• Référence FIM Completion
• Annonce V4 et retrait des anciens alias
• Politique de confidentialité DeepSeek

Note éditoriale : les recommandations de choix entre Flash et Pro, de validation, de retry et d’architecture sont des conseils pratiques de deepseek-fr.ai. Les valeurs techniques et tarifaires attribuées à DeepSeek sont reliées aux pages officielles correspondantes.