DeepSeek V4 Flash Vision Exp: Image Understanding at $0.22 per Million Tokens — the Practical Guide (2026)

Last updated: August 24, 2026 — every figure in this guide is taken directly from DeepSeek's official pricing and API documentation pages, verified on publication day.

On August 21, 2026, DeepSeek quietly added a third model to its V4 lineup: DeepSeek V4 Flash Vision Exp, the first model in the V4 family that accepts images alongside text. In plain terms: the budget model developers already knew as the cheapest capable text engine can now see. It can describe a photo, read text from a screenshot, and analyze charts — at the exact same input price as the text-only Flash tier: $0.22 per million tokens off-peak. This guide explains what actually changed, what it really costs, how to use it, and — just as important — when you should not build on it.

Source: official announcement post on X

What Is DeepSeek V4 Flash Vision Exp?

Until this release, the V4 generation was purely textual: two models — deepseek-v4-flash for speed and cost, and deepseek-v4-pro for higher performance. The new deepseek-v4-flash-vision-exp builds on the same Flash foundation and adds image input. The official documentation sums up its capabilities in three direct use cases: describing image content, reading text from screenshots, and analyzing charts and diagrams.

Pay attention to the Exp suffix: this is an explicitly experimental release, not a finished product tier. The official changelog describes it as "an experimental model that additionally accepts image input." That detail matters if you plan to build a product on top of it — we return to it in the honest-limitations section below.

Four formats are supported: JPEG, PNG, GIF, and WebP. Detection happens from the actual file content, not from the file name or the declared MIME type — so a mislabeled extension will not break your request as long as the underlying bytes are a valid image.

Source: DeepSeek API official documentation

The Official Price Table: What It Actually Costs

DeepSeek bills by peak and off-peak windows, with separate rates for tokens served from cache (cache hit) and fresh tokens (cache miss). Here are the official rates per million tokens across the three current models:

The practical takeaway: the new vision model is priced identically to the text-only flash tier and at one third of pro. Images you send are converted into tokens based on their dimensions and billed as input tokens together with your text — which means a single image typically costs you a fraction of a cent.

Peak Hours, Translated: When Do You Pay Half?

Here is a detail most coverage skips and you should not. DeepSeek defines peak hours as 01:00–04:00 and 06:00–10:00 UTC, Monday through Friday; everything else bills at half price.

Translated into common time zones: in Central European Time that is 03:00–06:00 and 08:00–12:00 on workdays; in India (UTC+5:30), 06:30–09:30 and 11:30–15:30; in New York (UTC-4), 21:00–00:00 and 02:00–06:00. What this means in practice: for most of Europe, the entire working afternoon and evening — plus the full weekend — runs at half price. For a developer in Lagos, São Paulo, or Jakarta batching jobs at night, the discount applies automatically.

A worked example: processing 500 images per month (~1,600 tokens per image after conversion, so 800K input tokens) plus 200K output tokens, all off-peak, costs (0.8 × $0.22) + (0.2 × $0.66) = roughly $0.31 per month. That is a rounding error for a side project and invisible inside a startup's budget.

How to Send Images: The Three Official Methods

The documentation defines three input paths. All of them use the standard OpenAI-compatible format (a content array of blocks instead of a plain string), and the same three methods carry over to the Responses API via input_image parts:

1. Base64-encoded inline — simplest for local files. The encoded data counts toward the 48 MiB request body limit.
2. External public URL — the model downloads the image itself. Constraints: URL up to 8,192 characters, image file up to 32 MiB, download completing within 60 seconds.
3. Files API — upload once, then reference the returned file_id in every request. Best when you reuse images; the size ceiling rises to 64 MiB and the 32 MiB per-image check does not apply.

This is the verbatim official example from the docs, using the OpenAI Python library:

import base64
from openai import OpenAI

client = OpenAI(
    api_key="<DeepSeek API Key>",
    base_url="https://api.deepseek.com"
)

with open("image.jpg", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[
        {"role": "user", "content": [
            {"type": "text", "text": "What is in this image?"},
            {"type": "image_url", "image_url": {"url": f"data:image/jpeg;base64,{b64}"}},
        ]}
    ],
)
print(response.choices[0].message.content)

The line that matters most is base_url="https://api.deepseek.com". You need no new SDK and no rewrite: any existing OpenAI-SDK project works by changing two lines — the base URL and the model name. If your code is built on the Anthropic library instead, the platform offers a dedicated compatibility endpoint at https://api.deepseek.com/anthropic.

Full Technical Specifications

Here is the model card as published on the official pricing page, next to its two siblings:

A one-million-token context means, in practice, that you can send dozens of images together with a long conversation history in one session without exhausting the window — a genuine advantage for document-analysis and invoice-processing pipelines. Tool-calls support means the model fits agent workflows, not just chat: DeepSeek also shipped a developer preview of its DeepSeek Harness tooling for agent-harness builders.

What This Means for You

For the independent developer: $0.22 per million input tokens and $0.66 per million output tokens off-peak makes this one of the cheapest vision-capable offers available today at a 1M-token context. For reference: Google's Gemini 3.7 Flash, released August 13, is being introduced at $0.75 input and $3.75 output per million tokens — meaning DeepSeek's vision tier is roughly 3.4× cheaper on input and about 5× cheaper on output than Google's promotional rate, which itself doubles after December 31, 2026.

For a student or researcher: a $5 credit covers thousands of requests, which removes budget as the blocker for experimenting with image understanding. If you need a completely free path that runs on your own machine, Qwen3.8-27B open-weights remains the strongest local option — though it is a text-first model.

For a business owner: dual compatibility with both OpenAI and Anthropic request formats eliminates migration cost. The 2500-request concurrency limit (five times pro's) leaves growth headroom without pre-negotiated upgrades. If you invoice customers from photos — receipts, delivery notes, forms — this price tier changes the unit economics of document automation.

For non-coders: this launch targets developers through an API — there is no "upload image" button in a DeepSeek chat app for this model. If you want AI tools without writing code, no-code builders such as the free Grok Build path are closer to what you need.

Quick Comparison: Which DeepSeek Model Fits Your Case?

Hands-On: Your First Request in Under Two Minutes

1. Create an API key on the DeepSeek platform (email signup; pre-paid balance billing).
2. Install the OpenAI library: pip install openai.
3. Paste the official example above, substituting your key and image path.
4. Try a practical prompt: "Read the table in this image and summarize it in three bullet points."

A cost-saving tip: if the same images repeat across requests, use the Files API rather than base64 — upload once, then pay only the reading tokens each time, instead of re-encoding the full image on every call. And of course, scheduling large batch jobs outside your local peak window (check the UTC conversion above) automatically lands you in half-price territory.

How Your Image Is Priced: Images Into Tokens

The most practical question newcomers ask: "How many tokens does my image cost?" The official mechanism is clear in principle: an image is converted into tokens based on its dimensions (width × height) and then billed together with your text input at the same rate. There is no special per-image fee and no separate charge for visual processing — everything flows through the single unified token meter.

Three direct saving tips follow from this mechanism:

1. Do not send more resolution than you need. A phone photo of a receipt at 4000 pixels converts into far more tokens than the same receipt resized to 1200 pixels while carrying identical information. Downscale your images when readable text is the goal.
2. Crop what does not matter. A full-screen screenshot containing one important button consumes more tokens than a tight crop of that button with its immediate context.
3. Exploit caching for repetition. If your system re-reads the same reference images (logos, templates, fixed forms), context caching drops the cost of repeated tokens to $0.007 per million off-peak — under a thirtieth of the fresh input rate ($0.22).

These small choices are the difference between a project spending dollars per month and one spending cents on the same workload.

Five Applications You Could Build This Week

The price point and the large context window open doors that used to belong to well-funded teams. Five realistic, no-hype ideas:

• Small-shop invoice archiving: send a photo of each invoice with a text instruction to extract (date, supplier, totals, tax) into a structured table. At 500 invoices a month you pay well under a dollar, as computed above.
• A lecture companion for students: upload slides as images and ask for summaries or revision cards — with a one-million-token context, a whole week of slides fits in one session.
• A chart reader for analysts: screenshots from dashboards become written readings of trends and key figures, useful for fast morning reports.
• Paper-form digitization: for small HR teams or clinics, a photographed form is extracted into structured JSON (officially supported) ready for import into any system.
• Accessibility improvements: automatic alt-text for product photos on e-commerce sites, or scene descriptions for educational content — the exact uses the official documentation names (describing images, reading text, analyzing charts) are the safest foundations to build on.

Every one of these ideas carries the same condition: test on a sample first. An experimental model deserves serious evaluation, not blind trust.

Honest Limitations to Know Before You Commit

• It is experimental, full stop. The Exp suffix is not cosmetic. The company may change the model or its behavior, and the documentation itself classifies it as experimental. Do not build a business-critical pipeline on it without a fallback plan.
• No published vision benchmarks. The official pages include no benchmark results for the vision model — not for English, and not for any other language. We advise running a 50–100 image sample of your real workload and measuring accuracy yourself before committing. And to be explicit: we cannot guarantee any specific accuracy reading text inside images in any language, because the company has published no such numbers.
• FIM is not supported on this model (it is available on the text sibling in non-thinking mode) — if your workflow depends on fill-in-the-middle code completion, it is not here.
• Image tokens count toward billing. A high-resolution image converts into a large number of tokens. Watch your image dimensions before sending them in bulk.
• Prices can change. The official pricing page states explicitly that the company reserves the right to adjust prices — the figures in this article were accurate on its publication date only.

Frequently Asked Questions

What is DeepSeek V4 Flash Vision Exp?

An experimental model launched by DeepSeek on August 21, 2026 — the first in the V4 family to accept images alongside text: describing image content, reading text from screenshots, and analyzing charts. It works through an OpenAI- and Anthropic-compatible API with a one-million-token context.

How much does DeepSeek V4 Flash Vision cost?

$0.22 per million input tokens (off-peak, cache miss) and $0.66 per million output tokens, doubling during peak hours (01:00–04:00 and 06:00–10:00 UTC on workdays). Images are billed as input tokens after conversion based on their dimensions.

What is the difference between deepseek-v4-flash and deepseek-v4-flash-vision-exp?

Pricing, context, and limits are nearly identical; the essential difference is that the vision version accepts image input. In theory you could use the vision model for everything, but the text version is the more stable choice since it is not experimental, and it supports FIM code completion.

Is there a free tier for DeepSeek V4 Flash Vision?

No free tier is announced for the API — the model runs on pre-paid pay-as-you-go billing. The effective cost is tiny (a few cents for thousands of requests), and if you need a genuinely free path, local open-weights models are the alternative.

When is DeepSeek half price?

At all times outside the two peak windows (01:00–04:00 and 06:00–10:00 UTC, Monday–Friday). Depending on your timezone this typically covers evenings, nights, and the entire weekend.

Can DeepSeek V4 Flash Vision read non-English text in images?

The official documentation mentions reading text from screenshots without specifying languages and publishes no per-language vision benchmarks. The model is multilingual for text, but no specific accuracy can be guaranteed for any language inside images in the absence of official numbers — test it on a sample of your real images before relying on it.

Sources

• Official Vision guide — DeepSeek API docs
• Official Models & Pricing page — DeepSeek
• Official changelog — DeepSeek
• Official announcement post — DeepSeek on X