DeepseekText Chat

DeepSeek V4.1 Flash

API DeepSeek V4.1 Flash sous le tarif officiel DeepSeek, sans majoration en heures de pointe. Contexte 1M, entrée d'images native, scores de pointe en codage agentique. Testez-le ou appelez l'API.

EntréeOfficiel $0.15 par million de tokensAIReiter $0.1127 par million de tokensSortieOfficiel $0.60 par million de tokensAIReiter $0.4507 par million de tokensLecture cacheOfficiel $0.003 par million de tokensAIReiter $0.0022 par million de tokens

Exécuter avec l'API

ENTRÉE

FormJSONNode.jsPythonHTTP

Install the official OpenAI client — AIReiter speaks the same protocol, so only the base URL changes:

npm install openai

Set the AIREITER_API_KEY environment variable:

export AIREITER_API_KEY=<paste-your-key-here>

Point the client at AIReiter:

import OpenAI from "openai";

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

Run deepseek-v4-1-flash:

const response = await client.chat.completions.create({
    "model": "deepseek-v4-1-flash",
    "messages": [
      {
        "role": "user",
        "content": "A CI job started failing right after this diff. Find the root cause, propose the minimal fix, and list the shell commands you would run to verify it.\n\nDiff:\n--- a/src/orders/list.ts\n+++ b/src/orders/list.ts\n-  return items.filter((item) => item.active).map((item) => item.id);\n+  return items.filter((item) => item.active).map((item) => item.uuid);\n\nCI log:\nFAIL src/orders/list.test.ts\n  ● listActiveOrderIds › returns ids of active orders\n    expect(received).toEqual(expected)\n    Expected: [\"ord_1\", \"ord_2\"]\n    Received: [undefined, undefined]\nTests: 1 failed, 42 passed"
      }
    ],
    "max_tokens": 8192,
    "temperature": 1,
    "top_p": 1
  });

console.log(response);

Stream the response instead:

const stream = await client.chat.completions.create({
  ...{
    "model": "deepseek-v4-1-flash",
    "messages": [
      {
        "role": "user",
        "content": "A CI job started failing right after this diff. Find the root cause, propose the minimal fix, and list the shell commands you would run to verify it.\n\nDiff:\n--- a/src/orders/list.ts\n+++ b/src/orders/list.ts\n-  return items.filter((item) => item.active).map((item) => item.id);\n+  return items.filter((item) => item.active).map((item) => item.uuid);\n\nCI log:\nFAIL src/orders/list.test.ts\n  ● listActiveOrderIds › returns ids of active orders\n    expect(received).toEqual(expected)\n    Expected: [\"ord_1\", \"ord_2\"]\n    Received: [undefined, undefined]\nTests: 1 failed, 42 passed"
      }
    ],
    "max_tokens": 8192,
    "temperature": 1,
    "top_p": 1
  },
  stream: true,
});

for await (const event of stream) {
  console.log(event);
}

Install the official OpenAI client — AIReiter speaks the same protocol, so only the base URL changes:

pip install openai

Set the AIREITER_API_KEY environment variable:

export AIREITER_API_KEY=<paste-your-key-here>

Point the client at AIReiter:

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["AIREITER_API_KEY"],
    base_url="https://aireiter.com/api/v1",
)

Run deepseek-v4-1-flash:

response = client.chat.completions.create(
      model = "deepseek-v4-1-flash",
      messages = [
        {
          role = "user",
          content = "A CI job started failing right after this diff. Find the root cause, propose the minimal fix, and list the shell commands you would run to verify it.\n\nDiff:\n--- a/src/orders/list.ts\n+++ b/src/orders/list.ts\n-  return items.filter((item) => item.active).map((item) => item.id);\n+  return items.filter((item) => item.active).map((item) => item.uuid);\n\nCI log:\nFAIL src/orders/list.test.ts\n  ● listActiveOrderIds › returns ids of active orders\n    expect(received).toEqual(expected)\n    Expected: [\"ord_1\", \"ord_2\"]\n    Received: [undefined, undefined]\nTests: 1 failed, 42 passed"
        }
      ],
      max_tokens = 8192,
      temperature = 1,
      top_p = 1
)

print(response)

Stream the response instead:

stream = client.chat.completions.create(
      model = "deepseek-v4-1-flash",
      messages = [
        {
          role = "user",
          content = "A CI job started failing right after this diff. Find the root cause, propose the minimal fix, and list the shell commands you would run to verify it.\n\nDiff:\n--- a/src/orders/list.ts\n+++ b/src/orders/list.ts\n-  return items.filter((item) => item.active).map((item) => item.id);\n+  return items.filter((item) => item.active).map((item) => item.uuid);\n\nCI log:\nFAIL src/orders/list.test.ts\n  ● listActiveOrderIds › returns ids of active orders\n    expect(received).toEqual(expected)\n    Expected: [\"ord_1\", \"ord_2\"]\n    Received: [undefined, undefined]\nTests: 1 failed, 42 passed"
        }
      ],
      max_tokens = 8192,
      temperature = 1,
      top_p = 1,
    stream=True,
)

for event in stream:
    print(event)

SORTIE

Example

AperçuJSON

Root cause

The diff changed the mapped property from item.id to item.uuid. The order objects in the tests/fixtures have an id field, not a uuid field, so JavaScript returns undefined for item.uuid.

That matches the failure exactly:

filtering still finds 2 active items
mapping over them produces [undefined, undefined]
test expects ["ord_1", "ord_2"]

Minimal fix

Revert the property access back to item.id:

-  return items.filter((item) => item.active).map((item) => item.uuid);
+  return items.filter((item) => item.active).map((item) => item.id);

If the project intentionally migrated orders from id to uuid, then the real fix is to update the Order type, fixtures, and test expectations to use uuid. But for this CI regression, the minimal fix is to restore item.id.

Verification commands

# Inspect the current diff
git diff -- src/orders/list.ts

# Revert the changed property access
perl -pi -e 's/item\.uuid/item.id/' src/orders/list.ts

# Run the failing test file directly
npx jest src/orders/list.test.ts

# Run the full test suite
npm test

# If the project has a typecheck script, run it too
npm run typecheck

If the repo uses Yarn or pnpm, substitute the package-manager commands accordingly, e.g. yarn jest src/orders/list.test.ts and yarn test.

{
  "model": "deepseek-v4-1-flash",
  "input": {
    "model": "deepseek-v4-1-flash",
    "messages": [
      {
        "role": "user",
        "content": "A CI job started failing right after this diff. Find the root cause, propose the minimal fix, and list the shell commands you would run to verify it.\n\nDiff:\n--- a/src/orders/list.ts\n+++ b/src/orders/list.ts\n-  return items.filter((item) => item.active).map((item) => item.id);\n+  return items.filter((item) => item.active).map((item) => item.uuid);\n\nCI log:\nFAIL src/orders/list.test.ts\n  ● listActiveOrderIds › returns ids of active orders\n    expect(received).toEqual(expected)\n    Expected: [\"ord_1\", \"ord_2\"]\n    Received: [undefined, undefined]\nTests: 1 failed, 42 passed"
      }
    ],
    "max_tokens": 8192,
    "temperature": 1,
    "top_p": 1
  },
  "output": "## Root cause\n\nThe diff changed the mapped property from `item.id` to `item.uuid`. The order objects in the tests/fixtures have an `id` field, not a `uuid` field, so JavaScript returns `undefined` for `item.uuid`.\n\nThat matches the failure exactly:\n\n- filtering still finds 2 active items\n- mapping over them produces `[undefined, undefined]`\n- test expects `[\"ord_1\", \"ord_2\"]`\n\n## Minimal fix\n\nRevert the property access back to `item.id`:\n\n```diff\n-  return items.filter((item) => item.active).map((item) => item.uuid);\n+  return items.filter((item) => item.active).map((item) => item.id);\n```\n\nIf the project intentionally migrated orders from `id` to `uuid`, then the real fix is to update the `Order` type, fixtures, and test expectations to use `uuid`. But for this CI regression, the minimal fix is to restore `item.id`.\n\n## Verification commands\n\n```bash\n# Inspect the current diff\ngit diff -- src/orders/list.ts\n\n# Revert the changed property access\nperl -pi -e 's/item\\.uuid/item.id/' src/orders/list.ts\n\n# Run the failing test file directly\nnpx jest src/orders/list.test.ts\n\n# Run the full test suite\nnpm test\n\n# If the project has a typecheck script, run it too\nnpm run typecheck\n```\n\nIf the repo uses Yarn or pnpm, substitute the package-manager commands accordingly, e.g. `yarn jest src/orders/list.test.ts` and `yarn test`.",
  "metrics": {
    "input_tokens": 184,
    "output_tokens": 1471,
    "generated_in_seconds": 9.3
  },
  "example": true
}

Generated in

9.3 seconds

Token d’entrée

184

Token de sortie

1471

Tokens per second

158.17 tokens / second

Time to first token

Détails du modèle

Utilisez la même clé de modèle dans le Playground, les requêtes API et les workflows internes.

ID du modèle: deepseek-v4-1-flash
Fournisseur: Deepseek
Protocole: OpenAI Chat Completions · Anthropic Messages
Fenêtre de contexte: 1,000,000 tokens
Sortie maximale: 384,000 tokens
Token d’entrée: 11.27 crédits / 1 M de tokens
Token de sortie: 45.07 crédits / 1 M de tokens
Lecture du cache: 0.225 crédits / 1 M de tokens
Écriture du cache: -

Ce qui a changé dans DeepSeek V4.1 Flash

V4.1 Flash est une nouvelle famille de modèles, et non un simple réajustement de V4 Flash. DeepSeek a reconstruit l'architecture et l'a entraînée de zéro sur 45 000 milliards de tokens multimodaux, et le niveau Flash surpasse désormais V4 Pro sur la plupart des benchmarks d'agents.

MoE encodeur-décodeur causal

Un mélange d'experts (MoE) de 552B paramètres divisé en un encodeur à 20 couches et un décodeur à 20 couches. Seuls 8B paramètres sont actifs lors de la lecture de votre prompt et 16B lors de l'écriture de la réponse, ce qui permet à un modèle de cette taille de rester dans la gamme de prix Flash.

Codage agentique supérieur à V4 Pro

DeepSeek rapporte un score Terminal-Bench 2.1 de 90,6 contre 82,7 pour V4 Flash et 87,9 pour V4 Pro, DeepSWE à 74,2 contre 54,4 et 62,7, et Codeforces à 3471. Sur Terminal-Bench 3.0, le bond passe de 7,6 à 30,0.

Vision intégrée à l'entraînement, non greffée

Un nouvel encodeur DeepSeek-ViT a été entraîné conjointement avec le modèle de texte dès la première étape de pré-entraînement. V4 Flash était uniquement textuel et sa variante vision n'était qu'une expérimentation. Les captures d'écran, graphiques et photos s'intègrent dans la même requête que le prompt.

Cache KV réduit au quart pour un contexte de 1M

L'attention clairsemée compressée et le stockage KV en FP4 réduisent le cache global à environ 890 octets par token, soit environ un quart de V4 Flash. C'est ce qui permet à une fenêtre de 1M de tokens de fonctionner au coût Flash et à 214 tokens par seconde lors de tests indépendants.

DeepSeek V4.1 Flash vs V4 Flash

Chez DeepSeek, la migration a déjà été effectuée pour vous : l'ID officiel est désormais deepseek-flash, et les requêtes utilisant encore deepseek-v4-flash sont servies par V4.1. Sur AIReiter, les deux restent des modèles distincts afin que vous puissiez figer celui de votre choix.

Moins de paramètres actifs, des scores plus élevés

V4 Flash active 13B paramètres sur chaque token. V4.1 Flash en active 8B lors du pré-remplissage et 16B lors du décodage, tout en le surpassant sur chaque benchmark d'agents publié par DeepSeek. Ne voyez pas ce nombre réduit lors du pré-remplissage comme une régression.

Le raisonnement est désormais toujours actif

V4 Flash proposait des modes de réflexion discrets. V4.1 Flash utilise un effort de raisonnement continu, réglé par défaut sur élevé. Sur cette route, une requête désactivant le thinking renvoie tout de même du raisonnement ; prévoyez votre budget max_tokens en conséquence.

L'entrée d'images est intégrée au modèle de base

Si vous routiez les captures d'écran vers un endpoint de vision distinct aux côtés de V4 Flash, V4.1 Flash gère désormais les deux en un seul appel. Envoyez les images sous forme d'URI de données base64 dans le tableau content standard ; cette route ne récupère pas les URL d'images distantes.

Le tarif officiel de sortie a doublé, pas le cache

Le tarif officiel des tokens de sortie est passé de 0,28 $ à 0,60 $ par million de tokens. L'entrée avec cache hit reste proche de 0,003 $. Les charges de travail comportant un long préfixe stable et des réponses courtes coûtent quasiment la même chose qu'auparavant ; les générations verbeuses coûtent plus cher.

Quand conserver V4 Flash

Une suite d'évaluation figée, un client incapable de gérer reasoning_content dans les boucles d'outils, ou un budget strict de tokens de sortie ne permettant pas la migration. Sinon, commencez vos nouveaux projets sur V4.1 Flash.

Tarification de l'API DeepSeek V4.1 Flash

DeepSeek affiche 0,15 $ en entrée, 0,60 $ en sortie et 0,003 $ en entrée avec cache-hit par million de jetons pendant les heures creuses, et double ces trois tarifs en semaine de 01h00 à 04h00 et de 06h00 à 10h00 UTC. AIReiter facture un tarif unique 24h/24 : environ 25 % de moins que le tarif heures creuses et 62 % de moins que le tarif heures de pointe.

Un tarif unique, toute la journée

Les trois lignes de tarification des tokens sont chacune facturées à environ trois quarts du tarif heures creuses de DeepSeek. Il n'y a pas de plage d'heures de pointe sur cette route : une tâche exécutée pendant les heures de bureau à Pékin coûte le même prix qu'une tâche nocturne. Les tarifs en temps réel sont indiqués au-dessus du playground.

Où se situent réellement les économies

Par rapport au tarif officiel en heures de pointe, le prix sur AIReiter représente environ 38 %. Par rapport aux heures creuses, il est d'environ 75 %. Si votre trafic se concentre principalement en journée en Europe ou aux États-Unis (période de pointe pour DeepSeek), l'écart est encore plus important que ce que le chiffre principal suggère.

Les tokens de raisonnement sont facturés comme sortie

Le mode thinking ne peut pas être désactivé sur cette route et V4.1 Flash est verbeux avec un effort élevé. Des tests indépendants ont relevé environ deux fois plus de tokens de sortie que les modèles comparables sur le même ensemble de tâches. Configurez max_tokens pour inclure le raisonnement et la réponse.

Les hits de cache constituent la ligne la plus économique

Un jeton d'entrée avec correspondance en cache (cache-hit) coûte environ 2 % d'un jeton sans correspondance (cache-miss). Pour les boucles d'agents qui renvoient le même prompt système et le même schéma d'outils à chaque tour, les lectures en cache dominent la facture et constituent le point fort de V4.1 Flash en matière de coût.

Quand utiliser DeepSeek V4.1 Flash — et quand s'en abstenir

DeepSeek positionne désormais Flash devant V4 Pro en matière de qualité, de coût et de rapidité. Les seules raisons de choisir une autre option concernent le rappel des connaissances et la compatibilité client, et non les capacités brutes.

Utilisez-le pour le code et les agents de terminal

Les modifications multifichiers, les boucles de test et correction, le tri des journaux CI et les tâches de contrôle d'interface (« computer-use ») représentent les domaines où les gains publiés par rapport à V4 Flash et V4 Pro sont les plus importants. Les longs historiques d'outils tiennent dans la fenêtre de 1M sans découpage.

Utilisez-le pour les captures d'écran et les graphiques

L'OCR à partir d'une capture d'interface utilisateur, la lecture d'un graphique ou la vérification d'une page générée peuvent être intégrés directement dans la même requête que la question de code. Pas de second modèle, pas de seconde facture.

N'utilisez V4 Pro que pour des raisons de compatibilité

DeepSeek a maintenu la disponibilité de V4 Pro après le lancement de V4.1 Flash parce que les clients l'ont demandé, et non parce qu'il obtient de meilleurs scores. Restez sur Pro si un contrat ou un benchmark figé l'exige.

Ne l'utilisez pas comme une encyclopédie

Le modèle de base affiche un retard d'environ 13 points par rapport à V4 Pro sur SimpleQA-Verified. Pour la recherche de faits sans système de récupération (retrieval), ancrez le modèle avec vos propres documents ou choisissez un modèle optimisé pour le rappel.

Comparez avec GLM-5.3 Flash sur le plan tarifaire

GLM-5.3 Flash est l'autre modèle flash multimodal disponible sur AIReiter et propose un tarif de sortie plus bas. Choisissez V4.1 Flash lorsque la tâche implique une boucle d'agents ou le travail sur un dépôt ; choisissez GLM-5.3 Flash pour l'extraction et la classification à fort volume.

Appeler l'API DeepSeek V4.1 Flash

Le playground de cette page et l'API partagent le même identifiant de modèle. La seule règle d'intégration susceptible de faire échouer les clients concerne la gestion du raisonnement au sein des boucles d'outils.

Envoyez une véritable tâche d'agent dans le playground

Collez un journal d'erreurs avec le diff et une question. Observez les jetons de sortie, qui incluent le raisonnement, et vérifiez la qualité de la réponse avant de l'intégrer. L'entrée d'images est disponible via l'API.

POST /api/v1/chat/completions

Utilisez le modèle "deepseek-v4-1-flash", une clé API AIReiter et le corps de requête Chat Completions standard. Le streaming fonctionne. Le même identifiant est également accepté sur /api/v1/messages si votre infrastructure utilise Anthropic Messages.

Renvoyez reasoning_content en aller-retour lorsque des outils sont présents

Chaque fois que la requête inclut un tableau tools, chaque tour d'assistant précédent doit obligatoirement renvoyer son reasoning_content, y compris les tours sans appel d'outil. L'omettre renvoie une erreur HTTP 400. C'est cette règle qui a provoqué des dysfonctionnements dans plusieurs frameworks d'agents sur V4, et elle s'applique toujours.

Joindre des images dans le tableau content (API)

Utilisez un élément image_url avec un URI de données base64. Les formats PNG, JPEG, GIF et WebP sont acceptés. Les URL d'images distantes ne sont pas récupérées sur cette route ; intégrez donc directement les octets en ligne. Placez la partie texte en premier lorsque l'image sert de contexte à une question plutôt que de sujet principal.

Questions sur l'API DeepSeek V4.1 Flash

Model id, tarification, migration vers V4 Flash, entrée d'images et règle de raisonnement générant des erreurs.

/ 01

Quel est l'identifiant de modèle de l'API DeepSeek V4.1 Flash ?

Sur AIReiter, utilisez deepseek-v4-1-flash. La clé interne est chat-deepseek-v4-1-flash. Directement chez DeepSeek, l'identifiant officiel est deepseek-flash, et l'ancien identifiant deepseek-v4-flash est désormais également pris en charge par V4.1 Flash.

/ 02

Quelle est la tarification de DeepSeek V4.1 Flash ?

DeepSeek affiche 0,15 $ en entrée, 0,60 $ en sortie et 0,003 $ en entrée avec cache-hit par million de jetons en heures creuses, ces trois tarifs doublant en semaine pendant les heures de pointe. AIReiter facture un tarif unique à toute heure, environ 25 % sous le tarif catalogue en heures creuses et 62 % sous le tarif en heures de pointe. Les tarifs actuels de la route sont indiqués au-dessus du playground.

/ 03

V4.1 Flash est-il meilleur que V4 Pro ?

Sur les benchmarks d'agents et de code publiés par DeepSeek, oui : Terminal-Bench 2.1 obtient 90,6 contre 87,9 et DeepSWE 74,2 contre 62,7. V4 Pro reste en tête sur GPQA Diamond et sur le rappel de connaissances. DeepSeek redirige désormais lui-même les nouveaux utilisateurs vers Flash.

/ 04

Qu'est-ce qui change par rapport à V4 Flash ?

Une nouvelle architecture encodeur-décodeur avec 8B à 16B de paramètres actifs au lieu de 13B, la prise en charge native des images en entrée, un raisonnement toujours actif, un cache KV quatre fois plus petit pour la fenêtre de 1M, et des gains importants sur tous les benchmarks d'agents. Le prix catalogue officiel de sortie est également passé de 0,28 $ à 0,60 $.

/ 05

Puis-je désactiver le raisonnement ?

Pas sur cette route. Les requêtes demandant la désactivation du mode thinking renvoient tout de même reasoning_content, et reasoning_effort n'est pas transmis. Contrôlez plutôt les coûts avec max_tokens et un prompt concis.

/ 06

Accepte-t-il les images ?

Oui, via l'API. La vision est native dans V4.1 Flash et a été vérifiée sur cette route. Envoyez du PNG, JPEG, GIF ou WebP sous forme d'URI de données base64 dans une partie image_url ; les URL distantes ne sont pas récupérées. Le playground sur cette page est pour l'instant limité au texte.

/ 07

Pourquoi ma boucle de tool-calling renvoie-t-elle une erreur HTTP 400 ?

Vous avez omis reasoning_content d'un message précédent de l'assistant. Lorsqu'un tableau tools est présent, DeepSeek exige le champ reasoning sur chaque tour précédent de l'assistant, même pour les tours sans appel d'outil. Enregistrez-le et renvoyez-le tel quel.

/ 08

Quelles sont les limites de contexte et de sortie applicables ?

DeepSeek documente une fenêtre de contexte de 1M de tokens et une sortie maximale de 384K. Le playground est configuré par défaut sur 8192 tokens de sortie ; augmentez cette valeur pour les longues exécutions d'agents, et gardez à l'esprit que les tokens de raisonnement sont comptabilisés dedans.

/ 09

Quel endpoint dois-je appeler ?

POST https://aireiter.com/api/v1/chat/completions est le contrat principal pour ce modèle. POST https://aireiter.com/api/v1/messages fonctionne également avec le même id pour les clients de type Anthropic.

/ 10

Puis-je l'essayer avant de l'intégrer ?

Oui. Le playground sur cette page utilise le même model id et la même route que l'API, les décomptes de tokens et le comportement observés ici correspondent donc exactement à ce que l'API renvoie.