✨ อัปเดตล่าสุด: how to use deepseek v flash api

Q: Does DeepSeek's API support streaming and tool calling?

Yes to both. Streaming works via the standard stream: true parameter and server-sent events, matching the OpenAI Responses API pattern. Tool/function calling uses the same tools and tool_choice parameters as OpenAI's schema, so existing agent code built around OpenAI's tool-calling format needs minimal changes to work against DeepSeek.

Q: Can I use DeepSeek's API as a drop-in replacement for Claude?

DeepSeek documents an Anthropic-compatible base URL at https://api.deepseek.com/anthropic that accepts requests shaped like Claude's Messages API, which allows apps built around that schema to route to DeepSeek with minimal request-formatting changes. This is separate from the OpenAI-compatible endpoint and is worth testing directly against your specific message payloads before relying on it in production.

Sofia Lindström

September 10, 2026

25 min read

DeepSeek shipped a new production model that actually went generally available on September 9, 2026, with peak pricing confirmed at $0.30 per 1M input tokens and $1.20 per 1M output tokens: deepseek-v4.1-flash, callable via the API as deepseek-flash. It arrived weeks after the V4-Pro general release on August 13, and on September 10, 2026 it formally replaced deepseek-v4-flash and its vision variant, with new off-peak pricing — $0.15 per 1M input tokens, $0.60 per 1M output tokens, and $0.003 per 1M cache-hit input tokens off-peak, with peak rates at 2× those figures — taking effect at 04:00 UTC on September 10, 2026. DeepSeek’s announcement also said that starting September 14, calls to deepseek-v4-pro would be routed to V4.1 Flash and billed at Flash rates, and that change went into effect as scheduled: since 04:00 UTC on September 14, 2026, every deepseek-v4-pro request is served by V4.1 Flash and billed at Flash rates, and that same day DeepSeek retired the deepseek-v4-flash and vision-variant alias names it had been running since September 10, a step beyond the routing change alone. That holds until DeepSeek ships a dedicated V4.1 Pro model. That detail is easy to miss if you stopped reading after the September 10 announcement and assumed it hadn’t happened yet, and it is part of why “deepseek api” and “deepseek v4” have both climbed past 20,000 monthly US searches this month.

This tutorial walks through setting up the DeepSeek API from a cold start: getting a key, wiring up the OpenAI-compatible SDK in Python and Node.js, calling both deepseek-flash (aliased from the older deepseek-v4-flash) and deepseek-v4-pro, understanding the V4-Pro routing change, streaming responses, using JSON mode and tool calling, and deploying a small working project. By the end you will have a working script that calls DeepSeek from either SDK, plus a troubleshooting list for the errors you are most likely to hit.

Google · Preferred Sources

Don't miss new tech stories on Google

Add Tech Insider once in the Google app and our stories appear in your news suggestions.

Add Now

Quick answer: DeepSeek V4.1 Flash pricing and model ID

Here’s the short version before the full walkthrough below.

Model ID: deepseek-flash is the current API name for V4.1 Flash. The older deepseek-v4-flash string still works and points to the same model.
Pricing: $0.15 per 1M input tokens, $0.60 per 1M output tokens, and $0.003 per 1M cache-hit input tokens, all off-peak. Peak hours run 2× those rates.
Base URL: https://api.deepseek.com, OpenAI-compatible, so the standard openai SDK works with a config change.
Context window: 1 million tokens in, with Flash capped at 384K tokens out.
Architecture: a 552B-parameter Mixture-of-Experts backbone that is natively multimodal, per DeepSeek’s Hugging Face model card.
deepseek-v4-pro: routed to V4.1 Flash and billed at Flash’s rate since 04:00 UTC on September 14, 2026, until DeepSeek ships a dedicated V4.1 Pro model.

What changed with DeepSeek V4.1 Flash on September 10, 2026

DeepSeek’s official changelog lists V4.1 Flash as generally available starting September 9, 2026, with the broader release formally replacing deepseek-v4-flash and its vision variant on September 10, 2026, following the DeepSeek-V4-Pro-0813 general availability on August 13 and the DeepSeek-V4-Flash-0731 update on July 31. The naming is confusing on purpose in one sense and accidental in another: DeepSeek reuses model family names (Flash, Pro) while appending date-stamped build tags internally, so deepseek-v4-flash as an API model string today resolves to V4.1 Flash’s newer weight set, even though the string in your code never changes. DeepSeek’s documentation now lists deepseek-flash as the current model ID going forward; deepseek-v4-flash and deepseek-v4-flash-vision-exp were initially routed to it for backward compatibility before DeepSeek retired both legacy names outright on September 14, 2026 — fitting, since DeepSeek’s own Hugging Face model card confirms V4.1 Flash is natively multimodal rather than needing a separate vision variant.

The part that matters for anyone with DeepSeek already wired into a product: DeepSeek’s September 10 announcement said that starting September 14, 2026, calls to the deepseek-v4-pro model string would be transparently routed to V4.1 Flash and billed at Flash rates until a V4.1 Pro model shipped. That change went into effect on schedule: since 04:00 UTC on September 14, 2026, deepseek-v4-pro requests are routed to V4.1 Flash and billed at Flash rates, and DeepSeek has not published a reversal or a V4.1 Pro ship date as of this writing. DeepSeek’s public pricing page, last updated September 20, 2026, still lists V4.1 Flash at these same rates with no V4.1 Pro or successor model announced, so the routing arrangement described here remained the live state of the API in late September 2026. If you already have deepseek-v4-pro in production, no code changes are required — the model string still works — but your bill and your output now reflect Flash, not the older standalone Pro model. Step 6 below covers how to confirm that in your own logs.

Both V4-family models are Mixture-of-Experts architectures with a 1 million token context window. DeepSeek-V4-Pro runs at roughly 1.6 trillion total parameters with about 49 billion active per token, according to third-party model overviews. For V4.1 Flash, DeepSeek’s Hugging Face model card publishes an official spec directly: a 552B-parameter MoE backbone, natively multimodal, with support for up to one million tokens of context. What is documented is the pricing split between the two model families and the fact that both sit behind the same OpenAI-compatible API surface, so the code you write for one works against the other by changing a single string — though as of September 14, 2026, a request to deepseek-v4-pro is actually served by the Flash weights described above until V4.1 Pro ships.

Prerequisites and versions

You do not need a DeepSeek-specific SDK. DeepSeek’s API is OpenAI-compatible, so the official OpenAI client libraries work once you swap the base URL and API key. Here is what to have installed before you start:

A DeepSeek account and API key from the DeepSeek platform (requires a Chinese or international phone/email verification depending on region)
Python 3.10 or newer, or Node.js 18 LTS or newer
openai Python package, version 1.50.0 or later (pip install openai)
openai Node.js package, version 4.60.0 or later (npm install openai)
curl for quick endpoint testing
A text editor and terminal — VS Code, Cursor, or any equivalent
Optional: python-dotenv or Node’s built-in --env-file flag to keep the API key out of source

Nothing here requires a GPU or local hardware — every request goes to DeepSeek’s hosted inference, so a laptop or a $5/month VPS is enough to follow along and build the working project at the end.

Step 1: Create a DeepSeek account and generate an API key

Go to the DeepSeek platform, sign up with an email or phone number, and verify the account. Once inside the console, open the API Keys section and generate a new key. DeepSeek keys are shown once at creation time — copy it immediately into a password manager or a local .env file, because the dashboard will only show a masked version afterward.

Store the key as an environment variable rather than pasting it into code:

# macOS/Linux
export DEEPSEEK_API_KEY="your-key-here"

# Windows PowerShell
$env:DEEPSEEK_API_KEY="your-key-here"

Add billing before you make your first real call. DeepSeek requires a prepaid balance on most accounts; unfunded keys return authentication errors that look identical to a bad key, which is the first item on the troubleshooting list further down.

Step 2: Understand the base URL and authentication format

DeepSeek’s API documentation lists the OpenAI-compatible base URL as https://api.deepseek.com, with some SDK examples using the /v1 suffix as an equivalent path. DeepSeek also documents an Anthropic-compatible variant at https://api.deepseek.com/anthropic for teams already standardized on the Claude Messages API shape — useful if you’re running a router that swaps providers without rewriting request bodies.

Authentication uses a standard bearer token header, the same pattern OpenAI, Anthropic, and most hosted LLM APIs use:

Authorization: Bearer YOUR_DEEPSEEK_API_KEY
Content-Type: application/json

Because the API mirrors OpenAI’s request and response schema, you do not install a separate deepseek package for Python or Node. You install the standard openai package and override base_url (Python) or baseURL (Node) plus the API key. This is the single biggest time-saver in this whole setup: any OpenAI-compatible tooling — LangChain, LlamaIndex, Vercel AI SDK — should work against DeepSeek with a config change and no new adapter code.

Step 3: Install the SDK and make your first call in Python

Install the OpenAI Python package if you don’t already have it:

pip install --upgrade openai python-dotenv

Create a file named deepseek_hello.py:

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-flash",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain the difference between MoE and dense transformer architectures in 3 sentences."},
    ],
    max_tokens=300,
    temperature=0.3,
)

print(response.choices[0].message.content)
print("Tokens used:", response.usage.total_tokens)

Run it with python deepseek_hello.py. A working call returns a normal chat completion object with choices, usage, and model fields — identical in shape to an OpenAI response, because that is the whole point of the compatibility layer.

Example output

Mixture-of-Experts (MoE) models route each token through a small subset of specialized
"expert" sub-networks chosen by a gating function, so only a fraction of total parameters
activate per token. Dense transformers activate every parameter for every token, which is
simpler but scales compute linearly with model size. MoE lets a model like DeepSeek-V4-Pro
carry roughly 1.6T total parameters while only computing through about 49B active
parameters per forward pass, cutting inference cost relative to an equally large dense model.
Tokens used: 187

Step 4: Make your first call in Node.js

If your stack is JavaScript or TypeScript, the same pattern applies with the Node OpenAI SDK:

npm install openai dotenv

Create deepseek-hello.js:

import OpenAI from "openai";

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

async function main() {
  const completion = await client.chat.completions.create({
    model: "deepseek-flash",
    messages: [
      { role: "system", content: "You are a concise technical assistant." },
      { role: "user", content: "List 3 use cases for a 1M-token context window." },
    ],
    max_tokens: 300,
    temperature: 0.3,
  });

  console.log(completion.choices[0].message.content);
  console.log("Tokens used:", completion.usage.total_tokens);
}

main();

Run with node --env-file=.env deepseek-hello.js on Node 20+, or load dotenv manually on older versions. The response object mirrors the Python example exactly — same field names, same structure.

Step 5: Choose between deepseek-flash and deepseek-v4-pro

DeepSeek’s official model tables currently list deepseek-flash (the current V4.1 Flash ID, generally available since September 9, 2026) and deepseek-v4-pro as the two live model strings. The older deepseek-v4-flash string and the deepseek-v4-flash-vision-exp legacy alias pointed at the same natively multimodal weights only as a bridge, and DeepSeek retired both of those legacy names outright on September 14, 2026 — the same day the V4-Pro routing change took effect. DeepSeek’s Hugging Face model card confirms the 552B-parameter Flash backbone handles image and text input directly, without needing a separate vision variant. Legacy aliases like deepseek-chat and deepseek-reasoner still resolve for existing integrations, but DeepSeek’s guidance is to call the current documented IDs directly, since deepseek-v4-flash and its vision alias are proof that phased-out legacy names do eventually stop working.

Model	Input, cache-miss (off-peak / peak)	Input, cache-hit (off-peak / peak)	Output (off-peak / peak)	Context	Best for
deepseek-flash (deepseek-v4-flash)	$0.15 / $0.30 per M tokens	$0.003 / $0.006 per M tokens	$0.60 / $1.20 per M tokens	1M tokens in, 384K max output	High-volume chat, summarization, agent tool calls, native image + text input
deepseek-v4-pro (billed as Flash since Sept 14, 2026)	$0.15 / $0.30 per M tokens	$0.003 / $0.006 per M tokens	$0.60 / $1.20 per M tokens	1M tokens	Same routing as Flash until V4.1 Pro ships; legacy standalone rate was $0.66 / $1.32 input, $1.98 / $3.96 output
deepseek-v4-flash-vision-exp	Same tier as Flash (legacy alias)	Same tier as Flash (legacy alias)	Same tier as Flash (legacy alias)	1M tokens	Now routed to Flash’s native multimodal weights, not a separate model

Pricing above reflects DeepSeek’s official rates: Flash pricing took effect September 10, 2026, with off-peak set at half the peak rate. deepseek-v4-pro ran at its own standalone rate (last set in the August 16, 2026 peak/off-peak overhaul) until 04:00 UTC on September 14, 2026, when DeepSeek’s routing change took effect and every deepseek-v4-pro request started billing at the Flash rate shown above instead — that holds until a V4.1 Pro model ships. Peak hours are 01:00–04:00 UTC and 06:00–10:00 UTC, Monday through Friday; every other hour bills at the off-peak rate. Input pricing also splits into cache-hit and cache-miss rates — repeated prompts (like a fixed system prompt) that hit the prompt cache bill at the lower cache-hit rate shown above, while a fresh, uncached prompt bills at the cache-miss rate. Factor that into cost estimates if your app sends the same system prompt on every request, which is the common case for agents and chatbots.

For rough context against the rest of the frontier field: one September 2026 pricing comparison put GPT-6 Astra and Claude Fable 5.1 at $10 per million input tokens and $50 per million output tokens, and Gemini 3.8 Flash at $0.75 input / $3.75 output per million tokens. Against that field, a deepseek-v4-pro call — currently billed at Flash’s peak rate of $0.30 input / $1.20 output following the September 14 routing change — lands far under the Astra/Fable tier and well under Gemini 3.8 Flash too, the same margin Flash itself gets credit for. Treat that comparison as directional — pricing across providers changes fast enough in 2026 that you should re-check current rates before committing a production budget, and again once V4.1 Pro ships with its own pricing.

Step 6: Understand the V4-Pro routing change (and what to check in your own logs)

DeepSeek’s September 10 announcement said that starting September 14, 2026, deepseek-v4-pro requests would route to V4.1 Flash and bill at Flash rates, and that’s exactly what happened: since 04:00 UTC on September 14, 2026, every deepseek-v4-pro call is served by V4.1 Flash and billed at Flash’s rates, and stays that way until a V4.1 Pro model ships. If you already call deepseek-v4-pro in production, your code keeps working with zero changes — the model string still resolves — but the output style and per-token cost behind it are now Flash’s, not the older standalone Pro model’s. Practically, this means:

Your deepseek-v4-pro calls keep resolving without code changes — the model string still works, but it’s Flash answering the request, not the old standalone Pro model
Per-token cost on deepseek-v4-pro traffic dropped automatically to Flash’s rate ($0.15/$0.60 per M off-peak) from the legacy Pro rate ($0.66/$1.98 per M off-peak) — no action needed to capture the savings
Output quality or style on hard reasoning tasks may have shifted since September 14, since Flash and the original Pro model are different weights despite the shared architecture family
Any prompt engineering tuned specifically for Pro’s reasoning behavior should be re-tested against current output, since that traffic is now running on Flash whether or not you changed your code

If you want to confirm what’s actually answering your deepseek-v4-pro calls rather than take the announcement at face value, a small wrapper that logs the model field from every response makes it easy to check:

import os
import logging
from openai import OpenAI

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

def call_deepseek(prompt, model="deepseek-v4-pro"):
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500,
    )
    logging.info(f"Requested={model} | Returned model field={resp.model}")
    return resp.choices[0].message.content

call_deepseek("Summarize the V4-Pro routing change in one sentence.")

Log the returned model field alongside your own quality and latency metrics, and use that data to decide whether to leave your code calling deepseek-v4-pro (which keeps working today and will presumably change behavior again once V4.1 Pro ships) or repoint it at deepseek-flash directly for clarity, since both currently return the same model.

Step 7: Stream responses instead of waiting for the full completion

DeepSeek’s API is built on the OpenAI Responses/Chat Completions format, which supports server-sent event streaming the same way OpenAI’s own API does. For chat UIs or long-form generations, streaming avoids making a user stare at a blank screen while a 2,000-token response finishes generating server-side.

stream = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "Write a 200-word explainer on MoE routing."}],
    stream=True,
)

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

In Node.js, the pattern is nearly identical — set stream: true and iterate over the async generator the SDK returns:

const stream = await client.chat.completions.create({
  model: "deepseek-flash",
  messages: [{ role: "user", content: "Write a 200-word explainer on MoE routing." }],
  stream: true,
});

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) process.stdout.write(delta);
}

Step 8: Force structured JSON output

For extraction tasks — pulling structured data out of unstructured text — set response_format to JSON mode. This follows the same schema OpenAI’s Responses API uses, since DeepSeek’s docs describe native support for that format:

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Extract structured data as JSON. Return only valid JSON."},
        {"role": "user", "content": "Parse: 'DeepSeek V4.1 Flash launched Sept 10, 2026, priced at $0.15/M input off-peak.'"},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)

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

Always include the word “JSON” in your system or user prompt when using this mode — most OpenAI-compatible APIs, DeepSeek included, require it as a signal alongside the response_format parameter or the request will fail validation.

Step 9: Add tool calling for agent workflows

DeepSeek’s Responses API implementation supports tool/function calling using the same schema as OpenAI’s tools parameter, which matters if you’re building an agent that needs to call external functions — a database lookup, a search API, a calculator.

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_token_price",
            "description": "Get the current price per million tokens for a DeepSeek model",
            "parameters": {
                "type": "object",
                "properties": {
                    "model_name": {"type": "string", "enum": ["deepseek-flash", "deepseek-v4-pro"]},
                },
                "required": ["model_name"],
            },
        },
    }
]

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[{"role": "user", "content": "How much does deepseek-flash cost per million output tokens?"}],
    tools=tools,
    tool_choice="auto",
)

tool_calls = response.choices[0].message.tool_calls
if tool_calls:
    print(tool_calls[0].function.name, tool_calls[0].function.arguments)

The model returns a tool_calls array instead of plain text when it decides a function should run. Your code executes the function, appends the result as a tool role message, and sends the conversation back for a final natural-language answer — the standard multi-turn tool-calling loop used across every OpenAI-compatible provider.

Step 10: Set request timeouts and retries

DeepSeek does not publish hard numeric rate limits in its documentation, but peak-hour traffic (which is exactly when peak pricing applies) means slower responses and higher chances of transient errors. Build retry logic with exponential backoff rather than hammering the endpoint on failure:

import time
from openai import OpenAI, APIError, APITimeoutError

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
    timeout=30.0,
    max_retries=0,  # handle retries manually for visibility
)

def call_with_retry(prompt, model="deepseek-flash", max_attempts=4):
    for attempt in range(max_attempts):
        try:
            return client.chat.completions.create(
                model=model,
                messages=[{"role": "user", "content": prompt}],
            )
        except (APIError, APITimeoutError) as e:
            wait = 2 ** attempt
            print(f"Attempt {attempt + 1} failed: {e}. Retrying in {wait}s")
            time.sleep(wait)
    raise RuntimeError("All retry attempts exhausted")

A 30-second timeout is a reasonable default for chat completions; bump it to 60-90 seconds for long-context requests approaching the 1M-token ceiling, since prompt processing time scales with input length.

Step 11: Monitor token usage and cost per request

Every response includes a usage object with prompt_tokens, completion_tokens, and total_tokens. Log this on every call so you can reconcile against your DeepSeek dashboard bill and catch runaway loops (a common bug in agent code where a tool call cycle never terminates) before they burn through your prepaid balance.

def log_cost(usage, model="deepseek-flash", peak=False):
    # deepseek-v4-pro is routed to and billed as Flash since Sept 14, 2026, until V4.1 Pro ships
    rates = {
        "deepseek-flash": {"in": 0.3 if peak else 0.15, "out": 1.2 if peak else 0.6},
        "deepseek-v4-pro": {"in": 0.3 if peak else 0.15, "out": 1.2 if peak else 0.6},
    }
    r = rates[model]
    cost = (usage.prompt_tokens / 1_000_000 * r["in"]) + (usage.completion_tokens / 1_000_000 * r["out"])
    print(f"{model} | in={usage.prompt_tokens} out={usage.completion_tokens} | est. cost=${cost:.6f}")

This is an estimate, not a billing-accurate figure — it ignores cache-hit discounts on repeated prompt prefixes. For exact billing, always defer to the usage dashboard in the DeepSeek console.

Step 12: Build the complete working project

Put the pieces together into a small command-line tool that routes short prompts to Flash and long or complex ones to Pro, streams the output, and logs cost. Save this as deepseek_cli.py:

import os
import sys
from openai import OpenAI

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

RATES = {
    "deepseek-flash": {"in": 0.15, "out": 0.6},
    "deepseek-v4-pro": {"in": 0.15, "out": 0.6},  # billed as Flash since the Sept 14, 2026 routing change
}

def pick_model(prompt: str) -> str:
    # Route longer or reasoning-flagged prompts to Pro, everything else to Flash
    reasoning_keywords = ["prove", "step by step", "reason", "debug", "plan"]
    if len(prompt) > 800 or any(k in prompt.lower() for k in reasoning_keywords):
        return "deepseek-v4-pro"
    return "deepseek-flash"

def run(prompt: str):
    model = pick_model(prompt)
    print(f"[routing to {model}]\n")

    stream = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": "You are a precise, concise technical assistant."},
            {"role": "user", "content": prompt},
        ],
        stream=True,
        max_tokens=800,
        temperature=0.3,
    )

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

    # Rough cost estimate (streaming responses don't return usage by default)
    est_tokens = len(full_text.split()) * 1.3
    rate = RATES[model]["out"]
    print(f"\n\n[approx {int(est_tokens)} output tokens, ~${est_tokens/1_000_000*rate:.6f} at off-peak rate]")

if __name__ == "__main__":
    prompt = " ".join(sys.argv[1:]) or "Explain what changed with DeepSeek V4.1 Flash."
    run(prompt)

Run it from the terminal:

python deepseek_cli.py "Debug this recursive function step by step: def f(n): return f(n-1)"

Example output

[routing to deepseek-v4-pro]

This function has no base case, so it recurses infinitely until Python hits its
default recursion limit (typically 1000 frames) and raises a RecursionError...
[approx 214 output tokens, ~$0.000128 at off-peak rate]

That gives you a working, cost-aware routing layer in under 60 lines — extend the pick_model heuristic, swap in the tool-calling code from Step 9, or wrap it in a Flask/FastAPI endpoint to turn it into a real backend service.

Common pitfalls when integrating the DeepSeek API

Assuming legacy aliases stay forever. deepseek-chat and deepseek-reasoner still resolve today, but DeepSeek’s own guidance says to migrate to the explicit deepseek-flash / deepseek-v4-pro IDs, since legacy aliases are being retired.
Ignoring peak/off-peak pricing. The same prompt can cost 2x more depending on when it runs. Batch non-urgent jobs (embeddings, summarization backlogs) into off-peak windows if your workload tolerates delay.
Assuming deepseek-v4-pro still runs as the standalone Pro model. DeepSeek announced the routing change on September 10, and it took effect on schedule at 04:00 UTC on September 14, 2026. If your code hardcodes deepseek-v4-pro, it keeps resolving, but requests are now served by V4.1 Flash and billed at Flash rates until V4.1 Pro ships — re-test output quality if your prompts were tuned for Pro’s reasoning behavior.
Treating cache-hit and cache-miss pricing as the same. Repeated system prompts bill at a lower cache-hit input rate. Cost estimates that ignore this will overstate your bill, sometimes significantly, for agent workloads with a fixed system prompt.

DeepSeek V4.1 Flash vs GPT-6 Astra vs Claude Fable 5.1 vs Gemini 3.8 Flash

Picking a model for a new integration usually comes down to three variables: price per token, context window, and how the provider handles the OpenAI-compatible interface (or doesn’t). Here’s where DeepSeek’s current lineup sits against the rest of September 2026’s frontier field on the numbers that are publicly documented:

Model	Provider	Input $/M tokens	Output $/M tokens	Context window	OpenAI-compatible
deepseek-flash	DeepSeek	$0.15–$0.30	$0.60–$1.20	1M tokens	Yes
deepseek-v4-pro (billed as Flash since Sept 14)	DeepSeek	$0.15–$0.30	$0.60–$1.20	1M tokens	Yes
Gemini 3.8 Flash	Google DeepMind	$0.75	$3.75	1M tokens	Via adapter
GPT-6 Astra	OpenAI	$10.00	$50.00	Large (272K+ surcharge tier)	Native
Claude Fable 5.1	Anthropic	$10.00	$50.00	Large	Via adapter

On raw price per token, DeepSeek’s entire V4 lineup undercuts GPT-6 Astra and Claude Fable 5.1 by a wide margin, and Flash even beats Gemini 3.8 Flash on both input and output pricing. The tradeoff shows up on benchmark scores: third-party evaluations put DeepSeek-V4-Pro’s SWE-bench Verified score around 80.6%, competitive with top-tier coding models but not uniformly ahead of GPT-6 Astra or Claude Fable 5.1 on every reasoning benchmark. For teams running high-volume, cost-sensitive workloads — chat support, summarization, bulk document processing — DeepSeek’s pricing makes it a serious default. For workloads where marginal reasoning quality on the hardest problems is worth 10-20x the token cost, the premium-tier models still have an edge on some benchmarks.

Advanced tip: run cost simulations before committing to a model

Before locking a production workload into any single model string, run a batch cost simulation against your actual prompt distribution rather than trusting headline per-token prices. A workload dominated by long system prompts benefits disproportionately from cache-hit pricing; a workload with short, unique prompts every time does not. The script below estimates monthly cost for both DeepSeek models against a sample of your real prompts:

import tiktoken  # approximate tokenizer, DeepSeek uses its own but this is close enough for estimates

enc = tiktoken.get_encoding("cl100k_base")

def estimate_monthly_cost(sample_prompts, requests_per_day, avg_output_tokens=300, model="deepseek-flash", peak_ratio=0.4):
    rates = {
        "deepseek-flash": {"in_off": 0.15, "in_peak": 0.3, "out_off": 0.6, "out_peak": 1.2},
        # deepseek-v4-pro routes to and bills as Flash since the Sept 14, 2026 change, until V4.1 Pro ships
        "deepseek-v4-pro": {"in_off": 0.15, "in_peak": 0.3, "out_off": 0.6, "out_peak": 1.2},
    }
    r = rates[model]
    avg_input_tokens = sum(len(enc.encode(p)) for p in sample_prompts) / len(sample_prompts)

    daily_requests = requests_per_day
    monthly_requests = daily_requests * 30
    peak_requests = monthly_requests * peak_ratio
    offpeak_requests = monthly_requests - peak_requests

    cost = (
        (peak_requests * avg_input_tokens / 1_000_000 * r["in_peak"]) +
        (offpeak_requests * avg_input_tokens / 1_000_000 * r["in_off"]) +
        (peak_requests * avg_output_tokens / 1_000_000 * r["out_peak"]) +
        (offpeak_requests * avg_output_tokens / 1_000_000 * r["out_off"])
    )
    return round(cost, 2)

sample = ["Summarize this support ticket in 2 sentences.", "What is the refund policy for order #4521?"]
print("Est. monthly cost (Flash):", estimate_monthly_cost(sample, requests_per_day=5000, model="deepseek-flash"))
print("Est. monthly cost (Pro):", estimate_monthly_cost(sample, requests_per_day=5000, model="deepseek-v4-pro"))

Running this against your actual prompt logs before a migration catches cost surprises that a simple “$X per million tokens” headline number hides — especially the peak/off-peak split, which most teams forget to model until the first invoice arrives.

Securing your DeepSeek API key in production

An exposed DeepSeek key behaves like any leaked API credential: it gets scraped by bots scanning public GitHub repos and CI logs within hours, and someone else’s traffic starts draining your prepaid balance. Treat the key with the same discipline as a database password, not as a config convenience.

Never hardcode the key in source files, even temporarily during testing — a single forgotten commit is enough to leak it permanently in git history
Use a secrets manager (AWS Secrets Manager, HashiCorp Vault, Doppler, or even a gitignored .env file for local dev) rather than plaintext environment files checked into version control
Scope separate keys per environment — one for local development, one for staging, one for production — so a leaked dev key doesn’t compromise your production billing
Set a spending alert or hard cap in the DeepSeek console if the option is available on your account tier, so a runaway loop or leaked key triggers a notification before it becomes a five-figure bill
Rotate keys on a schedule (quarterly is a reasonable default) and immediately after any team member with key access leaves the project
If you’re proxying DeepSeek calls through your own backend for a client-facing app, never ship the DeepSeek key inside client-side JavaScript or a mobile app bundle — route all calls server-side

The last point trips up more teams than the others combined. It’s tempting to call DeepSeek directly from a browser-based prototype to skip building a backend proxy, but any key embedded in client-side code is visible to anyone who opens their browser’s network tab. Build the thin proxy layer from day one, even for a demo — it’s a 20-line Express or FastAPI route, and retrofitting it after a key leak is far more painful than writing it upfront.

# Minimal FastAPI proxy — client calls this, never DeepSeek directly
from fastapi import FastAPI
from pydantic import BaseModel
from openai import OpenAI
import os

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

class ChatRequest(BaseModel):
    prompt: str

@app.post("/chat")
def chat(req: ChatRequest):
    resp = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{"role": "user", "content": req.prompt}],
        max_tokens=500,
    )
    return {"reply": resp.choices[0].message.content}

When to self-host DeepSeek’s open weights instead of using the API

DeepSeek publishes open-weight releases for several of its model families on Hugging Face, and that changes the calculus for teams with data residency requirements, extremely high sustained request volume, or strict latency needs that a shared multi-tenant API can’t guarantee. The hosted API covered in this tutorial is the right starting point for nearly every team — it’s faster to integrate and has no infrastructure to maintain — but it’s worth knowing when self-hosting makes more sense.

Factor	Hosted API (this tutorial)	Self-hosted open weights
Setup time	Minutes — API key and SDK config	Hours to days — GPU provisioning, serving stack (vLLM, SGLang), weight downloads
Infrastructure cost	Pay per token, no idle cost	GPU rental or ownership cost runs whether or not you’re serving requests
Data residency	Requests processed on DeepSeek’s infrastructure	Full control — data never leaves your own environment
Latest model access	Automatic — DeepSeek updates the hosted weights behind the model string	Manual — you pull and redeploy new open-weight releases yourself
Best fit	Prototypes, most production apps, variable or unpredictable traffic	Regulated industries, extremely high fixed volume, on-premise requirements

If self-hosting is the right call for your constraints, the open-weight releases DeepSeek publishes on Hugging Face are compatible with standard serving frameworks like vLLM and SGLang, and the request format you’d send to a self-hosted endpoint is close enough to the hosted API’s shape that migrating between the two later isn’t a full rewrite — another benefit of building on the OpenAI-compatible schema from the start.

Advanced tip: use the Anthropic-compatible endpoint for multi-provider routing

If your codebase already standardizes on the Claude Messages API shape — common in apps that support swapping between Claude and other providers — DeepSeek’s documented Anthropic-compatible base URL (https://api.deepseek.com/anthropic) lets you add DeepSeek as a fallback or cost-optimization tier without maintaining two separate request-formatting code paths. Route based on a simple cost/complexity heuristic: send routine requests to DeepSeek through the Anthropic-compatible path, and escalate to native Claude only when a confidence check or user flag calls for it.

Troubleshooting common DeepSeek API errors

Symptom	Likely cause	Fix
401 Unauthorized on a key you just created	Account has zero prepaid balance	Add funds in the DeepSeek console billing tab, then retry
Model not found error on a familiar model string	Legacy alias retired or typo in model ID	Use the current documented IDs: deepseek-flash (or the deepseek-v4-flash alias), deepseek-v4-pro
Conflicting information about deepseek-v4-pro pricing	Older articles and cached pages cite the legacy standalone Pro rate, which stopped applying once the Sept 14, 2026 routing change took effect	deepseek-v4-pro still resolves with no code changes, but check the model field in your responses — it bills at Flash’s rate until V4.1 Pro ships
Request hangs or times out on long documents	Timeout set too low for near-1M-token context requests	Raise client timeout to 60-90s for long-context calls
response_format json_object request fails validation	Prompt doesn’t contain the literal word “JSON”	Add “Return valid JSON” or similar phrasing to the system or user message
Streaming response missing usage/token counts	Standard streaming mode omits usage object per chunk	Estimate tokens client-side, or make a non-streaming call when exact usage is required
Unexpectedly high monthly bill	Requests landing mostly in peak pricing windows	Shift batch/non-urgent jobs to off-peak hours; log the peak/off-peak split per request
Tool call never returns after function execution	Tool result message not appended back into the conversation with the correct role	Append the function’s output as a message with role “tool” and the matching tool_call_id before re-sending
Rate-limit-style errors during high traffic	No official hard limits published, but concurrent request caps exist per account tier	Add exponential backoff retry logic; contact DeepSeek support for higher-tier limits on production accounts

Migrating existing V3 integrations to V4

Teams still calling deepseek-chat or a V3-era model string don’t need a rewrite — the request and response schema hasn’t changed, only the model identifiers and, in some cases, the context ceiling. The practical migration checklist:

Swap the model parameter from deepseek-chat to deepseek-flash (or deepseek-v4-pro for reasoning-heavy calls)
Re-run your existing prompt test suite — V4’s MoE routing can produce subtly different output style than V3’s dense architecture, even on identical prompts
Update cost dashboards to reflect the current peak/off-peak pricing structure instead of flat per-token rates
If you’re still calling deepseek-v4-pro directly, add the comparison logging from Step 6 to confirm what’s answering — the Sept 14, 2026 routing change already moved that traffic to Flash automatically, so there’s nothing left to migrate manually
Test the 1M-token context window on your longest real documents — V3-era limits were smaller, so code that chunked documents defensively may now be able to send them whole

None of this requires touching your HTTP client, retry logic, or SDK version — the OpenAI-compatible surface is exactly what makes this a config change instead of a rewrite.

Frequently asked questions

Is the DeepSeek API free to use?

No. DeepSeek’s API requires a prepaid account balance and bills per token. Since the September 14, 2026 routing change, both deepseek-flash and deepseek-v4-pro bill at the same rate: from $0.15 per million input tokens off-peak (as low as $0.003 on cache-hit tokens) and $0.60 per million output tokens off-peak, roughly double at peak hours. There is no permanent free tier for production API access, though new accounts sometimes receive a small trial credit.

What is the difference between deepseek-flash and deepseek-v4-pro?

Both are Mixture-of-Experts models with a 1 million token context window; Pro was built for harder reasoning and coding tasks while Flash is tuned for lower cost and latency on high-volume, simpler workloads like chat and summarization. Since the September 14, 2026 routing change, though, deepseek-v4-pro requests are actually served by V4.1 Flash and billed at Flash’s rate — the legacy Pro pricing (roughly 4x higher on input, 3x higher on output) doesn’t apply again until DeepSeek ships a dedicated V4.1 Pro model.

Does DeepSeek’s API work with the OpenAI Python or Node SDK?

Yes. DeepSeek’s API is OpenAI-compatible, so you install the standard openai package for Python or Node.js and override the base_url/baseURL to https://api.deepseek.com along with your DeepSeek API key. No separate DeepSeek-branded SDK is required.

What happens to deepseek-v4-pro requests after September 14, 2026?

They route to V4.1 Flash. DeepSeek’s September 10 changelog said that starting September 14, 2026, requests to the deepseek-v4-pro model string would route to V4.1 Flash and bill at Flash pricing, and that took effect on schedule: since 04:00 UTC on September 14, 2026, every deepseek-v4-pro request is served by V4.1 Flash and billed at Flash’s rate. No code changes are required for existing integrations — the model string still resolves — and this stays in place until DeepSeek ships a dedicated V4.1 Pro model.

Does DeepSeek’s API support streaming and tool calling?

Yes to both. Streaming works via the standard stream: true parameter and server-sent events, matching the OpenAI Responses API pattern. Tool/function calling uses the same tools and tool_choice parameters as OpenAI’s schema, so existing agent code built around OpenAI’s tool-calling format needs minimal changes to work against DeepSeek.

How big is DeepSeek-V4-Pro compared to other frontier models?

Third-party model overviews put DeepSeek-V4-Pro at roughly 1.6 trillion total parameters with about 49 billion active per token, using a Mixture-of-Experts architecture. DeepSeek’s own Hugging Face model card puts V4.1 Flash at 552B backbone parameters, confirmed as a natively multimodal MoE model. Both models share the same 1 million token context window.

Does DeepSeek V4.1 Flash support image input?

Yes. DeepSeek’s Hugging Face model card for V4.1 Flash confirms native multimodal support, so deepseek-flash accepts image and text in the same request without switching to a separate vision-specific model string. The legacy deepseek-v4-flash-vision-exp alias routed to those same weights only temporarily — DeepSeek retired it, along with the deepseek-v4-flash alias, on September 14, 2026, the same day V4-Pro traffic started routing to V4.1 Flash.

Can I use DeepSeek’s API as a drop-in replacement for Claude?

DeepSeek documents an Anthropic-compatible base URL at https://api.deepseek.com/anthropic that accepts requests shaped like Claude’s Messages API, which allows apps built around that schema to route to DeepSeek with minimal request-formatting changes. This is separate from the OpenAI-compatible endpoint and is worth testing directly against your specific message payloads before relying on it in production.

What is the maximum context window for DeepSeek V4 models?

Both deepseek-flash and deepseek-v4-pro support a 1 million token context window, according to DeepSeek’s current model documentation. This applies to combined input and prior conversation history within a single request, not a per-message limit. Flash caps output at 384K tokens per response — set max_tokens with that ceiling in mind for long structured-output requests.

Sofia Lindström

Editor-in-Chief

Sofia Lindström is the Editor-in-Chief at Tech Insider, where she leads editorial strategy and oversees coverage across AI, cybersecurity, and enterprise technology. With over a decade in Swedish tech journalism, she previously served as technology editor at Dagens Industri and covered the Nordic startup ecosystem for Breakit. Sofia holds an MSc in Media Technology from KTH Royal Institute of Technology and is a frequent speaker at Web Summit and Slush. She is passionate about making complex technology accessible to business leaders.

View all articles

Quick answer: DeepSeek V4.1 Flash pricing and model ID

What changed with DeepSeek V4.1 Flash on September 10, 2026

Prerequisites and versions

Step 1: Create a DeepSeek account and generate an API key

Step 2: Understand the base URL and authentication format

Step 3: Install the SDK and make your first call in Python

Example output

Step 4: Make your first call in Node.js

Step 5: Choose between deepseek-flash and deepseek-v4-pro

Step 6: Understand the V4-Pro routing change (and what to check in your own logs)

Step 7: Stream responses instead of waiting for the full completion

Step 8: Force structured JSON output

Step 9: Add tool calling for agent workflows

Step 10: Set request timeouts and retries

Step 11: Monitor token usage and cost per request

Step 12: Build the complete working project

Example output

Common pitfalls when integrating the DeepSeek API

DeepSeek V4.1 Flash vs GPT-6 Astra vs Claude Fable 5.1 vs Gemini 3.8 Flash

Advanced tip: run cost simulations before committing to a model

Securing your DeepSeek API key in production

When to self-host DeepSeek’s open weights instead of using the API

Advanced tip: use the Anthropic-compatible endpoint for multi-provider routing

Troubleshooting common DeepSeek API errors

Migrating existing V3 integrations to V4

Frequently asked questions

Is the DeepSeek API free to use?

What is the difference between deepseek-flash and deepseek-v4-pro?

Does DeepSeek’s API work with the OpenAI Python or Node SDK?

What happens to deepseek-v4-pro requests after September 14, 2026?

Does DeepSeek’s API support streaming and tool calling?

How big is DeepSeek-V4-Pro compared to other frontier models?

Does DeepSeek V4.1 Flash support image input?

Can I use DeepSeek’s API as a drop-in replacement for Claude?

What is the maximum context window for DeepSeek V4 models?

Sofia Lindström

Company

Explore

Categories