DeepseekText Chat

DeepSeek V4.1 Flash

API DeepSeek V4.1 Flash a prezzi inferiori al listino DeepSeek, senza ricarichi nelle ore di punta. Contesto da 1M, input di immagini nativo, punteggi di agentic coding al top. Provalo o chiama l'API.

InputUfficiale $0.15 per 1 M di tokenAIReiter $0.1127 per 1 M di tokenOutputUfficiale $0.60 per 1 M di tokenAIReiter $0.4507 per 1 M di tokenLettura cacheUfficiale $0.003 per 1 M di tokenAIReiter $0.0022 per 1 M di token

Esegui con API

INPUT

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)

OUTPUT

Example

AnteprimaJSON

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 input

184

Token output

1471

Tokens per second

158.17 tokens / second

Time to first token

Dettagli del modello

Usa la stessa chiave del modello nel Playground, nelle richieste API e nei flussi di lavoro interni.

ID modello: deepseek-v4-1-flash
Provider: Deepseek
Protocollo: OpenAI Chat Completions · Anthropic Messages
Finestra di contesto: 1,000,000 token
Output massimo: 384,000 token
Token input: 11.27 crediti / 1 M token
Token output: 45.07 crediti / 1 M token
Lettura cache: 0.225 crediti / 1 M token
Scrittura cache: -

Cosa cambia in DeepSeek V4.1 Flash

V4.1 Flash è una nuova famiglia di modelli, non una riottimizzazione di V4 Flash. DeepSeek ha ricostruito l'architettura e l'ha addestrata da zero su 45 mila miliardi di token multimodali; il livello Flash ora supera V4 Pro sulla maggior parte dei benchmark per agenti.

MoE encoder-decoder causale

Una mixture of experts da 552B suddivisa in un encoder da 20 layer e un decoder da 20 layer. Solo 8B parametri sono attivi durante la lettura del prompt e 16B durante la scrittura della risposta, motivo per cui un modello così grande rimane nella fascia di prezzo Flash.

Agentic coding superiore a V4 Pro

DeepSeek riporta Terminal-Bench 2.1 a 90,6 rispetto a 82,7 per V4 Flash e 87,9 per V4 Pro, DeepSWE a 74,2 rispetto a 54,4 e 62,7 e Codeforces a 3471. Su Terminal-Bench 3.0 il salto è da 7,6 a 30,0.

Visione integrata nativamente, non aggiunta a posteriori

Un nuovo encoder DeepSeek-ViT è stato addestrato congiuntamente al modello testuale sin dalla prima fase di pre-training. V4 Flash era solo testo e la sua variante vision era un esperimento. Screenshot, grafici e foto vengono inclusi nella stessa richiesta del prompt.

KV cache ridotta a un quarto per 1M di contesto

La compressed sparse attention e lo storage KV in FP4 riducono la cache globale a circa 890 byte per token, circa un quarto di V4 Flash. È questo che consente a una finestra di 1M di token di funzionare al costo di Flash e a 214 token al secondo nei test indipendenti.

DeepSeek V4.1 Flash vs V4 Flash

Su DeepSeek la migrazione è già avvenuta automaticamente: l'id ufficiale è ora deepseek-flash e le richieste che indicano ancora deepseek-v4-flash vengono servite da V4.1. Su AIReiter i due rimangono modelli separati, permettendoti di bloccare (pin) l'uno o l'altro.

Meno parametri attivi, punteggi più alti

V4 Flash attiva 13B parametri su ogni token. V4.1 Flash ne attiva 8B in fase di prefill e 16B in fase di decode, superandolo comunque in ogni benchmark per agenti pubblicato da DeepSeek. Non interpretare il numero inferiore di prefill come un downgrade.

Il thinking ora è sempre attivo

V4 Flash offriva modalità di thinking discrete. V4.1 Flash utilizza un reasoning effort continuo e impostato di default su high. Su questa route, una richiesta che invia thinking disabilitato restituisce comunque il reasoning; calcola max_tokens di conseguenza.

L'input di immagini fa parte del modello base

Se indirizzavi gli screenshot a un endpoint vision separato insieme a V4 Flash, V4.1 Flash gestisce entrambi in una sola chiamata. Invia le immagini come data URI base64 nell'array content standard; questa route non recupera URL di immagini remote.

Prezzo di listino dell'output raddoppiato, la cache no

L'output ufficiale è passato da 0,28 $ a 0,60 $ per milione di token. L'input con cache-hit rimane vicino a 0,003 $. I carichi di lavoro con un prefisso lungo e stabile e risposte brevi costano circa come prima; le generazioni prolungate costano di più.

Mantieni V4 Flash quando

Una suite di valutazione vincolata (pinned), un client che non supporta reasoning_content nei cicli di tool o un budget di output per token rigoroso non sono ancora pronti alla migrazione. Altrimenti, inizia i nuovi lavori su V4.1 Flash.

Prezzi delle API di DeepSeek V4.1 Flash

DeepSeek indica $0,15 per l'input, $0,60 per l'output e $0,003 per l'input con cache-hit per milione di token nelle ore non di punta, raddoppiando tutte e tre le tariffe nei giorni feriali dalle 01:00 alle 04:00 e dalle 06:00 alle 10:00 UTC. AIReiter applica una tariffa forfettaria unica 24 ore su 24: circa il 25% in meno rispetto al listino fuori punta e il 62% in meno rispetto a quello di punta.

Un'unica tariffa fissa, tutto il giorno

Le tre voci di token vengono fatturate ciascuna a circa tre quarti della tariffa fuori punta (off-peak) di DeepSeek. Non ci sono fasce di punta su questa route, quindi un processo eseguito durante l'orario d'ufficio di Pechino costa quanto uno notturno. Le cifre in tempo reale sono visibili sopra il playground.

Da dove deriva l'effettivo risparmio

Rispetto alla tariffa ufficiale di punta, il prezzo di AIReiter è pari a circa il 38%. Rispetto a quella fuori punta è circa il 75%. Se il tuo traffico si concentra nelle ore diurne europee o statunitensi, che corrispondono alle ore di punta di DeepSeek, il risparmio è persino superiore a quanto suggerito dal dato principale.

I token di ragionamento vengono fatturati come output

Il thinking non può essere disattivato su questa route e V4.1 Flash risulta prolisso con un effort elevato. Test indipendenti hanno registrato circa il doppio dei token di output rispetto a modelli comparabili sullo stesso set di attività. Imposta max_tokens per includere sia il reasoning che la risposta.

I cache hit sono la voce più economica

Un token di input con cache-hit costa circa il 2% di un token con cache-miss. Per i cicli di agenti che reinviano lo stesso system prompt e schema degli strumenti a ogni turno, le letture della cache dominano la spesa ed è qui che V4.1 Flash risulta più economico.

Quando usare DeepSeek V4.1 Flash — e quando non farlo

DeepSeek posiziona ora Flash davanti a V4 Pro per qualità, costi e velocità. I motivi rimanenti per scegliere un'altra soluzione riguardano il richiamo delle informazioni e la compatibilità dei client, non le capacità pure.

Usalo per il coding e gli agenti da terminale

Modifiche multi-file, cicli di test-fix, triage dei log di CI e attività di computer-use sono gli ambiti in cui i miglioramenti dichiarati rispetto a V4 Flash e V4 Pro risultano maggiori. Le tracce lunghe degli strumenti rientrano nella finestra da 1M senza necessità di chunking.

Usalo per screenshot e grafici

L'OCR da una cattura della UI, la lettura di un grafico o il controllo di una pagina renderizzata possono essere inclusi direttamente nella stessa richiesta della domanda sul codice. Nessun secondo modello, nessun costo aggiuntivo.

Usa V4 Pro solo per motivi di compatibilità

DeepSeek ha mantenuto attivo V4 Pro dopo il rilascio di V4.1 Flash su richiesta dei clienti, non perché ottenga punteggi più elevati. Rimani su Pro se richiesto da un contratto o da un frozen eval.

Non usarlo come enciclopedia

Il modello base è indietro rispetto a V4 Pro su SimpleQA-Verified di circa 13 punti. Per la ricerca di fatti senza retrieval, ancora il modello con i tuoi documenti o scegli un modello ottimizzato per il recall.

Confrontalo con GLM-5.3 Flash in termini di prezzo

GLM-5.3 Flash è l'altro modello flash multimodale su AIReiter ed è più economico sull'output. Scegli V4.1 Flash quando l'attività è un ciclo di agenti o lavoro su repository; scegli GLM-5.3 Flash per estrazione e classificazione su larga scala.

Chiamare l'API DeepSeek V4.1 Flash

Il playground su questa pagina e l'API condividono lo stesso model id. L'unica regola di integrazione che causa problemi ai client riguarda la gestione del reasoning all'interno dei cicli dei tool.

Invia una vera attività di agent nel playground

Incolla un log di errore con il diff e una domanda. Osserva i token di output, che includono il reasoning, e verifica la qualità della risposta prima dell'integrazione. L'input di immagini è disponibile tramite API.

POST /api/v1/chat/completions

Usa il modello "deepseek-v4-1-flash", una chiave API AIReiter e il body standard di Chat Completions. Lo streaming è supportato. Lo stesso id è accettato anche su /api/v1/messages se il tuo stack supporta Anthropic Messages.

Includi reasoning_content nel round-trip quando sono presenti strumenti

Ogni volta che la richiesta include un array tools, ciascun turno precedente dell'assistant deve riportare il proprio reasoning_content, inclusi i turni in cui non è stata effettuata alcuna chiamata a strumenti. Ometterlo restituirà un errore HTTP 400. Questa è la regola che ha causato problemi a diversi framework di agenti su V4 e rimane tuttora valida.

Allega immagini nell'array content (API)

Usa una sezione image_url con un URI dati in base64. Sono accettati i formati PNG, JPEG, GIF e WebP. Gli URL di immagini remote non vengono recuperati su questo endpoint, quindi inserisci i byte inline. Posiziona la parte di testo prima quando l'immagine funge da contesto per una domanda piuttosto che come soggetto.

Domande sull'API DeepSeek V4.1 Flash

Model id, prezzi, migrazione a V4 Flash, input di immagini e la regola di reasoning che genera errori.

/ 01

Qual è il model id dell'API DeepSeek V4.1 Flash?

Su AIReiter usa deepseek-v4-1-flash. La chiave interna è chat-deepseek-v4-1-flash. Direttamente su DeepSeek l'id ufficiale è deepseek-flash, e il precedente id deepseek-v4-flash è ora servito anch'esso da V4.1 Flash.

/ 02

Come viene calcolato il prezzo di DeepSeek V4.1 Flash?

DeepSeek elenca $0,15 per l'input, $0,60 per l'output e $0,003 per l'input con cache-hit per milione di token fuori punta, con tutti e tre che raddoppiano durante le ore di punta nei giorni feriali. AIReiter applica una tariffa fissa a tutte le ore, circa il 25% in meno rispetto al listino fuori punta e il 62% in meno rispetto a quello di punta. I prezzi attuali degli endpoint sono mostrati sopra il playground.

/ 03

V4.1 Flash è migliore di V4 Pro?

Sui benchmark di agenti e coding pubblicati da DeepSeek, sì: Terminal-Bench 2.1 è a 90,6 contro 87,9 e DeepSWE è a 74,2 contro 62,7. V4 Pro è ancora in testa su GPQA Diamond e sul richiamo delle conoscenze. La stessa DeepSeek ora indirizza i nuovi utenti verso Flash.

/ 04

Cosa c'è di diverso rispetto a V4 Flash?

Una nuova architettura encoder-decoder con 8B-16B parametri attivi invece di 13B, supporto nativo per l'input di immagini, reasoning sempre attivo, una KV cache di dimensioni ridotte a un quarto per la finestra da 1M e notevoli miglioramenti in tutti i benchmark per agenti. Anche il prezzo di listino ufficiale dell'output è salito da $0.28 a $0.60.

/ 05

Posso disattivare il thinking?

Non su questo route. Le richieste inviate con thinking disabilitato restituiscono comunque reasoning_content, e reasoning_effort non viene inoltrato. Controlla invece i costi impostando max_tokens e un prompt più conciso.

/ 06

Accetta immagini?

Sì, tramite l'API. La vision è nativa in V4.1 Flash ed è stata verificata su questo route. Invia file PNG, JPEG, GIF o WebP come URI dati base64 all'interno di una parte image_url; gli URL remoti non vengono recuperati. Il playground in questa pagina è per ora solo di testo.

/ 07

Perché il mio ciclo di tool-calling restituisce un errore HTTP 400?

Hai rimosso reasoning_content da un messaggio precedente dell'assistant. Quando è presente l'array tools, DeepSeek richiede il campo reasoning in ogni turno precedente dell'assistant, anche in quelli senza chiamata di strumenti. Memorizzalo e rinvialo invariato.

/ 08

Quali limiti di contesto e output si applicano?

DeepSeek documenta una finestra di contesto da 1M di token e un output massimo di 384K. Il playground è impostato di default su 8192 token di output; aumentalo per esecuzioni prolungate con agenti e ricorda che i token di reasoning vengono conteggiati nel totale.

/ 09

Quale endpoint devo chiamare?

POST https://aireiter.com/api/v1/chat/completions è il contratto principale per questo modello. Anche POST https://aireiter.com/api/v1/messages funziona con lo stesso id per i client in stile Anthropic.

/ 10

Posso provarlo prima dell'integrazione?

Sì. Il playground in questa pagina esegue lo stesso model id e route dell'API, quindi il conteggio dei token e il comportamento visualizzati qui corrispondono esattamente a quanto restituito dall'API.