DeepSeek-V4.1-Flash-1017 API Pricing Guide (2026): Peak Hours, Cache Rates, and Real Costs

On October 17, 2026, DeepSeek released DeepSeek-V4.1-Flash-1017 and pointed its deepseek-flash API name at it. Your integration doesn't have to change. The price sheet is worth a slow read, though, because it has two quirks most cost calculators miss: rates double during weekday peak hours, and Search and Fetch turn into paid features at 16:00 UTC on October 31, 2026.

DeepSeek calls the release a Pareto improvement over the previous Flash: stronger benchmark results, faster task completion, and shorter outputs. Shorter outputs matter more than they sound, since output tokens are the expensive half of every bill. I can't independently verify DeepSeek's benchmark claims, so treat those as vendor numbers. The pricing page is checkable, and everything below comes from it.

What Actually Changed on October 17

The model name stays deepseek-flash. Behind it, the weights are now DeepSeek-V4.1-Flash-1017. The older names deepseek-v4-flash and deepseek-v4-flash-vision-exp still work, but those models are retired. Requests to them are served by the new model and billed at the Flash price.

A few other facts from the docs. The API speaks both OpenAI format (https://api.deepseek.com) and Anthropic format (https://api.deepseek.com/anthropic). Flash accepts images; deepseek-v4-pro doesn't. Thinking mode is on by default. The weights are published on Hugging Face and ModelScope as DeepSeek-V4.1-Flash-1017. If you're still calling deepseek-chat, start with our DeepSeek V4 migration guide first.

DeepSeek API Pricing Table (USD per 1M Tokens)

DeepSeek publishes two prices for everything. Off-peak is exactly half of peak. All figures below are in US dollars per 1 million tokens, taken from DeepSeek's Models & Pricing page on October 20, 2026.

Cache hits are the number to watch. At $0.003 per 1M tokens, a cached input token on Flash costs 2% of an uncached one. An agent loop that re-sends a long, stable prefix and gets 90% cache hits pays a blended input rate of about $0.018 per 1M tokens off-peak and $0.035 at peak. Cache hits depend on repeated prefixes, so keep your system prompt and tool definitions byte-identical between calls.

Peak Hours Are the Hidden Variable

Peak is 01:00 to 04:00 UTC and 06:00 to 10:00 UTC, Monday to Friday, minus Chinese public holidays. That's seven peak hours a day out of 24. If you're in Europe or the Americas, your working day mostly misses it. If you're in Asia, you may be sitting inside it.

The practical move: split your traffic into interactive and deferrable. A user waiting on a response pays whatever the clock says. A nightly eval run, a bulk summarization job, or a backfill doesn't have to. Here's a small gate you can drop into a worker:

import os
from datetime import datetime, timezone
from openai import OpenAI

PEAK_WINDOWS_UTC = [(1, 4), (6, 10)]  # hours, Monday-Friday

def is_peak(now=None):
    now = now or datetime.now(timezone.utc)
    if now.weekday() >= 5:  # Saturday and Sunday are always off-peak
        return False
    return any(start <= now.hour < end for start, end in PEAK_WINDOWS_UTC)

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

def run(prompt, deferrable=False):
    if deferrable and is_peak():
        return None  # leave it queued; the next off-peak window picks it up
    resp = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{"role": "user", "content": prompt}],
        reasoning_effort="high",
        extra_body={"thinking": {"type": "enabled"}},
    )
    return resp.choices[0].message.content

This treats Chinese public holidays as peak, so you'll occasionally defer a job that would have been half price. Small loss.

The same call in curl and Node.js, straight from DeepSeek's quickstart:

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "Hello!"}],
    "thinking": {"type": "enabled"},
    "reasoning_effort": "high",
    "stream": false
  }'

import OpenAI from "openai";

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

const completion = await openai.chat.completions.create({
  model: "deepseek-flash",
  messages: [{ role: "user", content: "Hello!" }],
  thinking: { type: "enabled" },
  reasoning_effort: "high",
});
console.log(completion.choices[0].message.content);

Flash vs GPT-6.1 Sol vs Gemini 4 Argon

The fair question is what Flash costs next to the frontier models shipping this month. OpenAI released GPT-6.1 Sol on September 29, 2026. Google launched Gemini 4 Argon on October 13, 2026 at an introductory price that ends on November 30. The last column prices one identical workload: 100M input tokens (all cache misses) and 20M output tokens, at list price.

On list price, Flash off-peak is roughly 15 times cheaper than Sol or Argon for this workload. That gap is big enough to change architecture decisions. It doesn't make Flash the right default for everything. A cheap model that needs three attempts costs more than an expensive one that nails it the first time, and only your own evals can tell you which camp a given task falls into. Run them before you move traffic.

Search and Fetch: The Line Item That Sneaks Up on You

DeepSeek opened its Search and Fetch APIs to everyone with this release. Each costs $0.75 per 1,000 successful requests. If you use DeepSeek through DeepSeek Harness, Claude Code, or Codex, server-side tool calls already hit those endpoints. They're free right now. Billing starts at 16:00 UTC on October 31, 2026.

Do the math on an agent task. Say it uses 50,000 cache-miss input tokens and 5,000 output tokens off-peak, which costs $0.0105 in tokens. Add 10 searches at $0.00075 each and you've spent another $0.0075. Search is now about 42% of the task's total cost. Cheap tokens make per-call fees look big. Put a cap on tool calls per task before the free window closes, not after.

A Short Checklist Before October 31

1. Re-run your evals. The alias moved under you on October 17. Behavior changed even though the name didn't.
2. Retire legacy names. Replace deepseek-v4-flash with deepseek-flash so your logs and billing match reality.
3. Tag deferrable jobs. Anything a human isn't waiting on should run off-peak.
4. Set a Search/Fetch budget before October 31.
5. Estimate before you switch. Plug your real token volumes into the API cost calculator and measure prompts with the token counter.

Most production stacks end up mixed: a cheap model for the bulk of the traffic, a stronger one for the hard 10%. For the Claude and GPT side of that setup, KissAPI gives you one OpenAI-compatible endpoint and one key, so you aren't managing a separate dashboard per provider.

Frequently Asked Questions

How much does the DeepSeek-V4.1-Flash-1017 API cost?

Through the deepseek-flash model name, DeepSeek charges $0.15 per 1M cache-miss input tokens, $0.003 per 1M cache-hit input tokens, and $0.60 per 1M output tokens during off-peak hours. During peak hours the rates double to $0.30, $0.006, and $1.20 per 1M tokens. The context window is 1M tokens and the maximum output is 384K tokens.

What are DeepSeek API peak hours?

DeepSeek peak hours are 01:00 to 04:00 UTC and 06:00 to 10:00 UTC, Monday through Friday, excluding Chinese public holidays. All other hours, including weekends and Chinese public holidays, are off-peak and priced at half the peak rate.

When does DeepSeek start charging for Search and Fetch?

DeepSeek Search and Fetch cost $0.75 per 1,000 successful requests each. Server-side Search and Fetch calls made through DeepSeek Harness, Claude Code, and Codex are free until billing starts at 16:00 UTC on October 31, 2026, which is 00:00 Beijing time on November 1, 2026.