DeepSeek API : clé, tarifs et quand passer en local

#DeepSeek API : l'essentiel avant de commencer

DeepSeek propose deux portes d'entrée qu'il ne faut pas confondre. Le site de discussion, gratuit, s'utilise dans un navigateur. L'API, elle, s'adresse aux développeurs : votre programme envoie une requête, les serveurs de DeepSeek renvoient une réponse, et chaque échange est décompté de votre solde. C'est cette seconde porte que ce guide couvre.

Ce que c'est

Un service payant à l'usage, hébergé par DeepSeek. Vous ne téléchargez rien : le modèle tourne chez l'éditeur.

Le format

Compatible avec l'API d'OpenAI. Les bibliothèques et outils qui savent parler à OpenAI fonctionnent en changeant deux réglages : l'adresse de base et la clé.

La facturation

Au token, sur un solde prépayé. La grille distingue les tokens envoyés, selon qu'ils sont déjà en cache ou non, et les tokens générés.

Vos données

Chaque requête quitte votre infrastructure et est traitée sur les serveurs de l'éditeur. C'est le point à examiner en premier si vous manipulez des données personnelles ou confidentielles.

L'alternative

DeepSeek publie aussi les poids de ses modèles. Une version adaptée à votre matériel peut tourner sur votre machine, sans facturation au token ni envoi de données.

#Prérequis

Un compte développeur

Il se crée sur la plateforme de DeepSeek, à l'adresse platform.deepseek.com. Ce n'est pas la même adresse que le site de discussion.

Un moyen de paiement

Le service fonctionne sur un solde que vous créditez à l'avance. Sans solde disponible, les appels sont refusés.

Un outil pour appeler l'API

curl suffit pour un premier essai. Pour un vrai projet, Python 3 avec la bibliothèque openai, ou son équivalent pour Node.js.

Un endroit sûr pour la clé

Une variable d'environnement sur votre poste, un gestionnaire de secrets en production. Jamais le code source.

#Créer une clé DeepSeek API

1. 01
   Ouvrir un compte sur la plateforme

   Rendez-vous sur platform.deepseek.com en tapant l'adresse vous-même, puis inscrivez-vous. Pour un usage professionnel, utilisez une adresse partagée de l'équipe plutôt qu'une adresse personnelle : le compte porte le solde et les clés, il doit survivre au départ d'un collègue.
2. 02
   Créditer le solde

   La rubrique de rechargement de la plateforme permet d'ajouter du crédit. Commencez par un petit montant : il suffit largement pour les essais, et il borne mécaniquement la dépense si une boucle mal écrite s'emballe.
3. 03
   Générer la clé

   Dans la rubrique des clés d'API, créez une nouvelle clé et donnez-lui un nom qui dit à quoi elle sert (« essais-poste-clara », « prod-support »). Copiez-la tout de suite : comme sur la plupart des plateformes, elle n'est affichée en entier qu'au moment de sa création.
4. 04
   Ranger la clé hors du code

   Placez-la dans une variable d'environnement. Votre programme la lira au démarrage, et elle ne se retrouvera ni dans un dépôt Git ni dans une capture d'écran.

https://platform.deepseek.com/api_keys

export DEEPSEEK_API_KEY="collez-votre-cle-ici"

$env:DEEPSEEK_API_KEY = "collez-votre-cle-ici"

#Premier appel : le format compatible OpenAI

L'adresse de base de l'API est https://api.deepseek.com. La clé se transmet dans l'en-tête Authorization, précédée du mot Bearer. Avant d'envoyer une question, commencez par demander la liste des modèles que votre clé peut appeler : les identifiants changent d'une génération à l'autre, et c'est la seule liste qui soit à jour par construction.

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

La réponse est un objet JSON dont chaque entrée porte un champ id. C'est cet identifiant, recopié tel quel, qu'il faut placer dans vos requêtes. Beaucoup de tutoriels utilisent les noms historiques deepseek-chat et deepseek-reasoner : avant de les reprendre, vérifiez qu'ils figurent bien dans la liste renvoyée, et lisez sur la page de tarification à quel modèle chaque nom correspond aujourd'hui.

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY" \
  -d '{
    "model": "IDENTIFIANT_DU_MODELE",
    "messages": [
      {"role": "system", "content": "Tu réponds en français, en trois phrases maximum."},
      {"role": "user", "content": "Explique la notion de token pour un modèle de langage."}
    ],
    "stream": false
  }'

En Python, la bibliothèque officielle d'OpenAI fait le travail. Seuls deux paramètres diffèrent d'un appel à OpenAI : la clé et l'adresse de base.

pip install openai

import os
from openai import OpenAI

MODELE = "IDENTIFIANT_DU_MODELE"  # un id renvoyé par /models

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

reponse = client.chat.completions.create(
    model=MODELE,
    messages=[
        {"role": "system", "content": "Tu réponds en français, en trois phrases maximum."},
        {"role": "user", "content": "Explique la notion de token pour un modèle de langage."},
    ],
)

print(reponse.choices[0].message.content)
print(reponse.usage)  # le décompte qui sert à la facturation

La dernière ligne est la plus utile pour la suite. L'objet usage indique combien de tokens vous avez envoyés (prompt_tokens) et combien le modèle en a générés (completion_tokens). La documentation du cache de contexte décrit deux champs supplémentaires, prompt_cache_hit_tokens et prompt_cache_miss_tokens, qui séparent les tokens d'entrée déjà en cache de ceux qui ne l'étaient pas. Affichez l'objet renvoyé par votre propre appel : c'est lui qui fait foi, pas un exemple.

#Tarifs de la DeepSeek API : lire la grille officielle

Tous les prix se trouvent sur une seule page de la documentation. Ouvrez-la à côté de ce guide : les paragraphes qui suivent expliquent ce que signifie chaque ligne, pas ce qu'elle vaut.

https://api-docs.deepseek.com/quick_start/pricing/

La grille se présente comme un tableau, avec une colonne par modèle. Les prix y sont exprimés par million de tokens. Pour un texte français courant, un token représente un peu moins d'un mot, mais le rapport varie selon le modèle et le contenu : pour compter, fiez-vous à l'objet usage de vos réponses plutôt qu'à une règle de conversion.

Entrée, cache manqué (cache miss)

Le prix normal des tokens que vous envoyez : consigne système, historique de la conversation, documents joints, question.

Entrée, cache atteint (cache hit)

Un prix réduit, appliqué à la partie de votre requête que le service a déjà traitée récemment et gardée en cache.

Sortie (output)

Le prix des tokens générés par le modèle. Comparez cette ligne à celle de l'entrée : dans les API de ce type, c'est en général la plus élevée.

Tokens de raisonnement

Un modèle en mode raisonnement rédige une réflexion avant sa réponse. Vérifiez sur la page comment ces tokens sont comptés : s'ils sont facturés comme de la sortie, une réponse de trois lignes peut coûter le prix d'une page.

Contexte et sortie maximale

Le même tableau indique la longueur de contexte et la taille maximale d'une réponse. Ce ne sont pas des prix, mais elles plafonnent ce qu'une requête peut coûter.

Devise

Relevez la devise affichée. Si la grille n'est pas en euros, ajoutez le taux de change et les frais éventuels de votre banque sur les rechargements.

#Le cache de contexte, première source d'écart

Le cache fonctionne par préfixe : si le début d'une requête est identique au début d'une requête récente, cette partie commune est comptée au tarif réduit. Vous n'avez rien à activer. En revanche, l'ordre dans lequel vous construisez la requête décide de ce que vous payez.

Stable d'abord

Placez en tête ce qui ne change pas d'un appel à l'autre : consigne système, exemples, document de référence.

Variable à la fin

La question de l'utilisateur, la date, un identifiant de session vont en dernier. Une date insérée en première ligne suffit à rendre chaque requête unique, donc à perdre le bénéfice du cache.

Mesurer plutôt que supposer

Le cache n'est pas une garantie. La part réellement atteinte se lit dans les champs de cache de l'objet usage. Si elle reste proche de zéro alors que vos requêtes se ressemblent, c'est la construction de vos requêtes qu'il faut revoir.

#Heures creuses et remises temporaires

Une grille d'API peut prévoir un tarif réduit sur une plage horaire ou pendant une période de lancement. Trois vérifications s'imposent avant d'en tenir compte dans un budget.

La remise figure-t-elle sur la page aujourd'hui ?

Si la page officielle ne mentionne ni plage horaire ni remise, considérez qu'il n'y en a pas. Ne construisez pas un budget sur une réduction lue dans un article ancien.

Dans quel fuseau ?

Les plages sont en général données en UTC. En France métropolitaine, ajoutez une heure en hiver et deux en été.

Votre charge est-elle déplaçable ?

Une plage creuse ne profite qu'aux traitements qui peuvent attendre : résumés de nuit, classement de documents, génération par lots. Un assistant qui répond à des clients en journée n'en verra pas la couleur.

#Le calcul, avec vos chiffres

Le coût d'un appel est la somme de trois produits : tokens d'entrée hors cache, tokens d'entrée en cache et tokens de sortie, chacun multiplié par son prix puis divisé par un million. La fonction ci-dessous applique cette formule à l'objet usage d'une réponse. Les trois prix sont laissés à zéro : recopiez-les vous-même depuis la page officielle, pour le modèle que vous appelez.

# Prix par million de tokens, à recopier depuis la page officielle
# Relevé le : (notez la date ici)
PRIX_ENTREE_CACHE_MANQUE = 0.0
PRIX_ENTREE_CACHE_ATTEINT = 0.0
PRIX_SORTIE = 0.0

def cout_appel(usage):
    en_cache = getattr(usage, "prompt_cache_hit_tokens", 0) or 0
    hors_cache = usage.prompt_tokens - en_cache
    total = (
        hors_cache * PRIX_ENTREE_CACHE_MANQUE
        + en_cache * PRIX_ENTREE_CACHE_ATTEINT
        + usage.completion_tokens * PRIX_SORTIE
    )
    return total / 1_000_000

# Exemple : print(cout_appel(reponse.usage))

#Suivre sa consommation

Le solde restant se consulte sur la plateforme, et l'API expose un point d'accès qui le renvoie en JSON. C'est pratique pour déclencher une alerte avant la panne sèche plutôt qu'après.

curl https://api.deepseek.com/user/balance \
  -H "Authorization: Bearer $DEEPSEEK_API_KEY"

Journaliser chaque appel

Enregistrez la date, le modèle et les compteurs de l'objet usage. Deux semaines de journal en conditions réelles valent mieux que n'importe quelle estimation : c'est la base de la décision entre API et local.

Plafonner la sortie

Le paramètre max_tokens limite la longueur d'une réponse, donc son coût maximal. Réglez-le selon la tâche plutôt que de laisser la valeur par défaut.

Surveiller l'historique

Dans une conversation, tout l'historique est renvoyé à chaque tour. Une discussion de cinquante échanges renvoie cinquante fois son début, même si le cache en réduit le prix. Résumez ou tronquez au-delà d'une certaine longueur.

Crédit offert et crédit rechargé

Si votre compte dispose d'un crédit offert en plus du crédit rechargé, la page de tarification précise dans quel ordre ils sont consommés. Vérifiez aussi s'il a une date d'expiration.

#API ou modèle local : comment décider

Il n'existe pas de seuil universel à partir duquel le local devient moins cher, et ce guide n'en invente pas. Le résultat dépend de trois nombres que vous êtes seul à détenir : votre volume réel de tokens, la grille du jour et le prix du matériel que vous achèteriez. Les critères ci-dessous permettent souvent de trancher avant même de sortir la calculatrice.

Confidentialité

Données personnelles, contrats, code propriétaire, dossiers clients : avec l'API, ces contenus partent chez un tiers établi hors de l'Union européenne, ce qui relève du RGPD et se valide avec votre délégué à la protection des données. En local, la question ne se pose pas. C'est souvent le critère qui décide à lui seul.

Volume et régularité

Un usage faible ou irrégulier favorise l'API : vous ne payez rien quand vous ne l'utilisez pas. Un usage soutenu et prévisible favorise le local : la machine coûte la même chose qu'elle traite dix requêtes ou dix mille.

Qualité nécessaire

L'API sert les grands modèles de l'éditeur. Sur une carte de 12 à 24 Go de VRAM, vous ferez tourner des modèles nettement plus petits : comptez environ 9 Go pour un 14B et 19 Go pour un 32B en Q4_K_M. Si votre tâche exige le grand modèle, le local suppose un matériel d'une autre catégorie.

Disponibilité

L'API dépend de la charge de l'éditeur et de votre connexion. Le local dépend de votre machine, que vous devez surveiller et dépanner vous-même.

Prévisibilité du budget

La facture d'API suit l'usage et peut surprendre. Le local est un coût fixe, connu à l'avance : achat ou location, électricité, temps de maintenance.

Temps humain

L'API se branche vite : une clé, quelques lignes de code. Un serveur local demande une installation, des mises à jour et une personne qui sait quoi faire quand il ne répond plus. Ce temps a un coût, à inscrire dans la comparaison.

#La comparaison en quatre étapes

1. 01
   Mesurer

   Faites tourner votre cas d'usage sur l'API pendant deux semaines en journalisant l'objet usage. Vous obtenez un volume mensuel réel, réparti entre entrée hors cache, entrée en cache et sortie.
2. 02
   Chiffrer l'API

   Appliquez à ce volume la grille officielle du jour. C'est votre coût mensuel d'API, avec sa date de relevé.
3. 03
   Chiffrer le local

   Prenez le prix de la machine capable de faire tourner le modèle visé, répartissez-le sur la durée d'usage que vous retenez, ajoutez l'électricité et le temps de maintenance. Le guide sur le coût d'un serveur GPU détaille ce calcul.
4. 04
   Vérifier la qualité avant le prix

   Soumettez vingt requêtes réelles au modèle local que votre matériel peut accueillir et comparez les réponses à celles de l'API. Si le résultat ne convient pas, la comparaison de coût n'a plus d'objet : vous ne comparez pas le même service.

#Le même code pour les deux

Passer de l'un à l'autre ne demande pas de réécrire votre application. Ollama, qui écoute par défaut sur http://localhost:11434, expose lui aussi une interface compatible OpenAI sous le chemin /v1. Le code ci-dessous bascule entre l'API DeepSeek et un modèle local selon une variable d'environnement.

ollama pull deepseek-r1:14b

import os
from openai import OpenAI

LOCAL = os.environ.get("LLM_LOCAL") == "1"

if LOCAL:
    client = OpenAI(api_key="ollama", base_url="http://localhost:11434/v1")
    modele = "deepseek-r1:14b"
else:
    client = OpenAI(
        api_key=os.environ["DEEPSEEK_API_KEY"],
        base_url="https://api.deepseek.com",
    )
    modele = "IDENTIFIANT_DU_MODELE"  # un id renvoyé par /models

reponse = client.chat.completions.create(
    model=modele,
    messages=[{"role": "user", "content": "Résume ce texte en deux phrases : ..."}],
)
print(reponse.choices[0].message.content)

Le modèle deepseek-r1:14b est une version distillée, qui tient sur une carte de 12 Go comme une RTX 3060. Ce n'est pas le modèle servi par l'API : attendez-vous à des réponses moins précises sur les tâches difficiles. Ce montage sert justement à le constater sur vos propres requêtes, à l'étape quatre de la méthode.

#Dépannage : les erreurs courantes

La documentation de DeepSeek tient une page des codes d'erreur. Les cas ci-dessous sont ceux que l'on rencontre au démarrage ; en cas de doute, la page officielle prime sur ce résumé.

401, authentification refusée

La clé est absente, tronquée ou révoquée. Vérifiez que la variable d'environnement est bien définie dans le terminal qui lance le programme et qu'aucun espace ne s'est glissé au copier-coller.

402, solde insuffisant

Le compte n'a plus de crédit. Rechargez depuis la plateforme. Une alerte sur le point d'accès de solde évite que cela arrive en production.

400 ou 422, requête invalide

Le corps JSON est mal formé ou un paramètre n'est pas accepté. La cause la plus fréquente est un identifiant de modèle recopié d'un ancien tutoriel : repassez par la liste /models.

429, trop de requêtes

Vous envoyez plus vite que le service ne l'accepte. Espacez les appels et réessayez après un délai croissant.

500 ou 503, erreur ou surcharge du serveur

Le problème est du côté de l'éditeur. Réessayez après une attente, et prévoyez dans votre application un message clair ou un modèle de repli.

Réponse très lente

En période de forte charge, une requête peut attendre longtemps avant de commencer à répondre. Fixez un délai maximal côté client et activez le mode stream pour afficher la réponse au fil de l'eau.

Facture plus élevée que prévu

Trois suspects habituels : des tokens de raisonnement comptés en sortie, un cache rarement atteint, un historique de conversation renvoyé en entier à chaque tour. Le journal de l'objet usage permet de les départager.

#Sources officielles

Les prix, la liste des modèles et les règles de facturation évoluent. Ces pages de l'éditeur sont la référence, et ce sont elles qu'il faut consulter avant toute décision chiffrée.

https://api-docs.deepseek.com/quick_start/pricing/

https://api-docs.deepseek.com/

https://huggingface.co/deepseek-ai

#Pour aller plus loin

Ce guide s'arrête à la clé, à la lecture de la grille et à la méthode de décision. Pour chiffrer et installer, ces guides du site prennent le relais :

Combien coûte un serveur GPU pour LLM ?

Achat, location ou API : les postes de coût à additionner pour l'étape trois de la comparaison. https://quelllm.fr/guide/cout-serveur-gpu-llm

API LLM gratuites : le vrai comparatif

Les offres gratuites, leurs quotas et ce que deviennent vos données, si votre besoin tient dans un palier sans frais. https://quelllm.fr/guide/api-llm-gratuites-vs-local

DeepSeek V4 Pro en local

Le matériel qu'exige le grand modèle de la famille quand on veut l'exécuter soi-même. https://quelllm.fr/guide/guide-deepseek-v4-pro

IA locale vs ChatGPT

La même question, cloud ou local, posée pour un usage de discussion plutôt que pour une API. https://quelllm.fr/guide/ia-locale-vs-chatgpt