DeepSeek V4 Model Replacement: Avoid Higher Bills

As of July 31, 2026, DeepSeek’s official pricing lists Flash output at $0.28 per 1M tokens and Pro output at $0.87 per 1M tokens, while thinking is enabled by default for both models. That gives you the first migration rule: replace ordinary deepseek-chat traffic with deepseek-v4-flash and explicitly disable thinking; do not change only the model ID. (DeepSeek pricing)

This week, change ordinary chat and batch workloads first, then test Flash-thinking and Pro-thinking on the same evaluation set before moving reasoning-heavy traffic.

The official retirement point was July 24, 2026 at 15:59 UTC. During the compatibility period, deepseek-chat routed to Flash without thinking and deepseek-reasoner routed to Flash with thinking. After retirement, those legacy names are no longer a safe routing contract. (DeepSeek V4 release notice)

Last updated July 31, 2026. Model availability, default thinking behavior, request fields, and pricing were checked against DeepSeek’s official release, model list, pricing, thinking-mode, and API documentation.

This guide is for you if you maintain an application that still uses deepseek-chat, operate a shared SDK or model gateway, or need to balance response quality, latency, and API spending across chat, batch, Agent, and reasoning workloads.

Start With The Migration Map

Use the old workload, not the old model name, as the starting point. DeepSeek confirms that deepseek-v4-flash and deepseek-v4-pro both support thinking and non-thinking modes. The API request accepts enabled or disabled, and the default is enabled. (DeepSeek Thinking Mode guide)

The important distinction is between official compatibility behavior and your post-retirement engineering choice. The compatibility mapping does not prove that every former deepseek-reasoner task should move to Pro. It only tells you how the old name was routed before retirement. Your new route should come from quality tests, request counts, usage fields, and rollback requirements.

A safe first request for ordinary traffic looks like this:

{
  "model": "deepseek-v4-flash",
  "thinking": {
    "type": "disabled"
  },
  "messages": [
    {
      "role": "user",
      "content": "Summarize this support ticket in three bullet points."
    }
  ]
}

When you use an OpenAI-compatible SDK, DeepSeek’s documentation places the thinking object inside extra_body. Do not assume that a top-level parameter, an old SDK wrapper, or a gateway alias will reach the API unchanged.

Ordinary Chat And Batch Workloads

For customer chat, classification, summarization, extraction, rewriting, and bulk content generation, start with Flash in non-thinking mode. These workloads usually have a clear output shape and a relatively low failure cost. Enabling reasoning by default can change output behavior, token consumption, and the shape of the response even when your business prompt remains unchanged.

The most common migration mistake is:

{
  "model": "deepseek-v4-flash"
}

That request is incomplete for cost-sensitive traffic because the documented thinking default is enabled. You should send the mode explicitly:

{
  "model": "deepseek-v4-flash",
  "thinking": {
    "type": "disabled"
  }
}

The price difference between Flash and Pro is visible before you consider any extra reasoning output. The official pricing page currently lists the following rates per 1M tokens. DeepSeek also separates cache hits from cache misses, so a migration review that checks only request count can miss a major cost driver.

These are current official values, not a universal estimate of your invoice. DeepSeek states that prices may change, so check the official pricing page before setting a permanent budget or alert threshold.

For batch teams, compare three separate effects:

• Flash with thinking disabled: the closest starting point for routine deepseek-chat work.
• Flash with thinking enabled: a useful quality-control route, but not a free switch because reasoning tokens are reported separately.
• Prompt-prefix reuse: potentially valuable when many requests share a stable system prompt or document prefix, but only if your logs show cache hits rather than assuming they occurred.

The API response exposes prompt_cache_hit_tokens, prompt_cache_miss_tokens, completion_tokens, total_tokens, and completion_tokens_details.reasoning_tokens. Use those fields to explain a cost change instead of blaming the model name alone. The official Chat Completion API reference documents the response structure and request fields.

Do not upgrade a batch workflow to thinking merely because a few outputs look better. Define an exit condition first:

• The non-thinking result fails a measured accuracy or schema threshold.
• The thinking route fixes a named error category.
• The quality gain remains after testing representative inputs.
• The added completion and reasoning tokens fit the task budget.
• The route has a fallback to Flash non-thinking.

If the task passes these conditions without reasoning, keep the cheaper route.

Agent Routing And Tool Calls

AI Agent teams need a different boundary. A tool-using request is not always one model call. In thinking mode, DeepSeek documents a loop where the model can reason, call a tool, receive the tool result, and issue another request before returning the final answer. The guide also requires you to pass reasoning_content back when tool calls occur.

That creates three hidden costs that a single-request dashboard can miss:

1. One user task may contain several API sub-requests.
2. Tool results and repeated context can increase prompt tokens.
3. Incorrect handling of reasoning_content can produce failed calls or a 400 response, forcing retries.

For a simple Agent that selects one tool and returns a structured result, test Flash with thinking enabled first. DeepSeek describes Flash as having reasoning capabilities close to Pro and performing on par with Pro on simple Agent tasks, but that is a product-level positioning statement, not a guarantee for your tool schema or domain.

Use Pro when the cost of a wrong plan, missed tool call, unsafe action, or repeated retry is materially higher than the additional model spend. Do not route by the string deepseek-reasoner simply because that was the former name.

A useful Agent evaluation record should contain:

• The same user task and tool definitions.
• The final model ID returned by the API.
• The thinking state sent to the API.
• Total sub-request count.
• Tool-call count and failed tool-call count.
• Prompt cache hit and miss tokens.
• Completion and reasoning tokens.
• End-to-end completion time.
• Final task success, not just HTTP success.

The response’s model field tells you which model actually served the request. The usage object provides the token breakdown. In streaming mode, request stream_options with include_usage if you need usage statistics in the final stream chunk.

Migration warning: A gateway can silently overwrite thinking, normalize the model ID, or retry a failed tool call. The configuration file is not evidence. The final outbound payload and the returned response are evidence.

Keep Flash-thinking as the control group when you test Pro-thinking. If you change both model and thinking state at once, you cannot tell whether a quality improvement came from the larger model, the reasoning process, or a prompt-side change.

Reasoning-Heavy Workloads

For code reasoning, complex analysis, research synthesis, and high-risk decisions, treat Pro as a candidate rather than a mandatory destination.

The official documentation confirms the two V4 model IDs and their dual-mode support. It does not state that every former deepseek-reasoner workload must become deepseek-v4-pro. That means your migration decision should be based on a fixed evaluation set, not on a one-to-one alias rule.

Run the evaluation in this order:

1. Flash, thinking disabled: establish the low-cost baseline.
2. Flash, thinking enabled: measure the value of reasoning without changing model family.
3. Pro, thinking enabled: measure whether the larger route adds enough quality.
4. Pro, thinking disabled: test whether model capacity alone solves the failure category.

The fourth test is easy to skip, but it helps separate “better model” from “more reasoning.” You may find that some prompts need Pro but not thinking, while others benefit from Flash-thinking without the higher Pro rate.

Use a decision rule such as this:

Do not use a single impressive example as proof. Include short and long prompts, malformed inputs, adversarial cases, expected tool calls, structured output validation, and known production failures. Record the same evidence fields for every route.

For high-risk work, the rollback target should be explicit. It can be Flash-thinking, Flash non-thinking, a human review queue, or a disabled feature flag. “Switch back to the old model” is no longer a valid rollback instruction because the old model name has retired.

Platform And Gateway Controls

Platform teams should stop allowing ambiguous legacy aliases to circulate through application code. Store a versioned route object with at least these fields:

{
  "task_class": "support_summary",
  "model": "deepseek-v4-flash",
  "thinking": "disabled",
  "fallback_model": "deepseek-v4-flash",
  "fallback_thinking": "disabled",
  "owner": "support-platform",
  "remove_after": "migration-complete"
}

The exact schema is yours to define. The principle is not: every request must leave the gateway with an observable model ID, thinking state, business label, and fallback target.

Check each layer separately:

• Application configuration.
• SDK wrapper.
• Shared HTTP client.
• Proxy or API gateway.
• Retry middleware.
• Batch worker defaults.
• Agent tool loop.
• Billing and usage exporter.

A common permissions and ownership problem appears when the application team changes the model but the gateway team owns extra_body. The application believes thinking is disabled, while the gateway sends no override and the API uses its enabled default. Make the gateway log a redacted final request shape, including model and thinking.type, but never log API keys or sensitive prompt content.

A short-term mapping may be necessary for services that cannot migrate immediately. Make it traceable. Give it an owner, a route label, a removal condition, and an alert. For example, remove the temporary mapping after every dependent service reports a valid V4 model ID for a defined observation window and passes its workload evaluation.

The Migration Sign-Off Checklist

Use this checklist before increasing traffic or removing compatibility code:

• [ ] Replace every deepseek-chat reference in application code, configuration, tests, and dashboards.
• [ ] Replace every deepseek-reasoner reference with a workload-specific route, not an automatic Pro alias.
• [ ] Set model to deepseek-v4-flash for ordinary chat and batch traffic.
• [ ] Set thinking.type to disabled for ordinary chat and routine batch processing.
• [ ] Verify that the SDK places the thinking object in the correct request location.
• [ ] Capture the final outbound model and thinking state from a redacted request log.
• [ ] Confirm the response model field matches the intended route.
• [ ] Record prompt_tokens, cache hit tokens, cache miss tokens, completion tokens, and total tokens.
• [ ] Record reasoning tokens when thinking is enabled.
• [ ] Count every sub-request in an Agent tool loop.
• [ ] Compare Flash-thinking and Pro-thinking on the same fixed task set.
• [ ] Define a quality threshold and a cost limit before expanding traffic.
• [ ] Set a named fallback route for every business task label.
• [ ] Add an alert for unexpected model IDs or unexpected thinking states.
• [ ] Remove temporary aliases only after the owning team signs off.

The bill itself is a lagging signal. If the total rises, separate request volume, input cache status, output tokens, reasoning tokens, retries, and Agent sub-requests. A higher total does not automatically prove that the model price changed, and a stable request count does not prove that the workload stayed equivalent.

The Right Engineering Environment For This Migration

If the migration issue appears only in a macOS or iOS client, Xcode build chain, local SDK wrapper, or Apple-specific proxy configuration, do not keep switching production settings to reproduce it. Isolate the client, gateway, and final request body in a disposable regression environment first.

For a short migration test, compare the available cloud Mac options, delivery method, supported operating system, rental period, and access workflow before choosing resources. The right environment is the one that reproduces the failing client path without forcing you to alter production traffic. You can review VpsGona’s available Mac environment options and confirm operational details through the VpsGona help center.

Do not rent a Mac merely to run ordinary API calls if your existing Linux or Windows test host already reproduces the same HTTP request. A cloud Mac becomes useful when the failure depends on Apple SDK behavior, Xcode tooling, client signing, local networking, or a macOS-only integration path.

If you need to estimate the short-term resource commitment, review the applicable VpsGona pricing page only after confirming that the delivery method and system version match your reproduction plan. Pricing and availability are operational details that should be checked before starting the test, not assumed from an old migration note.

Final Recommendation For Technical Owners

Your sign-off should contain one row per workload: task type, final model ID, thinking state, fallback route, quality result, request count, cache state, token usage, and owner. Expand traffic only when the route is stable, quality meets the acceptance threshold, and a quick rollback has been tested.

For most former deepseek-chat workloads, the correct first move remains deepseek-v4-flash with explicit non-thinking mode. For former reasoning workloads, test Flash-thinking before Pro-thinking, and keep the two variables separate. That gives you a defensible migration rather than a costly alias replacement.

If the problem exists only inside a macOS or iOS client, the current approach of repeatedly changing production model settings has three real weaknesses: it mixes client and API variables, makes rollback evidence harder to trust, and can hide gateway parameter overrides. A short-lived isolated Mac environment from VpsGona can be the cleaner option when you need to reproduce an Apple-specific client path, provided you first verify the available system, delivery method, and rental period against the test plan.