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. We covered how that peak-hour split changes a real bill when DeepSeek introduced it.

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.

We sent flat test images 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. We ran 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 our 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, which is the same trap GLM 5.3 sets with undocumented effort values.

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.io/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, our 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