DeepSeek Explained: Why Its Models Are So Cheap, and What You Give Up

Human Verified 0

Share to: , and

A small whale-like sea creature silhouette beside a glowing lightbulb over a calm ocean at dusk, deep teal and warm amber tones. No text, no logos.

DeepSeek Explained: Why Its Models Are So Cheap, and What You Give Up

DeepSeek is a Chinese AI lab’s family of large language models, and it is famous for one thing above all: price. Its current flagship-class model, DeepSeek-V4-Pro, charges $1.32 per million input tokens at peak hours and $3.96 per million output tokens. Its cheaper model, DeepSeek-V4.1-Flash, charges $0.30 per million input tokens and $1.20 per million output tokens at peak — and as little as $0.003 per million input tokens when your prompt hits its cache off-peak. Compare that with OpenAI’s GPT-5 at $1.25 per million input tokens and $10.00 per million output tokens — GPT-5’s last published prices, since OpenAI’s live API pricing page now lists the GPT-6 family instead (see the note in the price-comparison section below) — and the gap is real: Flash is roughly four times cheaper than GPT-5 on input and eight times cheaper on output, at peak prices. On top of that, the DeepSeek chat app is free, with no subscription tier at all. That combination — a genuinely cheap API and a free chat — is why DeepSeek went from an obscure lab to a household name in January 2025, and why it still dominates conversations about AI value in November 2026. All prices in this guide were checked 17 November 2026 against DeepSeek’s own API pricing page, and DeepSeek warns that its prices may change.

But the cheap price is only half the story, and it is the half most explainers stop at. The DeepSeek of November 2026 is not the DeepSeek of January 2025. The models that made it famous — V3 and R1 — are gone from DeepSeek’s own API, retired on 24 July 2026. The lineup today is just two models, Flash and V4-Pro, and reasoning is no longer a separate model you choose: it is a mode you switch on inside one model. The newest model, V4.1-Flash, is cheaper still because its architecture was rebuilt to spend compute only where it matters. And the price comes with trade-offs that are easy to miss until they bite: the free chat slows to a crawl at peak hours, the stronger model cannot see images at all, and DeepSeek’s own privacy policy says your personal data is collected, processed and stored in China. This guide explains, in plain language, what DeepSeek is today, why it can charge so little, what the numbers actually mean for a real bill, and what you give up — so you can decide whether the cheapest frontier-class AI is the right one for you.

Three corrections belong at the top, because most explainers still get them wrong. First, there is no “DeepSeek Plus” or “DeepSeek Pro plan” to buy. V4 Pro is a model, not a subscription, and the chat app has no paid tier. Second, R1 is not DeepSeek’s current reasoning model. Reasoning now lives inside Flash and V4-Pro as a thinking mode, and anyone still writing about “DeepSeek-R1” as the product to use is describing a model DeepSeek retired from its own API in July 2026. Third, DeepSeek is not cheapest on every axis. OpenAI’s tiny GPT-5 nano charges $0.05 per million input tokens — cheaper than Flash’s $0.30 peak cache-miss input price — so the honest claim is narrower and stronger: DeepSeek Flash is far cheaper than flagship models while offering a free chat with no subscription. The rest of this guide is built on that honest framing, with every price, date and model name traced to a source listed at the end.

A small whale-like sea creature silhouette beside a glowing lightbulb over a calm ocean at dusk, deep teal and warm amber tones. No text, no logos.

What DeepSeek Is, in Plain Language

<img src="

A person chatting with a laptop at a kitchen table in warm light, the screen glowing with a simple chat window. No readable text, no logos.

” alt=”A person chatting with a laptop at a kitchen table in warm light, the screen glowing with a simple chat window. No readable text, no logos.”>

DeepSeek is two things at once, and keeping them apart clears up most of the confusion about it. It is an AI lab based in Hangzhou, China — the company behind the models is Hangzhou DeepSeek Artificial Intelligence Co., Ltd., named as the data controller in its privacy policy — and it is also the family of large language models that lab builds. When people say “DeepSeek”, they usually mean one of the models, or the free chat app that runs on them. The lab itself stays deliberately low-profile: its homepage is minimal and Chinese-first, it publishes no company history, headcount or funding figures on its own pages, and this guide does not repeat the founding dates and founder names that circulate in secondary coverage, because none of them was verified on a primary source for this guide. What matters for a user is the product, and the product is straightforward.

Most people meet DeepSeek in one of four ways. The first is the free chat app at chat.deepseek.com, with iOS and Android apps alongside it. You open it, type a question, and get an answer from the current model — free, with no subscription tier, no paywall and no “Pro plan” upsell. The second is the API at api.deepseek.com, where developers pay per token to call the same models from their own apps. The third is through a third-party host: the models are also available on platforms such as AWS SageMaker JumpStart and OpenRouter, and through coding tools such as Claude Code, GitHub Copilot and OpenCode, which can use DeepSeek as a backend. The fourth is self-hosting: the V4 model weights are released under the MIT licence and published on Hugging Face, so anyone with enough hardware can download them and run them on their own machines. Four doors into the same models, with very different prices, privacy properties and trade-offs — and much of this guide is about choosing the right door.

What DeepSeek is not matters just as much. It is not a subscription product. There is no monthly plan that unlocks a better DeepSeek, the way ChatGPT Plus unlocks better ChatGPT. The only paid product is the API, charged per token. It is not a search engine, although since 13 November 2026 its API has offered web search and URL fetching as paid extras. It is not a general app store of AI tools: it does one thing — text models — and the chat app is a thin wrapper around those models rather than a platform of agents and integrations. And it is not, any more, the V3 and R1 lineup that made it famous. Those models were deprecated on DeepSeek’s own API on 24 July 2026, five days after the V4 line reached general availability. Their open weights are still downloadable and still run on third-party hosts, but if you call DeepSeek’s own API today, you get V4 models, not V3 or R1. Any guide, tutorial or benchmark that still treats R1 as DeepSeek’s current model is out of date.

The simplest way to think about DeepSeek is as the budget airline of frontier AI. The seat is the same class of product — a large language model that can write, reason, code and analyse long documents — but the ticket costs a fraction of the flag carriers’, the free tier is genuinely free, and the corners that were cut are visible if you know where to look: queues at busy times, fewer frills, and a data policy that reflects where the company is based. Whether that trade is worth it depends entirely on what you are flying for, and the rest of this guide works through the fare structure, the aircraft, and the fine print, in that order.

The Short Answer: Why DeepSeek Is So Cheap

A balance scale in a bright workshop, one side holding a single coin and the other a stack of paper sheets. No readable text, no logos.

DeepSeek is cheap for four reasons, and none of them is a trick. The first and biggest is architecture. DeepSeek’s models are Mixture-of-Experts designs: instead of using the whole model for every word, the model routes each token to a small subset of specialist sub-networks — “experts” — and only those experts do the work. In V4.1-Flash, the model has 552 billion parameters in total, but only about 8 billion of them are active per token while reading your prompt, and about 16 billion while writing its answer. You are, in effect, paying for a small model to do the work of a very large one. That is the single most important fact in this whole guide: the price gap is mostly an engineering gap, not a subsidy. A model that activates 8 billion parameters per token costs far less to run per token than a dense model that activates all of its parameters for every token, and DeepSeek passes that saving on.

The second reason is the open-weights strategy. DeepSeek releases its model weights under the MIT licence, free for anyone to download, modify and run. That sounds like giving the product away, and in a sense it is — but it is also a distribution strategy. Open weights mean other companies host DeepSeek models, build tools on top of them, and send DeepSeek’s usage through the roof without DeepSeek paying for the marketing. Third-party hosting also creates competition among hosts, which pushes hosting prices down and keeps DeepSeek’s own API honest. And open weights mean the research community improves the ecosystem around the models for free. The openness is real, and it is also good business.

The third reason is pricing design. DeepSeek charges half price off-peak — peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays, and everything else is off-peak — which smooths demand across the day and lets DeepSeek sell spare capacity cheaply instead of building for the peak. It also charges far less for cached input than for fresh input: a prompt that repeats text the model has recently seen costs $0.003 per million tokens on Flash off-peak, against $0.15 for a cache miss. That is a fifty-fold difference, and it rewards the most common real-world pattern — the same system prompt and documents sent again and again — with a near-zero marginal cost. The fourth reason is the simplest: the free chat is a loss leader with no subscription to upsell you to. DeepSeek does not need the chat app to make money; it needs it to make the models famous, and the API is where the money is made.

None of this means the price is free of cost. The same design choices that make DeepSeek cheap also make it busy: a free chat with no subscription and a famously cheap API attracts enormous traffic, and that traffic queues at peak hours. The mixture-of-experts design is efficient, but it is also harder to run well, which is one reason the strongest model has a concurrency limit of just 500 against Flash’s 2,500. And the open-weights strategy means DeepSeek gives up the lock-in that lets other labs charge more. The price is real, the engineering behind it is real, and the trade-offs are real too. The rest of this guide prices each of them.

The Model Lineup in November 2026: Flash and V4-Pro

Two distinct model lanes on a road seen from above, a small fast car in one lane and a large truck in the other. No text, no logos.

DeepSeek’s own API pricing page, read in full on 17 November 2026, lists exactly two models. That is the whole lineup, and it is worth stating plainly because most explainers still list four or five. The two models are deepseek-flash, served by the checkpoint DeepSeek-V4.1-Flash-1017, and deepseek-v4-pro, served by DeepSeek-V4-Pro-0813. Those are the only two valid model names in the API documentation’s Chat Completions reference. If your code, your tutorial or your comparison table names anything else as a current DeepSeek API model, it is out of date.

Flash is the fast, cheap, general-purpose model, and it is the one most people will use most of the time. It is the model behind the free chat app: DeepSeek’s own changelog, as reported in October 2026, says the web and app models were updated to V4.1-Flash-1017 on 17 October 2026. Flash supports vision — it can take image input — and it is the model that received the 13 November 2026 expansion of app features to the API, including web search, file input and URL reading. Its architecture is the newest in the family: a 552-billion-parameter mixture-of-experts backbone (763 billion with the vision encoder), with a design DeepSeek calls a Causal Encoder-Decoder, or CED — 40 layers split into a 20-layer causal encoder and a 20-layer decoder, with 384 routed experts plus one shared expert per layer and six experts firing per token. The practical result of that design, according to DeepSeek’s own technical report as summarised in secondary coverage, is a key-value cache of about 890 bytes per token — roughly a quarter of the previous V4-Flash — which is a large part of why Flash can be served so cheaply at a million-token context length. Those architecture figures are DeepSeek-reported, not independently measured, and this guide labels them as such.

V4-Pro is the stronger, slower, more expensive model — the one you reach for when Flash is not enough. It is also a mixture-of-experts model, and its scale is far larger: AWS, announcing the model’s arrival on SageMaker JumpStart on 11 November 2026, reports 1.6 trillion total parameters with 49 billion active per token. That figure comes from AWS, not from DeepSeek’s own pages, and this guide attributes it accordingly. V4-Pro does not support vision: if your task involves images, Flash is your only first-party option. V4-Pro is available on the chat app and web through what DeepSeek calls “Expert Mode”, according to release notes from 13 August 2026 as reported in secondary coverage. Both models share the same headline specs: a 1-million-token context length, a maximum output of 384,000 tokens, JSON output, tool calls, the Responses API, Anthropic-compatible API access, and a beta Chat Prefix Completion mode. Fill-in-the-middle completion is available in beta in non-thinking mode only, on both models.

Two loose ends from the old lineup deserve a clear statement. First, the legacy API names deepseek-v4-flash and deepseek-v4-flash-vision-exp are still accepted by the API, but the models behind them are retired: requests under those names are served by V4.1-Flash-1017 and billed at the Flash price. Second, there were secondary reports from 14 September 2026 that deepseek-v4-pro API requests were being routed to V4.1-Flash at Flash prices, with V4-Pro being phased out. That report conflicts with the official pricing page read today, which still lists V4-Pro as a separate, separately priced model — so this guide presents the routing as reported, not as confirmed fact, and does not state that V4-Pro is retired. If you are building on V4-Pro, the pricing page is the authority, and it says V4-Pro is alive and priced. Finally, no new model has been announced: secondary sources from October 2026 found no DeepSeek statement about a V5 or a new R-series model, and the only future model DeepSeek has pointed to is V4.1-Pro, with no date attached. This guide does not speculate about either.

From V3 and R1 to V4: What Changed (and What Disappeared)

A timeline wall in a museum with three framed abstract pictures in a row, the middle frame slightly faded. No readable labels, no text, no logos.

DeepSeek became famous in January 2025, when it released R1 — a reasoning model that matched frontier rivals on hard problems at a fraction of their price. The launch was a genuine shock to the AI industry: a relatively unknown Chinese lab had built a model that could reason step by step through maths, science and coding problems, and it was offering it at prices that made the incumbents look expensive. R1’s May 2025 update, R1-0528, kept it competitive. For most of 2025, “DeepSeek” meant two models: V3, the general-purpose chat model, and R1, the separate reasoner you switched to when a problem needed thinking. That two-model shape is the one most people still carry in their heads — and it is the shape that no longer exists.

The change came in stages through 2026. A preview of the V4 line launched on 24 April 2026. V4 reached general availability on 19 July 2026, and five days later, on 24 July 2026, DeepSeek deprecated V3 and R1 on its first-party API. The legacy API names deepseek-chat and deepseek-reasoner were retired the same day. V4-Pro reached general availability on 13 August 2026. V4.1-Flash, the current fast model, replaced V4-Flash in September 2026 — it was released on 10 September 2026 and reached general availability on the API — and the checkpoint was updated to V4.1-Flash-1017 on 17 October 2026. Those dates come from DeepSeek’s changelog as reported by multiple independent secondary sources, corroborated against the pricing page and API documentation read in full for this guide.

What changed, in substance, is the shape of reasoning. R1 was a separate model: you chose it, and it thought. In the V4 line, reasoning is a mode inside one model. Both Flash and V4-Pro have a built-in thinking mode, switched on by default, with a reasoning_effort setting — none, low, high or max — that controls how hard the model thinks. That is a real improvement for most users: you no longer have to decide in advance whether a question needs reasoning, and you no longer lose your conversation context by switching models mid-task. It is also a change that R1 users need to relearn, because the controls are different, the defaults are different, and the old model names no longer work. The thinking-mode section later in this guide covers the new controls in full.

What disappeared is narrower than it sounds, and the distinction matters. Deprecation hit DeepSeek’s own API endpoints, not the weights. The open weights of V3 and R1 remain downloadable under the MIT licence, and they still run on third-party hosts and on local hardware. If you have a workflow built on R1’s weights through a host such as OpenRouter or AWS, it did not vanish on 24 July 2026. What vanished was the ability to call deepseek-chat or deepseek-reasoner on api.deepseek.com and get V3 or R1 back. For most users that distinction is academic — they used the app or the API, and both moved to V4 — but for anyone running the old weights elsewhere, it is the difference between a dead model and a live one. One caution about the history: benchmark claims about R1 versus its rivals come from DeepSeek’s own reports and from the launch period, and this guide treats them as vendor and historical claims, not as current measurements. R1 is history now; the current question is how V4.1-Flash and V4-Pro perform, and the honest answer is that independent evaluations of the V4 line were not published as of September 2026, so DeepSeek’s own technical-report claims are the only numbers available — and they are labelled as such wherever this guide mentions them.

How the Pricing Actually Works

A close-up of a calculator and a small pile of coins on a desk next to a notebook with abstract scribbles. No legible numbers, no text, no logos.

DeepSeek’s pricing looks simple — a small table of dollars per million tokens — and it is simple, once you understand the three distinctions it turns on: cache hit versus cache miss, peak versus off-peak, and input versus output. Get those three right and you can predict a bill to the cent. Get any one wrong and you can be out by a factor of fifty. All figures below are from DeepSeek’s official API pricing page, read in full on 17 November 2026, in US dollars per million tokens. DeepSeek notes on the same page that product prices may vary and that it reserves the right to adjust them — so treat these as checked on 17 November 2026 and re-check before you spend.

ModelInput, cache hit (off-peak / peak)Input, cache miss (off-peak / peak)Output (off-peak / peak)
deepseek-flash$0.003 / $0.006$0.15 / $0.30$0.60 / $1.20
deepseek-v4-pro$0.022 / $0.044$0.66 / $1.32$1.98 / $3.96

The first distinction is the cache. When you send a prompt, DeepSeek checks whether it has recently processed the same text — typically your system prompt and any documents you attach on every call. If it has, that input is a cache hit and costs almost nothing: $0.003 per million tokens on Flash off-peak, fifty times less than the $0.15 cache-miss price. On V4-Pro the gap is thirty-fold: $0.022 against $0.66. The cache is the single biggest lever on a DeepSeek bill, and it rewards exactly the pattern real applications use — the same instructions and the same documents, sent again and again with a new question each time. If your application sends a long, fresh document on every call, you pay the cache-miss price on all of it, and your bill will be far higher than the headline $0.003 figure suggests. If it reuses context, the input cost effectively vanishes and you pay almost entirely for output. That is why two developers can use the same model and report wildly different costs: they are not paying different prices, they are hitting the cache at different rates.

The second distinction is peak versus off-peak, and it is exactly a factor of two: every off-peak price is half the peak price. Peak hours are 01:00–04:00 and 06:00–10:00 UTC, Monday to Friday, excluding Chinese public holidays. In Pakistan time (PKT, UTC+5) that is 06:00–09:00 and 11:00–15:00 on weekdays. All other hours are off-peak, including the whole weekend and Chinese public holidays in full. For a developer in Pakistan, that means the cheapest hours run through the afternoon, evening and night, while the late morning to early afternoon on weekdays is peak. The practical advice is simple: if your workload can wait, schedule bulk jobs outside the peak windows and pay half. If it cannot wait, budget at peak prices and treat any off-peak saving as a bonus.

The third distinction is input versus output, and output is where the money goes. On Flash at peak, output costs $1.20 per million tokens — four times the $0.30 cache-miss input price, and two hundred times the $0.006 cache-hit input price. On V4-Pro at peak, output is $3.96 per million tokens, three times its cache-miss input price. The lesson is that a model that writes long answers is expensive in a way that a model that reads long documents is not. Thinking mode makes this sharper, because the model’s reasoning tokens count as output: a long chain of thought is billed at the output rate even though you may never see it. Turning thinking off for simple questions is not just a speed choice; it is a money choice.

A worked example makes the arithmetic concrete. Suppose your application processes 10 million input tokens a day on Flash off-peak, with 80% of the input hitting the cache, and generates 2 million output tokens. The bill is: 8 million cache-hit input tokens at $0.003 per million, which is $0.024; 2 million cache-miss input tokens at $0.15 per million, which is $0.30; and 2 million output tokens at $0.60 per million, which is $1.20. Total: $1.52 a day. At peak prices the same workload costs $3.05. Run the same workload on GPT-5 at peak — 8 million cached input tokens at $0.125 per million ($1.00), 2 million fresh input tokens at $1.25 per million ($2.50), 2 million output tokens at $10.00 per million ($20.00) — and the total is $23.50 a day, roughly eight times the Flash peak price. That is the price gap in real money, and it is why the cache and the clock matter as much as the model choice. For the GPT-5 figures in that comparison, see our guide to the OpenAI API, where the GPT-5 family prices were checked against OpenAI’s own pricing and documentation pages.

Two more charges complete the picture. First, the extras: web search and fetching a URL cost $0.75 per 1,000 searches or fetches; file parsing and OCR cost $0.225 per 1,000 pages; text-to-speech costs $0.45 per 10,000 characters, currently half price at $0.225 as a limited-time offer; and automatic speech recognition costs $0.116 per hour of audio, also half price at $0.058 for a limited time. Those extras come from the same pricing page and carry the same 17 November 2026 check date. Second, the limits: Flash allows 2,500 concurrent requests and V4-Pro allows 500, which matters more than it looks — a low concurrency limit is a queue by another name, and it is covered in the availability section later in this guide. The free chat, by contrast, costs nothing at all: there is no subscription, no per-message charge and no published daily message cap. The API is the only paid product, and the chat app is the free front door to it.

DeepSeek vs ChatGPT on Price: The Real Comparison

Two shopfronts side by side on a street at dusk, one modest and one grand, with blank price tags in the windows. No readable text, no logos.

The comparison everyone wants is DeepSeek against ChatGPT, and the honest version of it is a table, not a slogan. On the API, where the figures are verified, the comparison is straightforward. The table below uses DeepSeek’s official pricing page, checked 17 November 2026, and OpenAI’s GPT-5 family prices as checked against OpenAI’s own pricing and documentation pages for our OpenAI API guide on 6 November 2026, corroborated by aggregator reads on 16 November 2026. All figures are peak prices per million tokens.

A note on the comparison, checked 17 November 2026: OpenAI’s live API pricing page no longer lists GPT-5 at all — the GPT-6 family has replaced it (GPT-6.1 Sol now lists at $2.00 input and $10.00 output per million tokens, with cached input at $0.10). The GPT-5 figures in the table below are therefore GPT-5’s last published prices, checked against OpenAI’s own pricing page on 6 November 2026 and corroborated by aggregator reads on 16 November 2026, and are kept here so the comparison stays readable. The conclusion is unchanged on the new numbers: against GPT-6.1 Sol, Flash is still roughly seven times cheaper on input ($0.30 against $2.00) and more than eight times cheaper on output ($1.20 against $10.00).

ModelInput (cache miss)Input (cached)OutputContext
DeepSeek Flash$0.30$0.006$1.201M tokens
DeepSeek V4-Pro$1.32$0.044$3.961M tokens
GPT-5$1.25$0.125$10.00400K tokens
GPT-5 mini$0.25—$2.00400K tokens
GPT-5 nano$0.05—$0.40400K tokens

Read the table carefully, because it says three different things. First, against the flagship: Flash is about four times cheaper than GPT-5 on fresh input ($0.30 against $1.25), about twenty times cheaper on cached input ($0.006 against $0.125), and more than eight times cheaper on output ($1.20 against $10.00). V4-Pro is roughly at parity with GPT-5 on input ($1.32 against $1.25) and about two and a half times cheaper on output ($3.96 against $10.00). If your workload is a flagship model doing serious work, DeepSeek is dramatically cheaper, and the gap is widest exactly where the money is — on output tokens. Second, against the small models, the story flips: GPT-5 nano charges $0.05 per million input tokens and $0.40 per million output tokens, which is cheaper than Flash on both axes. Nano is a much smaller model with a 400K context window against Flash’s 1 million tokens, so the two are not interchangeable — but any guide that claims DeepSeek is cheapest on every axis is wrong, and this one does not make that claim. Third, on context: both DeepSeek models offer a 1-million-token window against the GPT-5 family’s 400K total (up to 272K input and 128K output), so DeepSeek is the cheaper way to work with very long documents as well as the cheaper way to generate long answers.

The consumer comparison is different, and it is where DeepSeek’s advantage is clearest. DeepSeek’s chat app is free, with no subscription tier. ChatGPT’s Plus plan costs $20 a month, billed monthly with no annual discount, according to OpenAI’s pricing page as corroborated by multiple secondary reads checked 17 November 2026. That is $240 a year for the privilege of a better model, higher limits and extra features — against $0 for DeepSeek’s chat. The products are not identical: ChatGPT Plus buys a general-purpose assistant with memory, projects, file tools, deep research and a much wider feature set, while DeepSeek’s free chat is a thinner product built around the model itself. But for a user whose main need is a good chat model and who does not need the extras, the price difference is the whole story: one costs $20 a month, the other costs nothing. For the full ChatGPT tier breakdown, see our comparison of ChatGPT’s Free, Plus and Pro tiers, and for the company and models behind it, our OpenAI explainer.

The honest verdict is that there is no overall winner on price, because the products are not the same shape. If you want the cheapest capable model per token, DeepSeek Flash wins against every flagship and loses only to the smallest OpenAI model — and it wins by a large margin where it matters most, on output. If you want a free chat with no subscription, DeepSeek wins outright, because ChatGPT’s free tier is a limited version of a paid product while DeepSeek’s free chat is the product. If you want the cheapest possible token regardless of capability, GPT-5 nano is cheaper than Flash. And if you want the best reasoning model money can buy, the comparison is not really about DeepSeek versus ChatGPT at all: Claude and Gemini both field flagship reasoning models whose pricing and capabilities belong in the same decision, and our Claude explainer and our Gemini explainer cover those. Price is one axis. The rest of this guide covers the others — and the next section, thinking mode, is where DeepSeek’s design starts to look genuinely different rather than merely cheaper.

Thinking Mode Explained: Reasoning Without a Separate Model

A person thinking at a desk with a thought bubble made of gears and puzzle pieces above them. No text, no logos.

The biggest conceptual change in the V4 line is also the easiest to miss: reasoning is no longer a model you pick. In the R1 era, you chose between a chat model and a reasoning model, and switching meant starting over in a different model. In the V4 line, both Flash and V4-Pro have thinking built in. It is a mode, controlled by two API settings, and it is on by default. That single design decision changes how you use DeepSeek more than any price cut, so it is worth understanding properly.

The controls are two settings in the Chat Completions API, documented in full on DeepSeek’s API docs page read on 17 November 2026. The first is thinking, which takes {"type": "enabled"} or {"type": "disabled"}. The second is reasoning_effort, which takes none, low, high or max, and defaults to high. Thinking is enabled by default when you set neither — so if you call the API with no thinking settings at all, you get a thinking model. Older effort labels are mapped for compatibility: minimal becomes low, and medium and xhigh both become high. The output limit follows the effort: max_tokens can go up to 384,000 tokens, with a default of 8,000 tokens in non-thinking mode and 64,000 in thinking mode, rising to 128,000 when reasoning_effort is set to max. On the chat app, the same behaviour appears as a thinking toggle and, for V4-Pro, an “Expert Mode” switch — but the API settings are the precise version, and they are what developers should build on.

When to think, and when not to, is a practical question with a money answer attached. Turn thinking on — or leave it on, since it is the default — for anything where the answer is not obvious: maths, logic puzzles, multi-step planning, debugging code, analysing a long document, or any question where a wrong first guess is expensive. Use max effort for the hardest problems, where you want the model to work longest. Turn thinking off for anything where the answer is a fact, a summary or a short piece of writing: a translation, a quick rewrite, a simple question, a greeting. The reason is not just speed. Thinking tokens are billed as output, at the output rate, so a long chain of thought on a trivial question is money spent on reasoning nobody needed. On Flash at peak, a 10,000-token thinking trace costs $0.012 — small in isolation, but across a million API calls it is the difference between a cheap application and an expensive one. The rule of thumb is short: think when the problem is hard, do not think when it is easy, and set reasoning_effort to low for the large middle ground of questions that need a little thought but not a lot.

For R1 users, three things need relearning. First, there is no separate reasoner to switch to: the model you are already using is the reasoner, and the switch is a setting, not a model name. Second, the default is on, where R1 was an opt-in choice — so a developer who migrates old code without setting thinking to disabled will get thinking behaviour, thinking token bills and thinking-length outputs by default, and should set the parameter explicitly rather than assuming the old defaults. Third, the old model names are gone: code that calls deepseek-reasoner will not reach R1 any more. The migration is small — a model name and two settings — but it is a migration, and anyone still running R1-era code against DeepSeek’s API should update it rather than assuming the old names still work. The weights of R1 remain available elsewhere for anyone who genuinely needs the old model, but on DeepSeek’s own platform, thinking mode is the reasoning product now.

The 1-Million-Token Context Window: What It Lets You Do

An extremely long paper scroll unrolling across a library table, with books stacked at both ends. No readable text, no logos.

Both current DeepSeek models accept up to 1 million tokens of context — roughly 750,000 English words, or about ten average novels — and can generate up to 384,000 tokens of output in a single call. Those two numbers are on DeepSeek’s pricing page and in its API documentation, and they are the same for Flash and V4-Pro. A million-token window is not a marketing number. It changes what the models can be used for, and it is one of the places where DeepSeek is ahead of the GPT-5 family, whose total context is 400,000 tokens. But a long window is also easy to misuse, so this section covers what it genuinely enables and where it still breaks down.

The clearest use is long documents. A million tokens holds an entire legal contract, a full annual report, a PhD thesis, or a whole codebase’s core files in a single prompt, with room left over for the question. That means you can ask a model to compare two versions of a contract, find the contradictions in a long report, or trace a bug across a dozen files without the chunking and summarising that shorter-context models force on you. It also means you can feed a model a whole book and ask it to summarise it, or to answer questions that require connecting a fact on page 10 with a fact on page 300. For researchers, lawyers, analysts and developers working with large documents, that is a real capability, not a specification-sheet boast — and at DeepSeek’s cache prices, reusing the same long document across many questions costs almost nothing on input after the first read, because the cache-hit price is $0.003 per million tokens on Flash off-peak.

The second use is long output. A 384,000-token maximum output is unusually large — most models cap output far lower — and it matters for tasks that produce long text: a full report, a long piece of code, a detailed analysis, or a multi-chapter draft. The default output limits are much smaller (8,000 tokens without thinking, 64,000 with it), so you have to raise max_tokens deliberately to use the full allowance, and you should, because the default will cut a long generation short without warning. But remember the pricing lesson from the earlier section: output is the expensive token. A 384,000-token output on Flash at peak costs about $0.46; on V4-Pro at peak it costs about $1.52. Those are small numbers, but they are per call, and a long-output application making thousands of calls a day should budget for them explicitly.

The honest limit is quality at extreme length, and it applies to every long-context model, DeepSeek included. A model that can accept a million tokens does not necessarily use a million tokens well: details buried in the middle of a very long prompt are easier to miss than details at the start or the end, instructions given early can be forgotten by the time the model reaches the question, and a long document full of irrelevant material dilutes the model’s attention on the relevant parts. That is general large-language-model behaviour, not a DeepSeek-measured claim — no primary source publishes a DeepSeek-specific accuracy curve across context lengths — so this guide states it as a general caution rather than a measured fact. The practical advice follows from it: keep the context as short as the task allows, put the question and the key instructions at the end of the prompt as well as the beginning, and test long-context work on a sample before trusting it at scale. A million-token window is a powerful tool, and like every powerful tool it rewards the user who respects its limits.

Vision, Search, Files and Voice: What the Models Can Actually Do

A desk with a phone showing an abstract photo, a paper document, and a magnifying glass over a map. No readable text, no logos.

DeepSeek’s models are text models first, but the V4 line has grown a set of capabilities around the text core, and the most important thing to know about them is that they are not evenly distributed between the two models. Vision is the sharpest example: Flash supports image input, and V4-Pro does not. If your task involves reading a chart, describing a photo, extracting text from a screenshot or answering questions about an image, Flash is the only first-party DeepSeek model that can do it. That is a genuine limitation of the stronger model, and it is worth checking before you build on V4-Pro: a developer who picks Pro for its capability and then discovers it cannot see images has picked the wrong model for the job.

The bigger change arrived on 13 November 2026, when DeepSeek opened the chat app’s features to API developers. On deepseek-flash, across the Messages, Responses and Chat Completions APIs, developers can now use web search, deep-thinking search, file input, URL reading and safety checks — the features that previously existed only inside the chat app. Alongside them came standalone APIs for search, fetching, OCR, speech recognition and text-to-speech, and an open-source demo chat application at github.com/deepseek-ai/chat-demo, released under the MIT licence. The prices for those extras are confirmed on the pricing page read for this guide: web search and fetching cost $0.75 per 1,000 searches or fetches, file parsing and OCR cost $0.225 per 1,000 pages, text-to-speech costs $0.45 per 10,000 characters (currently half price at $0.225), and speech recognition costs $0.116 per hour of audio (currently half price at $0.058). The 13 November date and the demo-app repository are secondary-reported — our own news post covers the release in detail — so this guide cites them with that attribution and links to the news post rather than re-reporting it. For the full story of the release, see our news coverage of DeepSeek turning its app into a developer API.

Two more capabilities complete the picture. First, tool use: both models support function calling, and the API offers DeepSeek’s own web tools — deepseek_web_search and deepseek_read_url — so a model can search the web and read pages as part of answering. There is also a safety_check extension, where setting the level to high turns on basic risk control that reviews both input and output. Second, DeepSeek Harness, a desktop application for agent harness developers, is in developer preview, with its guide published at deepseek-harness.github.io. Harness is the beginning of an agent story for DeepSeek — a way to build agents on top of the models rather than just calling them — but it is a preview, not a finished product, and this guide does not present it as more than that.

The practical summary is short. If you need vision, use Flash. If you need the web, files or voice through the API, Flash is also the model that has them, and the extras are cheap — a thousand web searches cost less than a dollar. If you need the strongest reasoning and you do not need images, use V4-Pro. And if you are comparing DeepSeek’s search features with a dedicated answer engine, remember that DeepSeek is a model with search attached, not a search product: it searches to answer, and the quality of the answer depends on the model, not on the search alone. The capabilities are real and the prices are low, but they are additions to a text model, not a separate product line — and the next section shows how little work it takes to start using them.

How to Start: Chat, App, and API in Ten Minutes

Hands typing on a laptop with a coffee cup beside it and a small paper-plane model on the desk. No readable text, no logos.

Starting with DeepSeek takes about ten minutes, and there are three doors in, in order of effort. The first door is the chat app, and it is the one most readers should walk through first. Go to chat.deepseek.com, create an account, and start typing. There is no subscription to choose, no plan to pick, and no payment to enter. The iOS and Android apps offer the same chat on a phone. The model behind the chat is V4.1-Flash-1017, updated on 17 October 2026, and V4-Pro is available through the app’s “Expert Mode”. Spend an hour with the chat before you spend anything on the API: it will tell you whether DeepSeek’s answers are good enough for your work, whether the peak-hour slowness affects you, and whether the thinking behaviour suits the way you ask questions. The chat is the free trial, and it is a genuine one.

The second door is the API, and it is simpler than most API quick-starts. Create a key on DeepSeek’s platform, then call the Chat Completions endpoint at https://api.deepseek.com — or the Anthropic-compatible endpoint at https://api.deepseek.com/anthropic if your tooling speaks Anthropic’s format. The only two valid model names are deepseek-flash and deepseek-v4-pro. A minimal first call sets the model to deepseek-flash, sends a user message, and gets an answer back; thinking is on by default, so add "thinking": {"type": "disabled"} if you want a plain answer, or set reasoning_effort to low for a light touch. DeepSeek’s own quick-start guide, “Your First API Call”, read in full for this guide, walks through exactly that call. Two things to remember from the pricing sections: set max_tokens explicitly if you want long output, because the defaults are 8,000 tokens without thinking and 64,000 with it; and reuse your system prompt and documents across calls, because the cache-hit price is fifty times cheaper than the cache-miss price on Flash. This section is a walkthrough, not the full tutorial — a dedicated DeepSeek API tutorial is a separate guide, and this one deliberately stops at the first call.

The third door is no code at all. DeepSeek’s API works as a backend inside Claude Code, GitHub Copilot and OpenCode, with no code required: you point the tool at DeepSeek’s API and use DeepSeek’s models from inside a coding assistant you already know. That is the fastest route for a developer who wants DeepSeek’s prices inside a real workflow without writing integration code, and it is also the best way to compare DeepSeek’s coding against the model you currently use — same tool, different model, same task. For the wider comparison of coding assistants and what to look for in one, see our comparison of AI coding assistants. Whichever door you choose, the same advice applies: start with the free chat, try the API on a small workload, watch the first bill, and only then commit a real application to it. Ten minutes of testing will tell you more than ten more sections of this guide.

Open Weights: What “Open” Really Means

An open wooden crate with glowing puzzle pieces spilling out onto a workbench in warm workshop light. No readable text, no logos.

DeepSeek calls its models open, and the claim is worth unpacking, because “open” means several different things in AI and DeepSeek means a specific one. The V4 family is released under the MIT licence, one of the most permissive licences in software: anyone can download the weights, use them, modify them and build commercial products on them, with almost no restrictions. The weights are published on Hugging Face — V4.1-Flash, for example, is published as deepseek-ai/DeepSeek-V4.1-Flash — and they are also available through third-party hosts such as AWS SageMaker JumpStart, which added the V4 models on 11 November 2026, and OpenRouter, which routes a large volume of DeepSeek tokens. That is genuine openness, and it is the reason DeepSeek has an ecosystem far larger than its own products: researchers fine-tune the models, companies host them, and developers build on them without ever talking to DeepSeek.

Openness matters for price in a way that is easy to miss. When weights are open, anyone can host the model, and hosts compete on price. That competition disciplines DeepSeek’s own API pricing: if DeepSeek charged too much, users would simply move to a cheaper host running the same weights. It also means the model cannot be taken away: if DeepSeek changed its API, raised its prices or shut down tomorrow, the weights would still exist, and the community would keep running them. That is a real form of insurance, and it is one that closed models cannot offer. It is also why the open-weights strategy is good business for DeepSeek rather than charity: openness buys distribution, trust and an ecosystem that a closed lab has to pay for. For the comparison on the open side, Meta’s Llama family is the other major open-weights line, and our Meta AI explainer covers what Llama offers and how its openness differs from DeepSeek’s.

The honest cost of self-hosting is the part most explainers skip, so this guide states it plainly. Running a model yourself is not free just because the weights are free. The V4.1-Flash checkpoint is about 510 gigabytes in size, according to secondary reports — DeepSeek publishes no official hardware guidance — which means you need serious storage before you even start, and serious GPU memory to run it at usable speed. DeepSeek publishes no minimum GPU specification, and this guide states none, because none exists to cite. In practice, self-hosting a 552-billion-parameter model is a job for a company with a GPU cluster, not for a laptop. For most individuals and small teams, the realistic ways to use open weights are through a third-party host, which handles the hardware and charges per token, or through a smaller distilled or quantised version of the model that fits on hardware you actually own. Open weights give you the choice of where the model runs. They do not give you free compute, and anyone who tells you self-hosting is free has confused the price of the weights with the price of the hardware.

There is one more distinction that belongs in this section, because it is the key to the privacy section that follows: a DeepSeek model and DeepSeek’s service are not the same thing. When you use the chat app or DeepSeek’s own API, your data goes to DeepSeek. When you run the same model yourself, or through another provider such as AWS or OpenRouter, your data goes to that provider and follows that provider’s policy — nothing is sent to DeepSeek. The model is open; the service is a separate product with its own data rules. That distinction is the single most useful fact in this guide for anyone worried about data, and the next-but-one section builds on it directly.

Speed, Availability, and Peak Hours: The First Trade-Off

A busy motorway at rush hour with many cars queuing in lanes, seen from a bridge at dusk, headlights glowing. No readable text, no logos.

The first trade-off of DeepSeek’s price is the one you feel rather than the one you read about: speed and availability. A free chat with no subscription and a famously cheap API attracts enormous traffic, and enormous traffic queues. The queuing on the free chat at peak hours is widely reported — users describe slow responses and “server busy” messages at busy times — but it is anecdotal, not measured: DeepSeek publishes no speed, latency or uptime figures, and this guide gives none, because no primary source publishes them. What can be said with confidence is the shape of the problem: cheap plus popular equals busy, and the busy times are the peak hours on the pricing page — weekday mornings in UTC, which are late morning to early afternoon in Pakistan.

The API has its own version of the same constraint, and it is visible in the numbers. Flash allows 2,500 concurrent requests; V4-Pro allows just 500. A concurrency limit is a queue by another name: when more requests arrive than the limit allows, the excess waits or fails, and the stronger model — the one you most want at busy times — has the lower limit. That is not an accident. V4-Pro is a far larger model, with 49 billion active parameters per token against Flash’s 16 billion in decode, so each request costs DeepSeek more to serve, and the concurrency limit is how DeepSeek rations that cost. The practical consequence is that V4-Pro is the model most likely to be slow or unavailable exactly when you need it most, and any application built on it should handle retries and fall back to Flash gracefully rather than assuming Pro is always there.

The scale of the traffic is visible in third-party data. Our own news coverage reported that DeepSeek now moves more tokens through OpenRouter than OpenAI and Anthropic combined — a striking figure for a lab that was obscure two years ago, and a useful proxy for how much demand its low prices have created. For the details, see our report on DeepSeek’s token volume on OpenRouter. That volume is both the proof that the price works and the cause of the queues: the same low prices that attract users also attract more users than the infrastructure can always serve at once.

Who should pay for the API instead of using the free chat? Anyone whose work cannot wait. If you are a developer building an application, pay: the API is cheap, the concurrency limits are published, and a paid API call is a far more reliable thing than a free chat at peak hours. If you are a professional whose time is worth more than the pennies the API costs, pay: the worked example earlier in this guide put a serious daily workload at $1.52 off-peak on Flash, and your time is worth more than the minutes a queue would cost you. If you are a casual user asking a few questions a day, stay free — and ask them outside peak hours if you can. The free chat is a good product at the price of nothing; it is simply a product that gets busy, and the fix for busy is either patience or a very small API bill.

Your Data: Where It Goes and What to Do About It

A locked metal filing cabinet with a keyhole and a paper shredder beside it in a quiet office, cool blue light. No readable documents, no text, no logos.

The second trade-off of DeepSeek’s price is the one you should understand before you paste anything sensitive into it: your data. DeepSeek’s privacy policy, last updated on 10 February 2026, states — in the policy’s own words, as quoted verbatim by multiple independent secondary sources — that “we directly collect, process and store your Personal Data in People’s Republic of China.” The data controller is Hangzhou DeepSeek Artificial Intelligence Co., Ltd. This guide cites the policy through that secondary coverage because the policy page itself could not be read directly during this research, and it does not invent a policy URL. The storage location is the fact that matters, and it is stated here without softening: if you use DeepSeek’s chat app or its API, your data is stored in China under Chinese law.

What is collected is broad, and it is worth listing. According to the same policy coverage, DeepSeek collects the text and voice input you type or speak, your prompts, files and photos you upload, your feedback, your chat history, and device and network data including your IP address and approximate location. The policy also gives users a right to opt out of having their personal data used for model training — a real protection, and one you should use if you use the service for anything beyond casual questions. The distinction from the open-weights section applies here in full: this is the policy for DeepSeek’s app and API. A DeepSeek model run locally, or through another provider such as AWS or OpenRouter, follows that provider’s policy and sends nothing to DeepSeek. The model is not the service, and the data rules follow the service you actually use.

Regulators have acted, and the record is worth stating with dates rather than as a vague warning. Italy’s data-protection authority, the Garante, restricted the app in January 2025. South Korea’s Personal Information Protection Commission found in April 2025 that device and network data and user input were being sent to Beijing Volcano Engine. Germany’s Berlin data-protection commissioner reported the app to Apple and Google in June 2025. In the United States, several states restrict the app on government devices, and a bill called the “No DeepSeek on Government Devices Act” (H.R. 1121) exists. Separately, the security firm Wiz found an exposed DeepSeek database in January 2025 containing more than a million log lines including chat history; DeepSeek closed it. All of those items are secondary-reported, and this guide presents them with attribution and dates rather than as primary-verified fact. None of them means DeepSeek is unsafe for every use. All of them mean the data question deserves a decision rather than a shrug.

The practical rules are short, and they are the same rules that apply to any AI service, with DeepSeek’s storage location as the extra reason to follow them. Never paste secrets: no passwords, no API keys, no private credentials, no confidential business or legal documents. Never paste personal data you would not want stored abroad: medical details, financial records, children’s information. If your work is sensitive, do not use the app or the API at all — run the open weights locally or through a provider whose data policy you have read and accepted, because that is the route where nothing goes to DeepSeek. And turn on the training opt-out if you use the service. DeepSeek’s price is real, its models are good, and its data policy is stated plainly on its own pages. Read it, decide what you are comfortable with, and then use the product within that decision — rather than discovering the policy after the fact.

The Verdict: Who Should Use DeepSeek, and Who Shouldn’t

A fork in a forest path with two blank wooden signposts in morning mist, a hiker standing at the fork. No readable text, no logos.

There is no overall winner in this guide, and there should not be. DeepSeek is the cheapest capable AI on the market and the only frontier-class chat that is entirely free — and it is also the one with the busiest free tier, the narrowest feature set, and the most consequential data policy. The verdict below is by user type, because a verdict by product would be a verdict about nothing. For the general skill of picking between models — speed, cost, reasoning depth and context — see our guide to choosing an AI model, which covers the trade-offs that sit behind any model choice, DeepSeek’s included.

You areUse DeepSeek?Why
Casual chatterYes — the free chatIt costs nothing, the model is strong, and you lose nothing by trying it first.
StudentYes — free chat, then the APIFree reasoning with thinking mode, a million-token window for long readings, and API bills measured in cents.
DeveloperYes — the API, Flash firstThe cheapest capable tokens available, with cache pricing that rewards real application patterns. Fall back to Flash when Pro is busy.
Business, cost-sensitiveYes — with careHigh-volume workloads are dramatically cheaper than GPT-5, but budget for peak prices and build retries around the concurrency limits.
Privacy-sensitive userOnly via another host or locallyThe app and API store your data in China. Use the open weights through a provider you trust, or run them yourself.
Government or regulated workProbably notRestrictions exist on government devices in several countries and US states; check your organisation’s rules before using it.
Someone who needs vision, voice and agents in one placeProbably not as the only toolFlash has vision and the API has search and voice, but the feature set is thinner than ChatGPT, Claude or Gemini — use DeepSeek for the model, not the platform.

When is ChatGPT, Claude or Gemini the better call? When the work is the platform rather than the model: long conversations with memory, projects, deep research reports, document creation, and agentic work across your apps are all stronger in ChatGPT and Claude than in DeepSeek’s thin chat wrapper. When you need the strongest reasoning money can buy regardless of price, Claude’s flagship and Gemini’s flagship belong in the same comparison, and their explainers on this site cover them. When your organisation’s rules forbid data stored in China, the decision is made for you, and the open-weights route through another host is the only DeepSeek option that survives it. And when you need guaranteed availability at a specific hour, a paid API with published limits — DeepSeek’s included — beats any free chat, DeepSeek’s included.

The bottom line is the one this guide opened with. DeepSeek is cheap because its architecture spends compute only where it matters, because its weights are open, and because its pricing sells spare capacity at half price and cached input at a fiftieth of the fresh price. The price is real, not marketing, and the worked example in the pricing section shows it in dollars: a serious daily workload for about a dollar and a half. What you give up is also real: a free chat that queues at peak hours, a stronger model that cannot see images, a thin feature set, and a data policy that stores your personal data in China. For a casual user, a student, a developer or a cost-sensitive business, that is a good trade, and the free chat is the right place to start. For privacy-sensitive or regulated work, it is the wrong trade, and the open weights run elsewhere are the only version worth using. Know which user you are, and the choice makes itself. All prices checked 17 November 2026.

Sources

All sources below were read in full on 17 November 2026, except where noted. Prices, limits, model names and dates in this guide come from these pages. Prices carry a “checked 17 November 2026 — re-check before you spend” note. Secondary sources are labelled as such and used only where the brief says so.

  • DeepSeek API docs — Pricing (official pricing page, read in full 17 November 2026) — https://api-docs.deepseek.com/quick_start/pricing
  • DeepSeek API docs — Create Chat Completion (read in full 17 November 2026) — https://api-docs.deepseek.com/api/create-chat-completion
  • DeepSeek API docs — “Your First API Call” (read in full 17 November 2026) — https://api-docs.deepseek.com/news/news250917
  • DeepSeek — Homepage (read 17 November 2026; minimal, Chinese-first; not cited for history, pricing or specs) — https://www.deepseek.com/
  • DeepSeek Privacy Policy (last updated 10 February 2026) — quoted verbatim in multiple independent secondary sources; the policy page itself was not read directly in this session, and no policy URL is stated here. Checked 17 November 2026.
  • DeepSeek V4.1-Flash release and architecture (September–October 2026) — DeepSeek technical report via secondary summaries; figures labelled “DeepSeek-reported” in this guide. Release 10 September 2026; checkpoint V4.1-Flash-1017, 17 October 2026.
  • DeepSeek V3 / R1 deprecation (24 July 2026) and V4 timeline — DeepSeek changelog as reported by multiple independent secondary sources, corroborated against the pricing page and API docs read 17 November 2026.
  • DeepSeek free chat and peak-hour queuing — secondary sources, corroborated across four or more independent sources; queuing described as reported, not measured. Checked 17 November 2026.
  • DeepSeek 13 November 2026 API expansion (app features via API; Search, Fetch, OCR, ASR and TTS APIs; demo chat app) — prices confirmed on the official pricing page read 17 November 2026; date and demo-app repository secondary-reported. See also our news post: https://geroundtable.com/deepseek-full-app-api/
  • AWS — “What’s New” announcement, 11 November 2026 (V4-Pro, V4-Flash and V4.1-Flash on SageMaker JumpStart; V4-Pro 1.6T total parameters, 49B active per token, AWS-reported).
  • OpenAI GPT-5 family API prices — our published evergreen https://geroundtable.com/openai-api-explained/ (checked 6 November 2026 against OpenAI’s own pricing and documentation pages), corroborated by aggregator reads 16 November 2026. GPT-5 retirement claims were secondary-only and are omitted from this guide. Director’s note, 17 November 2026: OpenAI’s live API pricing page (https://platform.openai.com/docs/pricing) no longer lists GPT-5; the GPT-6 family is listed instead (GPT-6.1 Sol $2.00 input / $10.00 output / $0.10 cached input per 1M tokens).
  • ChatGPT Plus price ($20 a month, monthly billing only) — OpenAI’s pricing page as corroborated by multiple secondary reads checked 17 November 2026.
  • Regulator actions and the Wiz database finding (Italy Garante, January 2025; South Korea PIPC, April 2025; Berlin data-protection commissioner, June 2025; US state restrictions and H.R. 1121; Wiz exposed database, January 2025) — secondary-reported, presented with attribution and dates.
  • DeepSeek token volume on OpenRouter — our news post https://geroundtable.com/deepseek-openrouter-token-dominance/ (post 5107).
  • Self-hosting checkpoint size (~510 GB) — secondary-reported; DeepSeek publishes no minimum GPU specification, and none is stated in this guide.
  • No V5 or new R-series model announced — secondary sources, October 2026; the only future model DeepSeek has pointed to is V4.1-Pro, with no date.

Share to: , and

Faheem R. Khattak

Senior automation engineer and AI marketing journo covering LLMs, algorithms, analytics, core updates, Bing search, and technical SEO.

0 Comments

Leave a Reply

Optional Take Tag:

🛡️ Spam protection: Honeypot + Time-Trap Active

This site uses Akismet to reduce spam. Learn how your comment data is processed.