VynarisEarly betaGet your API key

Blog · 2026-09-10 · Vynaris Team

DeepSeek V4 Flash Vision caps images at 384 tokens: $0.08448 per 1,000 images before text and output

DeepSeek's experimental vision model caps images at 384 tokens, costing $0.08448 per 1,000 images off-peak. The cap is resolution-independent. Prompt caching does not apply to image tokens.

DeepSeek's experimental vision model, deepseek-v4-flash-vision-exp, charges a flat 384 visual tokens per image regardless of resolution. At off-peak rates, that is $0.08448 per 1,000 images before any text or output. Peak hours double it to $0.16896. Prices verified 2026-09-10.

The cap comes from the model's tokenizer: images are resized to roughly 800x800 pixels, and the resulting token count tops out at 384. A 2000x2000 image and a 5000x5000 image cost the same. The rate is DeepSeek V4 Flash's standard input token price: $0.22 per million off-peak, $0.44 peak.

TL;DR

Verdict table

Scenario                                        Off-peak / 1,000  Peak / 1,000  Image share of input
----------------------------------------------  ----------------  ------------  --------------------
Image only (384 tokens, no text, no output)     $0.08448          $0.16896      100%
Full request (1 image + 500 text in + 200 out)  $0.32648          $0.65296      43.4%
5 images + 500 text in + 200 out                $0.66440          $1.32880      79.3%

The full-request bill uses 884 input tokens (384 image + 500 text) and 200 output tokens. The derivation: (884 x $0.22 + 200 x $0.66) / 1,000,000 x 1,000 = $0.32648. Swap $0.22 for $0.44 and $0.66 for $1.32 to get the peak figure.

DeepSeek's pricing page and vision guide supply every rate and the 384-token cap. The Hacker News thread reached 498 points and 154 comments.

What 384 tokens buys (and does not)

The vision guide is explicit: images are "resized, preserving their aspect ratio, so that the total pixel count after resizing is roughly that of an 800x800 image." That gives a ceiling of 384 tokens. A 2000x2000 product photo, a 5000x5000 satellite image, and a 200x200 icon all consume the same 384 tokens after resizing.

The practical consequence: fine detail is lost. An HN commenter reported the model failing a simple analog-clock reading test that Gemini 3.7 Flash and GPT-5.6 Sol also failed. The failure mode is structural. At 800x800 equivalent, small text in screenshots, dense schematics, and fine grid patterns blur before the model ever sees them.

This is not a DeepSeek-specific limitation. OpenAI and Anthropic vision models apply similar resizing. The difference is that DeepSeek publishes the exact token ceiling, which lets you compute the cost before sending a single image.

The image bill in context

At $0.08448 per 1,000 images off-peak, image input is cheap. The bill grows when images are part of a larger request. In the full-request model above, the image contributes 43.4% of input tokens but the output tokens still cost more than the input. At 200 output tokens and $0.66/MTok off-peak, output is $0.000132 per request. The 884 input tokens cost $0.00019448.

For multi-image workflows, the picture changes. Five images produce 1,920 image tokens, which is 79.3% of the 2,420 total input. The image bill now dominates. At 10 images, images are 88.5% of input. At the 600-image request limit, images are 99.8% of input. The cost per token is the same for image and text input. DeepSeek does not charge a vision premium. The bill is purely token-volume-driven.

Peak hours and what they cost

Peak runs seven hours daily: 01:00 to 04:00 and 06:00 to 10:00 UTC. Every rate doubles. The image-only cost goes from $0.08448 to $0.16896 per 1,000. The full request goes from $0.32648 to $0.65296.

Our earlier DeepSeek V4 peak/off-peak price analysis showed that off-peak is still 77 to 83% more expensive than the pre-August-16 flat rate. The vision model inherits the same peak/off-peak structure that took effect on August 16, 2026.

If your image workload is batchable, schedule it in the 17 off-peak hours. If it is interactive (screenshot analysis, real-time OCR, agent vision), you eat the peak rate during seven hours of the day. Use the LLM cost calculator with your actual token shape to see the difference.

Cache hits do not help images

Prompt caching applies to text input, not image tokens. The vision guide treats each image as independently counted. If you send the same screenshot 1,000 times, each request incurs the full 384 tokens. There is no image cache.

This matters for computer-use agents that re-send screenshots on every step. Our browser-agent cost playbook models screenshot-driven vision at roughly 1,100 vision tokens per step. DeepSeek's 384-token cap is lower per image, but a 15-step task still sends 15 separate images, each billed at 384 tokens. That is 5,760 image tokens per task, or $0.001267 off-peak in image input alone.

Text prompt caching still works for the non-image portion of the request. A 2,000-token system prompt repeated across 15 steps can cache after the first call, cutting the text input bill. The images cannot.

Experimental model, real bills

The model name ends in -exp for a reason. DeepSeek labels it experimental, and the HN discussion shows why. Commenters report the model hallucinating image-reading capabilities it does not have, inventing text-based analysis tools when it cannot actually see images, and failing basic visual reasoning tests. One commenter noted that DeepSeek V4 Flash 0731 (the non-vision model) frequently assumed it had vision and "resorts to inventing text-based image analysis tools" when it finds it cannot see.

The pricing is not experimental. Every token is billed at production rates. The 384-token cap, the peak/off-peak split, and the $0.22/$0.66 off-peak rates are all live on the pricing page today.

DeepSeek's 17-provider price spread showed that third-party endpoints charge up to 2.2x more for the same DeepSeek model. The vision model is only available through DeepSeek's direct API, so there is no provider arbitrage yet.

Honest tradeoff

Do not build a production vision pipeline on an experimental model without a fallback. The 384-token cap means fine detail is structurally unavailable, and the -exp label means the model's behavior can change without notice. If your use case depends on reading small text in screenshots or distinguishing fine visual features, test it against your actual images before committing. The cost is low enough that testing is cheap. The quality is uncertain enough that production deployment is not.

FAQ

How much does one image cost with DeepSeek V4 Flash Vision?

$0.00008448 off-peak, $0.00016896 peak. Each image is capped at 384 tokens, billed at the standard input rate of $0.22/MTok off-peak or $0.44/MTok peak.

Does DeepSeek charge extra for vision?

No. Image tokens are billed at the same rate as text input tokens. The cost difference comes from token volume, not a vision premium.

Can I cache images to reduce cost?

No. Prompt caching applies to text input only. Each image is independently tokenized and billed on every request.

What is the maximum image size DeepSeek V4 Flash Vision accepts?

32 MiB per image (base64 or URL), 64 MiB via Files API. Maximum dimension is 8,192 pixels per side (4,096 with 15 or more images). But all images are resized to roughly 800x800 equivalent before tokenization, so larger images do not cost more.

How many images can I send per request?

Up to 600. Each image is counted independently at 384 tokens. A 600-image request produces 230,400 image tokens.

Is the model production-ready?

DeepSeek labels it experimental. The HN thread documents basic vision-reasoning failures. The pricing is production-rate. Test before deploying.