DeepSeek V4 Flash Vision

deepseek-v4-flash-vision-exp is DeepSeek’s experimental vision model, built on the V4 Flash base with image input added: describe pictures, read text out of screenshots, read chart values, compare multiple images. Everything on the text side (1M context, thinking mode, function calling, context caching) is retained, and pricing is identical to the text-only V4 Flash —— vision costs no premium; images are converted to input tokens by their dimensions. APIYI has completed 124 test cases across roughly 1,100 calls, covering three image-input channels, four image formats, two protocols and two groups.

Read this before you call: this model is served by two groups on APIYI with different capabilities. Pick the group that matches your protocol.

Protocol you use	Group your key must be in
OpenAI format (`/v1/chat/completions`, `/v1/responses`)	`default`
Anthropic format (`/v1/messages`, incl. Claude Code and similar clients)	`ClaudeCode`

Picking the wrong group does not raise a “wrong group” error. It shows up as parameters silently doing nothing, a 400 on the second turn, or /v1/responses complaining about messages. Both groups are priced identically —— the group affects capability only, never billing. See “Choosing a group” below.

Highlights

No vision premium

Same price as text-only V4 Flash: $0.44 input, $1.32 output per 1M tokens. Images become input tokens, capped at 384 per image.

Solid recognition in testing

Screenshot OCR values all correct, 5-bar chart read 5/5, counting a specific shape among 36 shapes 24/24. No hallucination on negative questions.

No need to pre-compress

2000×2000 and 4000×4000 convert to exactly the same token count (346). Upstream rescales for you —— compressing only saves bandwidth, not money.

Both protocols work

OpenAI format (chat/completions + responses) and Anthropic format (/v1/messages) are both verified, each through its own group.

Model information

Field	Value
Model name	`deepseek-v4-flash-vision-exp`
Model version	DeepSeek-V4-Flash-Vision-Exp (experimental)
Context window	1M (measured hard ceiling 1,048,576 tokens, with `max_tokens` counted inside it)
Max output	384K (measured hard limit 393,216; beyond it returns `valid range of max_tokens is [1, 393216]`)
Available groups	`default`, `ClaudeCode`, `svip`
Endpoints	`POST /v1/chat/completions`, `POST /v1/responses`, `POST /v1/messages`
Image input	✅ JPEG / PNG / GIF / WebP
Thinking mode	On by default, can be disabled (the working syntax depends on the group, see below)
Streaming	✅ on all three endpoints
Function calling / tool use	✅ including incremental streaming assembly
JSON output	✅ `json_object`; ❌ `json_schema` (not enabled upstream)
Pricing	$0.44 input, $1.32 output, $0.014 cache hit, per 1M tokens

Since 2026-08-17 the vendor bills this model in two tiers by time of day (peak hours are 01:00-04:00 and 06:00-10:00 (UTC)). APIYI charges the peak rate at all times, so your cost never varies by the hour.

Choosing a group

The two groups on APIYI route to different upstream endpoints, so their capabilities are not equivalent. The table below is measured on 2026-08-21, three repetitions per cell:

Capability	`default` group	`ClaudeCode` group
`/v1/chat/completions` with image	✅	✅
`/v1/responses` with image	✅	❌ 400 every time
`/v1/messages` with image	⚠️ requires an explicit `top_p`, and multi-turn 400s	✅ fully working
`detail` token savings	✅ effective	❌ ignored
Disabling thinking (OpenAI format)	✅ effective	❌ ignored
`logprobs`	✅ populated	❌ returns empty
`reasoning_tokens` in usage	✅ present	❌ whole field missing
Image via public URL (Anthropic format)	❌	✅

OpenAI format → use the `default` group

Create a token with group default, then:

from openai import OpenAI

client = OpenAI(
    api_key="sk-your-apiyi-key",          # a token in the default group
    base_url="https://api.apiyi.com/v1",
)

Anthropic format → use the `ClaudeCode` group

Create a token with group ClaudeCode, then:

import anthropic

client = anthropic.Anthropic(
    api_key="sk-your-apiyi-key",          # a token in the ClaudeCode group
    base_url="https://api.apiyi.com",
)

One account can hold several tokens in different groups at once and they do not interfere —— keeping one per protocol is the recommended setup. See What are groups and Tokens and groups for how to create them, and Codex vs ClaudeCode vs Default groups for how the three differ.

Never use the default group for the Anthropic format. Two problems stack up there:

Omitting top_p returns 400 Invalid top_p value every time
Even with top_p supplied, replaying the first turn’s thinking block into the second turn returns unknown variant 'thinking' —— and standard clients such as Claude Code and the Anthropic SDK always replay it, so multi-turn always breaks

Switch to the ClaudeCode group and neither problem exists; the full tool-call round trip works as well.

Three ways to send an image

1. Inline base64 (most common)

import base64

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

resp = 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}"}},
        ],
    }],
    max_tokens=2000,
)
print(resp.choices[0].message.content)

2. Public image URL

resp = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Describe this image."},
            {"type": "image_url",
             "image_url": {"url": "https://example.com/image.jpg"}},
        ],
    }],
    max_tokens=2000,
)

The URL may be at most 8192 characters and the download must finish within 60 seconds. A dead link returns Failed to download image.

3. A `file` content block (equivalent to inline base64)

{
  "type": "file",
  "file_data": "data:image/jpeg;base64,<BASE64>",
  "filename": "image.jpg"
}

Measured token cost is identical to the image_url channel (303 for the same image either way).

The Files API (upload to /v1/files, then reference by file_id) is not available on APIYI, which is the norm for third-party gateways. The two allowances the vendor reserves for file_id —— 64 MiB per image and 200 MiB per request —— are therefore out of reach.The limits that actually apply are 32 MiB per image and 48 MiB per request body. Exceeding them returns image file size exceeds limit 32 MB.

How images are billed

An image is converted to input tokens based on its post-resize dimensions, and billed together with your text tokens at $0.44 / 1M. The numbers below are measured on APIYI using a fixed prompt and subtracting the text-only baseline:

Image size	Tokens	Cost per image	Per 1,000 images
64×64	114	$0.00005	$0.05
384×384	114	$0.00005	$0.05
800×800	346	$0.000152	$0.15
2000×2000	346	$0.000152	$0.15
4000×4000	346	$0.000152	$0.15
1600×1200	354	$0.000156	$0.16
1600×1200 with `detail: "low"`	142	$0.0000625	$0.06

Three rules, matching the vendor’s description exactly:

384 tokens per image is a hard ceiling. The largest value measured was 354; no image exceeds it
Large images are scaled down to roughly an 800×800 equivalent. That is why 2000² and 4000² cost the same, and why pre-compressing before upload saves bandwidth but not money
Images below 384×384 are scaled up. So 64×64 costs the same as 384×384 —— no need to shrink small images further

The token saver: `detail: "low"`

When fine detail does not matter (identifying an image type, recognising the subject, rough classification), add detail: "low" to downscale the image to 512×512 before inference:

{
  "type": "image_url",
  "image_url": {"url": "https://example.com/image.jpg", "detail": "low"}
}

All four levels, measured on the same 1600×1200 image:

`detail`	Tokens	vs. default
`low`	142	-60%
`high`	354	same
`original`	354	baseline
`auto`	354	same

detail only takes effect when both conditions hold: it is set on an image_url block (on a file block it is silently ignored), and your token is in the default group (it does nothing in the ClaudeCode group).An invalid value fails loudly: unknown variant 'ultra', expected one of 'low', 'high', 'original', 'auto'.

Controlling thinking mode

Thinking mode is on by default, and the thinking text counts against your max_tokens budget. For pure image-reading tasks, turn it off: with thinking disabled our tests scored 24/24, ran faster, saved the entire thinking output, and cut 80 input tokens as well (the thinking system prompt costs exactly that much). Every syntax, three runs each:

Syntax	chat, `default` group	chat, `ClaudeCode` group	`/v1/messages`
`thinking: {"type": "disabled"}`	✅	❌	✅ both groups
`reasoning_effort: "none"`	✅	❌	—
`reasoning_effort: "low"`	⚠️ thinking stays on, only the system prompt gets shorter	❌	—
`reasoning: {"effort": "none"}`	❌	❌	—
`enable_thinking: false`	❌	❌	—

resp = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[...],
    max_tokens=2000,
    extra_body={"thinking": {"type": "disabled"}},   # works in the default group
)

Do not set max_tokens too low. With thinking on, even a one-line question can emit several hundred tokens of thinking first; too small a budget yields finish_reason: "length" with an empty content —— which looks like the model failed to answer. Use 2000 or more with thinking on, or simply disable thinking.

Context caching

Caching needs no parameters: a repeated long prefix hits automatically, and the hit portion is billed at $0.014 / 1M. But requests containing images differ from text-only ones in two ways:

	Text-only request	Request with an image
First hit occurs on call	2nd	3rd
The image’s own tokens	—	never cached

Measured with a 2304-token text prefix plus one 800×800 image:

Call	prompt_tokens	Hit	Miss
1	2675	0	2675
2	2675	0	2675
3	2675	2304	371
4	2675	2304	371

The hit is exactly the text that sits before the image; the image and everything after it is charged at full price every time. So put your fixed long instructions ahead of the image to get them cached —— anything placed after the image can never hit.

In the Anthropic format these fields are named cache_read_input_tokens and cache_creation_input_tokens, and behave the same way. Note that explicit cache_control markers have no effect (upstream uses automatic prefix caching), and that the two protocols report usage differently: OpenAI’s prompt_tokens is always the full count, while Anthropic’s input_tokens drops to the uncached remainder after a hit —— the two cannot be reconciled directly.

Supported image formats

Format	Supported	Note
JPEG	✅
PNG	✅
GIF	✅	Animated GIFs are read as the first frame only, and billed as one frame
WebP	✅
BMP / TIFF / SVG	❌	Returns `You have uploaded an unsupported image`

All four supported formats convert to identical token counts, so the container never affects cost.

The format is detected from file content, not from the MIME type you declare. In testing, a PNG declared as image/jpeg worked fine —— a wrong extension or wrong MIME does not matter as long as the file itself is one of the four supported formats.

Verified capability matrix

Measured by APIYI on 2026-08-21:

Capability	Vendor claim	Measured (`default` group)
Inline base64 image	✅	✅
Public URL image	✅	✅
`file` block with `file_data`	✅	✅
`file_id` (Files API)	✅	❌ the platform does not offer a Files API
Multiple images per request	up to 600	✅ 20 images verified, order and content all correct
Image plus multi-turn context	✅	✅
Image plus function calling	✅	✅ including streaming increments
Image plus JSON output	✅	✅ `json_object`
Structured output `json_schema`	—	❌ upstream returns `This response_format type is unavailable now`
Streaming	✅	✅ on all three endpoints
`logprobs` / `temperature` / `top_p` / `stop` / `seed`	✅	✅
Responses `previous_response_id` chaining	✅	❌ silently ineffective (no error, but no context). Build the full `input` yourself

Accuracy spot checks

Task	Result
OCR of a 6-line mixed alphanumeric screenshot	Order ID, amount and email all correct
Reading a 5-bar chart	5/5 correct, title included
Counting a specific shape in a 6×6 grid (36 shapes)	24/24 correct
Spotting the difference between two images	Correct
Label recognition across 10 and 20 images in order	All correct
Negative question (something absent from the image)	Correctly denied, no hallucination

Limits and common errors

Limit	Value	Error when exceeded
Single image	32 MiB	`image file size exceeds limit 32 MB`
Request body	48 MiB	—
URL length	8192 characters	`external link length … too long, max link length 8192`
Images per request	600 per the vendor	—
`max_tokens`	393,216	`valid range of max_tokens is [1, 393216]`
`top_logprobs`	0–20	`valid range of top_logprobs is [0, 20]`
Context	1,048,576	`This model's maximum context length is 1048576 tokens`

The 1,048,576 context ceiling is measured, and the error message shows that max_tokens counts against that same total (… in the messages, … in the completion). When packing a long context, leave room for your output budget or you will hit the ceiling.

Other common 400s:

You have uploaded an unsupported image —— format is not one of the four, or the base64 is corrupt
Failed to download image —— the URL is unreachable or took over 60 seconds
Image in assistant message is unsupported —— images may only appear in user messages

In testing, roughly 1%-3% of requests had their connection silently closed (surfacing to the client as an SSL EOF or a handshake timeout). This is unrelated to images and unrelated to the group —— it is an occasional transport-level event. Always set a read timeout and retry, otherwise a single request can hang for over two minutes. See Timeout configuration.

Full examples

OpenAI format (`default` group)

import base64
from openai import OpenAI

client = OpenAI(
    api_key="sk-your-apiyi-key",       # default group
    base_url="https://api.apiyi.com/v1",
)

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

resp = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Read the five bar values in this chart. Numbers only."},
            {"type": "image_url",
             "image_url": {"url": f"data:image/png;base64,{b64}", "detail": "original"}},
        ],
    }],
    max_tokens=2000,
    extra_body={"thinking": {"type": "disabled"}},
)
print(resp.choices[0].message.content)
print(resp.usage)

Anthropic format (`ClaudeCode` group)

import base64
import anthropic

client = anthropic.Anthropic(
    api_key="sk-your-apiyi-key",       # ClaudeCode group
    base_url="https://api.apiyi.com",
)

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

msg = client.messages.create(
    model="deepseek-v4-flash-vision-exp",
    max_tokens=2000,
    thinking={"type": "disabled"},
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Read the five bar values in this chart. Numbers only."},
            {"type": "image", "source": {
                "type": "base64", "media_type": "image/png", "data": b64}},
        ],
    }],
)
print(msg.content)

Vision Understanding API

General calling patterns and comparisons across vision models