DeepSeek V4 Flash Vision: Images Cap at 384 Tokens

DeepSeek shipped a vision variant of V4 Flash, and it costs exactly what the text model costs. Model ID deepseek-v4-flash-vision-exp, live on ofox as deepseek/deepseek-v4-flash-vision-exp.

Same 1M context, same 384K output ceiling, same 2500 concurrency, same price on every row of the pricing table. The interesting question is what an image actually costs once it becomes tokens, and the answer has a hard ceiling.

Model:        deepseek/deepseek-v4-flash-vision-exp
Price:        $0.44 in / $1.32 out per 1M at peak
              $0.22 / $0.66 off-peak (peak = 01:00-04:00, 06:00-10:00 UTC)
Cache hit:    $0.014 peak / $0.007 off-peak per 1M
Context:      1M in / 384K out
Images:       384 tokens max per image, 600 images per request
Thinking:     on by default at effort high, disable via thinking.type
Measured:     800x800 and 3000x3000 both cost 348 input tokens
Snapshot:     2026-08-21, n=5 per configuration

Last updated 2026-08-21. The model ID carries an -exp suffix, so treat its availability as experimental and re-check before building a dependency on it.

What Is DeepSeek V4 Flash Vision Exp?

V4 Flash with image input, priced identically. DeepSeek's pricing page puts the three models side by side, and the vision column matches the flash column cell for cell.

Off-peak rates are half the peak rates across the board. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, three hours plus four, which leaves seventeen hours a day at the lower rate.

One thing moves in the wrong direction. On the feature table, FIM completion reads "Non-thinking mode only" for V4 Flash and V4 Pro, and "Not supported" for the vision variant. Everything else carries over: JSON output, tool calls, the Responses API, the Anthropic-format API and chat prefix completion are all ticked.

How Much Does an Image Cost?

348 tokens for an 800x800 image, and the same 348 for a 3000x3000 one.

Every image is resized before inference. Images below roughly 384x384 total pixels are scaled up, larger images are scaled down, both preserving aspect ratio, and the target is a total pixel count near an 800x800 image. The documented consequence is a ceiling of 384 tokens per image, which is why a 2000x2000 photo and a 5000x5000 photo bill the same.

Test images sent through the ofox route on 2026-08-21, subtracting a 91-token text-only baseline measured on the same prompt:

Two things fall out of that table. The 800x800 and 3000x3000 rows are identical, which is the resize rule doing exactly what the documentation says. And the 6000x3000 row is cheaper than the square ones, because a 2:1 image that has been squeezed into the same total pixel budget tiles into fewer patches than a square one does.

At $0.44 per million input tokens, a thousand images cost about 15 cents at peak and half that off-peak. Image input on this model is not a line you need to model. What you do need to model is the next section.

Does Thinking Mode Change the Bill?

It costs 80 extra input tokens before the model has looked at anything. Thinking mode is on by default with effort set to high. Test results from running the same image and the same prompt five times per configuration:

The prompt_tokens figure did not vary once across ten calls: 439 with thinking on, 359 with it off, every single time. That 80-token gap is a template the API adds when thinking is enabled, and you pay input rate on it whether the model ends up reasoning or not.

On the output side the gap is wider and less predictable. With thinking on, the completion ranged from 68 to 425 tokens across five identical calls for a one-sentence image description. With it off, the same five calls returned 18 to 20 tokens. For "describe this image in one sentence", the reasoning is buying variance rather than accuracy.

Add it up at peak rates. Thinking on: 439 input plus 114 output is about $0.000343 per call. Thinking off: 359 plus 19 is about $0.000183. Nearly half the bill, on a task where the visible answer is the same either way.

Switch it off with either of these:

{"thinking": {"type": "disabled"}}
{"reasoning_effort": "none"}

Both worked on the test route, and both made the reasoning_tokens field disappear from the usage object rather than merely shrink. If you want thinking but cheaper, the effort mapping is worth reading first: DeepSeek maps low to low, max to max, and medium, high and xhigh all to high. Three of the five values you might send are the same setting.

How Do I Send an Image?

Standard OpenAI-compatible content blocks. Three transports are available: inline base64, an external URL, and a Files API file_id.

import base64
from openai import OpenAI

client = OpenAI(api_key="sk-...", base_url="https://api.ofox.ai/v1")

with open("chart.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode()

r = client.chat.completions.create(
    model="deepseek/deepseek-v4-flash-vision-exp",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What is the trend in this chart?"},
        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
    ]}],
    extra_body={"thinking": {"type": "disabled"}},
)
print(r.usage)

Calling DeepSeek directly, the base URL becomes https://api.deepseek.com and the model string drops its deepseek/ prefix. The Anthropic-format endpoint is https://api.deepseek.com/anthropic, and images travel as input_image parts on the Responses API.

Two restrictions that return HTTP 400 rather than degrading: images are accepted only in user messages, and only the vision model accepts them at all. Send an image to deepseek-v4-flash and you get "This model does not support image".

What Are the Limits?

The dimension rule is the one that bites in production. A batch job that sends fourteen screenshots at 6000 px works; the fifteenth one silently changes the ceiling for the whole request.

Should You Switch From V4 Flash?

If you send images at all, yes, because it costs nothing to. The rates are identical, the context and output ceilings are identical, and the concurrency limit is identical. The only thing you give up is FIM completion, which matters for inline code completion and nothing else.

For the wider picture on which multimodal endpoints do what, the multimodal API guide covers vision alongside speech, and the V4 Flash against Gemini 3.6 Flash cost comparison has the per-task math on the text side of the same model.

References

• DeepSeek: models and pricing
• DeepSeek: vision guide
• DeepSeek: thinking mode
• ofox model page: DeepSeek V4 Flash Vision Exp
• ofox model page: DeepSeek V4 Flash 0731

Frequently Asked Questions

What is DeepSeek V4 Flash Vision Exp?

It is a vision-capable variant of DeepSeek V4 Flash, model ID deepseek-v4-flash-vision-exp. It accepts images alongside text in user messages and bills them at the same rates as the text-only V4 Flash: $0.44 per million input tokens and $1.32 per million output at peak, half that off-peak. Context is 1M tokens with 384K maximum output, the same as V4 Flash.

How much does an image cost on DeepSeek V4 Flash Vision?

Very little. Images are resized before inference so that the total pixel count lands near an 800x800 image, which caps each image at 384 input tokens. Testing measured 348 tokens for both an 800x800 and a 3000x3000 image on the same route, which works out to $0.000153 per image at the peak input rate and half that off-peak. Prompt length, not image resolution, is what moves that number.

Is DeepSeek V4 Flash Vision more expensive than V4 Flash?

No. DeepSeek's pricing page prints identical numbers for deepseek-v4-flash and deepseek-v4-flash-vision-exp across every row: cache hit, cache miss and output, at both peak and off-peak. The concurrency limit is also the same 2500. The vision variant is the text model's price list with image input added.

Does DeepSeek V4 Flash Vision support thinking mode?

Yes, and it is on by default with effort set to high. Send thinking with type disabled, or reasoning_effort none, to turn it off. In testing, turning it off dropped the median completion from 114 tokens to 19 and the median call from 1.9 seconds to 1.0.

How many images can one request carry?

Up to 600. The per-request ceilings are 48 MiB of request body, 32 MiB per image sent as base64 or an external URL, 64 MiB per image via a Files API file_id, and 64 MiB of images in total without file_id references. Maximum dimension is 8192 pixels per side, dropping to 4096 once a request carries 15 or more images.

What image formats does DeepSeek V4 Flash Vision accept?

JPEG, PNG, GIF and WebP. The format is detected from the file content rather than the filename or the declared MIME type, so a mislabelled extension does not break the call. Images are accepted only in user messages: an image in a system or assistant message returns HTTP 400.

What does DeepSeek V4 Flash Vision give up compared to V4 Flash?

One line on the feature table. FIM completion, which V4 Flash supports in non-thinking mode, is listed as not supported on the vision variant. JSON output, tool calls, the Responses API, the Anthropic-format API and chat prefix completion all carry over unchanged.

Originally published on ofox.ai/blog.