DeepSeek V4 Flash: model id, API pricing, and the real cost of running it on Twitter (X) data

DeepSeek runs two API models at the moment: deepseek-flash and deepseek-v4-pro. The Models & Pricing page lists the model version behind deepseek-flash as DeepSeek-V4.1-Flash-1017 and the version behind deepseek-v4-pro as DeepSeek-V4-Pro-0813. Both are reachable through an OpenAI-format base URL (https://api.deepseek.com) and an Anthropic-format base URL (https://api.deepseek.com/anthropic), so the OpenAI and Anthropic SDKs work after you change the base URL and the key.

Footnote (1) on that page is the part most people miss: use deepseek-flash as the model name; the legacy names deepseek-v4-flash and deepseek-v4-flash-vision-exp are still accepted, but the corresponding models have been retired, and their requests are served by DeepSeek-V4.1-Flash-1017 and billed at the Flash price. In other words, code written for V4 Flash keeps running, but it is no longer talking to V4 Flash.

The change log shows how the name drifted. April 24, 2026: the V4 Preview added deepseek-v4-pro and deepseek-v4-flash, and pointed the old deepseek-chat and deepseek-reasoner names at V4 Flash's non-thinking and thinking modes until their retirement on July 24, 2026. July 31, 2026: the official V4 Flash API went into public beta. September 10, 2026: V4.1 Flash shipped with native image understanding, the model name became deepseek-flash, V4 Flash and V4 Flash Vision Exp were retired, and API prices were cut. October 17, 2026: V4.1-Flash-1017 replaced it behind the same name with "the API calling method and pricing" unchanged, according to the change log.

The October release note describes the 1017 build as a Pareto improvement: higher benchmark scores with shorter outputs and faster task completion. Shorter outputs matter for cost, because output tokens are the most expensive line on the rate card. The weights are also published on Hugging Face as deepseek-ai/DeepSeek-V4.1-Flash-1017, so self-hosting is an option if you have the hardware; the prices on this page apply only to DeepSeek's hosted API.

DeepSeek bills model usage per token: expense equals tokens times price, deducted from your topped-up or granted balance (granted balance first). There is no subscription for the API. Prices are listed per 1M tokens and split three ways: input tokens that hit the context cache, input tokens that miss it, and output tokens. Since August 16, 2026 every rate also has a peak and an off-peak version.

Peak hours. The pricing page defines peak as 01:00-04:00 and 06:00-10:00 UTC, Monday through Friday, excluding Chinese public holidays. Every other hour is off-peak, including weekends and Chinese public holidays in full. For a team in the Americas that is mostly the middle of the night, so interactive daytime traffic in the US lands almost entirely in off-peak hours, while a European morning overlaps the 06:00-10:00 UTC window.

Cache hits are 50x cheaper than misses. A cache hit on deepseek-flash costs $0.006 per 1M tokens at peak against $0.30 for a miss. DeepSeek's context-caching guide explains that the cache matches repeated prefixes (for example the same system prompt at the start of every request), works on a best-effort basis with no guaranteed hit rate, and reports what happened in two usage fields: prompt_cache_hit_tokens and prompt_cache_miss_tokens.

Flash vs Pro. At the same hour, deepseek-v4-pro costs 4.4x Flash on cache-miss input and 3.3x on output. DeepSeek's own September note said multiple parties found V4.1 Flash ahead of V4 Pro on performance, cost and speed; the change log later says V4 Pro service continues with billing unchanged. For high-volume text jobs such as labeling posts, Flash is the default choice the docs point you to.

Search and Fetch are billed separately. The same page lists DeepSeek's Search and Fetch APIs at $0.75 per 1,000 successful requests each, and notes that server-side tool calls from DeepSeek Harness, Claude Code and Codex started being billed at 16:00 UTC on October 31, 2026. If your agent lets the model browse, that is a separate line item from tokens.

Context length: 1M tokens. DeepSeek made 1M context the default across its official services with the V4 Preview, and the pricing page lists 1M for both current models. Maximum output: 384K tokens. That is a ceiling, not a default; set max_tokens to what your task needs, because you pay for every output token.

Thinking mode is on by default. The thinking-mode guide says both models support non-thinking and thinking modes, that thinking is enabled by default with effort high, and that the chain of thought comes back in reasoning_content. Reasoning tokens are generated output, so a classification call in thinking mode can cost several times the same call in non-thinking mode. For short, well-defined labels, send "thinking": {"type": "disabled"} in the request body; keep thinking for multi-step agent work. Effort levels are low, high and max.

Sampling parameters. In thinking mode, temperature, presence_penalty and frequency_penalty are accepted but have no effect. For deepseek-flash, top_p only takes effect in thinking mode, within 0.95 to 1.0.

Concurrency: 2,500 for Flash, 500 for Pro. The Rate Limit & Isolation page counts limits per account, not per key. A request occupies one slot from send until the response completes; above the limit you get HTTP 429. DeepSeek offers capacity expansion at no extra cost on request, and a user_id parameter for isolating your own end users. Requests that have not started inference after 10 minutes are closed by the server.

Features. Both models support JSON Output, tool calls, the Responses API, the Anthropic API format and chat prefix completion (beta). FIM completion is non-thinking only. Vision is supported on deepseek-flash and not on deepseek-v4-pro, per the pricing table.

Price per token only becomes useful once you know how many tokens your data has. So we collected 1,000 recent public X posts that mention DeepSeek Flash or DeepSeek V4 (search query below), measured each one, and priced two common jobs. We did not have a DeepSeek API key for this build, so no post was sent to DeepSeek: the token counts are estimates, made two ways. The first uses DeepSeek's own documented ratio (about 0.3 token per English character and 0.6 per Chinese character). The second uses OpenAI's cl100k_base tokenizer as a cross-check; it is a different tokenizer, so treat the two as a range.

The sample is short text, but with a long tail. The median post is 216 characters and 73 estimated tokens; the mean is 164 tokens because some posts are long-form (the 90th percentile is 319 tokens and the longest is 5,706). If you process every post, budget for the mean, not the median.

How the jobs are modeled. Classification sends one request per post with a fixed 100-token system prompt and a 25-token JSON label in non-thinking mode; after the first calls, the repeated system prompt is billed as a cache hit. Per 1,000 posts that is about 164,591 cache-miss input tokens, 99,800 cache-hit tokens and 25,000 output tokens. Summarization packs 100 posts into each request and asks for a roughly 250-word brief (350 output tokens), so 1,000 posts become 10 calls with about 168,253 input tokens.

The cross-check moves the numbers, not the conclusion. With cl100k_base counts the same classification job comes to $0.048 off-peak and $0.097 at peak per 1,000 posts. Either way, labeling 1,000 posts with deepseek-flash costs a few cents, and the batch summary costs less than the per-post labels because the instructions are paid for ten times instead of a thousand.

Thinking mode would change this table. All figures above assume thinking is disabled. With the default thinking mode, every call also generates reasoning tokens at the output rate, which is the most expensive token on the card. Measure it on a few hundred calls with the usage object before you run a large job.

A post about a Chinese AI lab draws a multilingual audience. In our sample, 57.8% of posts were tagged English, 23.3% Chinese and 9.2% Japanese, with the rest spread across Portuguese, Korean, Spanish, Indonesian and others. Language changes the token count per character, and so the cost per post.

Chinese and Japanese posts are shorter in characters but heavier in tokens under both estimators. The gap between the two estimators is also much wider for CJK text (180 vs 326 tokens for Chinese), which is expected: DeepSeek's tokenizer is built for Chinese and English, while cl100k_base splits CJK text into more pieces. For English the two agree closely (151 vs 145).

Use the real count before you scale. DeepSeek publishes an offline tokenizer package on its Token & Token Usage page, and every API response returns exact usage numbers. Run it on a slice of your own data; a feed that is mostly Japanese will cost more per post than this blended sample suggests, and one that is mostly short English replies will cost less.

Once the model costs a few cents per 1,000 posts, the cost of getting the posts dominates. TwitterAPI.io charges 15 credits per tweet returned, which is $0.15 per 1,000 tweets ($1 = 100,000 credits), with a minimum of 15 credits per request. The official X API's pay-per-use rate card on docs.x.com/x-api/getting-started/pricing lists $0.005 per post read, which is $5.00 per 1,000 posts, roughly 33x more for the same read.

What the official card adds. X's pay-per-usage plan is capped at 3M post reads a month, with Enterprise above that; new developers get $20 in credits after saving a first card and buying credits, plus a match of the first auto-recharge up to $50. User reads are $0.010 each on that card, against $0.18 per 1,000 profiles on TwitterAPI.io.

No X account needed for reads. On TwitterAPI.io you sign up, get a key, and call endpoints such as /twitter/tweet/advanced_search with an X-API-Key header. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), which is enough to pull several thousand posts for a test like this one. Rate limits start at 0.2 requests per second before the first payment and rise to 20 once paid. Plan details are on the pricing page.

DeepSeek announces every model change on its X account first, which makes @deepseek_ai a useful feed to watch if you depend on the API. We pulled the account's timeline: the endpoint returned 69 posts spanning 2023 to 2026, 13 of them from 2026. Every one of them is authored by @deepseek_ai.

Flash posts draw the account's largest 2026 audiences. The 7 posts that mention Flash had a median of 7.2M views, against 2.2M for the account's other 6 posts of 2026. The DeepSeek-V4.1-Flash-1017 launch post reached 8.3M views and 37,210 likes; the V4 Flash official-API post reached 9.6M, the V4 Preview post 10.2M, and the V4 Pro launch 3.1M.

Why this matters for an API user. Price changes, retirements and model swaps behind an unchanged name were all announced on this account as well as in the API docs change log. A small watcher that polls /twitter/user/last_tweets for deepseek_ai and alerts on words like price, retired or model name is a cheap way to avoid finding out from a changed invoice. At the polling floor, a check every 5 minutes that usually finds nothing costs about $1.30 a month.

The full script at the end of this page does three things: pulls recent posts with /twitter/tweet/advanced_search (following has_next_page and next_cursor), sends each post to deepseek-flash with JSON Output and thinking disabled, and adds up the real usage numbers so you see your actual cost instead of our estimate.

Keep the system prompt identical. The cache matches prefixes, so put the fixed instructions first and the post text last. Any change to the system prompt (even a timestamp) turns every call back into a cache miss.

Disable thinking for labels. Send "thinking": {"type": "disabled"} and cap max_tokens. Turn thinking back on, with reasoning_effort set to low, high or max, only for tasks that need multi-step reasoning.

Batch when you can. If you want a digest rather than per-post labels, send 50 to 100 posts per call. In our model that cut the cost per 1,000 posts by roughly a third versus per-post labeling, and a 1M-token context leaves plenty of room.

Schedule bulk jobs off-peak. A backfill that can wait should run outside 01:00-04:00 and 06:00-10:00 UTC on weekdays; every token is half price.

Truncate long-form posts. The longest post in our sample was over 5,000 estimated tokens. Cutting the input at a few thousand characters keeps one outlier from costing as much as a hundred normal posts.

Question. How many tokens does a real X post contain, and what does it cost to classify or summarize 1,000 of them with deepseek-flash at DeepSeek's published rates, next to the cost of the data itself? Secondary: how does @deepseek_ai announce Flash models, and how much attention do those posts get?

Sources and query. An advanced search for posts containing "deepseek flash", "deepseek-flash", "deepseek v4" or "v4.1 flash", excluding reposts, sorted Latest; and the public timeline of the @deepseek_ai organization account via /twitter/user/last_tweets.

Window and sample. 1,000 search posts covering the most recent 26 hours at collection time (about 38 posts an hour), plus the 69 timeline posts the endpoint returned. Collected in 2026. The study used 55 requests and returned 1,069 tweets, which at 15 credits per tweet is 16,035 credits, or about $0.16.

Method. Characters were counted on the post text as returned. Tokens were estimated two ways, DeepSeek's documented character ratio and the cl100k_base tokenizer, because no DeepSeek key was available and nothing was sent to DeepSeek. Costs multiply those estimates by the rates on DeepSeek's Models & Pricing page under the stated job assumptions (non-thinking mode, fixed prompts, fixed output lengths).

What the sample cannot show. It is one topic over about one day, so its language mix and length distribution are specific to DeepSeek chatter; your feed will differ. The estimates are not DeepSeek's tokenizer output and ignore message-format overhead per request. Cache hit rates are best-effort on DeepSeek's side and may be lower than modeled. Timeline view counts are a snapshot and keep growing; the timeline endpoint did not return the account's full history.

Privacy. Aggregates only. Search posts come from private individuals: their raw pages were kept out of the repository, and the published sample holds only language, length, token estimates and engagement counts, with no IDs, text, links or handles. Only the @deepseek_ai organization account is named.