DeepSeek V4 Flash Vision Exp is an experimental DeepSeek API model for requests that combine text with images. Its documented model ID is deepseek-v4-flash-vision-exp. It accepts JPEG, PNG, GIF, and WebP images and is available through DeepSeek’s OpenAI-compatible Chat Completions and Responses interfaces as well as its Anthropic-compatible interface. This guide explains the supported image-delivery methods, request limits, image-token rules, current pricing, and documentation-based cURL and Python patterns.
Start with the broader DeepSeek models guide if you are comparing families, or the DeepSeek V4 guide if you need the surrounding V4 context. For general authentication and endpoint setup, use the site’s DeepSeek API guide.
Verification and disclosure: this page was prepared from DeepSeek’s current official Vision, Models & Pricing, Files API, Responses API, and Anthropic API documentation reviewed on August 24, 2026. The examples below are documentation-based. No live paid inference request was sent for this article, so this page does not claim an observed answer, latency, token count, availability result, or benchmark.
Quick answer: what the model offers
The model is designed for image understanding rather than text-only requests. Image placement depends on the selected interface: Chat Completions accepts images in user messages; Responses accepts them in user or developer input and in supported tool-output blocks; Anthropic-compatible messages use an image source. DeepSeek labels the model experimental, so teams should evaluate it against their own screenshots, charts, photographs, and document images before depending on it in a production workflow.
| Item | Current documented value |
|---|---|
| Model ID | deepseek-v4-flash-vision-exp |
| Status | Experimental |
| Supported image formats | JPEG, PNG, GIF, and WebP |
| API surfaces | Chat Completions, Responses API, and Anthropic-compatible messages |
| Context length | 1 million tokens |
| Maximum output | 384,000 tokens |
| Listed concurrency limit | 2,500 |
| FIM Completion | Not supported |
| Maximum image-token charge | 384 input tokens per image after documented resizing |
The 1M context figure and 384K maximum output are model ceilings, not a recommendation to make every request large. Image count, total image bytes, request-body size, and image dimensions have separate limits. A valid application must satisfy all of them at the same time.
When to use Vision Exp
Vision Exp is relevant when the answer depends on visual evidence. Typical evaluation tasks include explaining a chart, describing a screenshot, reading visible labels, comparing several product photographs, or interpreting a diagram supplied by a user. The safest workflow gives the model a narrow question, provides only the images required for that question, and checks the returned statements against the original visual source.
- Screenshot review: ask for a concise description of the visible interface, message, or error.
- Chart interpretation: request the main trend, labels, and any uncertainty caused by unreadable details.
- Document-image extraction: supply rendered image pages and ask for structured notes that are checked against the source.
- Multi-image comparison: label the images in the prompt and specify exactly which attributes should be compared.
- Tool-assisted workflows: pass a screenshot produced by an approved application step, then validate the model’s interpretation before another action occurs.
Do not treat visual output as deterministic evidence. Small text, unusual layouts, low contrast, cropping, animation, or ambiguous visual relationships can change the result. Keep the original image available to the reviewer and require human confirmation when a mistake could affect a customer, payment, account, legal decision, medical decision, security action, or other consequential outcome.
Three supported ways to send images
DeepSeek’s official Vision guide documents three delivery methods: an inline Base64 data URL, an external HTTP or HTTPS URL, and an image uploaded through the Files API and referenced by file_id. The right choice depends on where the image lives, whether it will be reused, and which size limits apply.
| Method | Best fit | Main boundary |
|---|---|---|
| Base64 data URL | A local image included directly in one request | Counts toward the 48 MiB request body; a single inline image is limited to 32 MiB |
| External URL | An image already available at a reachable HTTP or HTTPS address | URL up to 8,192 characters, image up to 32 MiB, download within 60 seconds |
Files API file_id | A reusable image or one too large for the inline path | A referenced Files API image can be up to 64 MiB |
1. Base64 for a local image
Base64 is the most direct method when the application already has the image bytes. Encode the file, prepend the appropriate data-URL prefix, and place it in the image content block. Because encoding makes the request larger, check the final request body rather than only the original file size. The complete HTTP body must remain within 48 MiB, and the individual inline image must remain within 32 MiB.
2. External URL for a reachable image
An external URL avoids placing image bytes inside the request. The address must use HTTP or HTTPS, remain at or below 8,192 characters, point to an image no larger than 32 MiB, and complete its download within 60 seconds. Use a stable URL that DeepSeek can reach without an interactive sign-in. Do not place credentials, session tokens, or private customer information in the URL.
3. Files API for reuse or larger images
The Files API separates upload from inference. Upload the supported image, keep the returned file_id, and reference that identifier from a later Vision Exp request. The documented single-image limit rises to 64 MiB for a Files API reference. This method also avoids repeatedly embedding the same Base64 payload when several requests use one image.
File reuse is an application design choice, not permission to retain data indefinitely. Apply your own access, deletion, retention, and audit rules. Review the official Files API documentation before implementing upload lifecycle management.
Image detail controls
For URL-style image input, the optional detail value controls preprocessing. Choose it deliberately rather than copying a setting from an unrelated example.
| Detail value | Documented behavior | Practical use |
|---|---|---|
low | Downscales the image to 512 × 512 before inference | Broad scene or layout questions where fine text is not required |
high | Keeps the original image and is currently equivalent to original | Compatibility with clients that expose a high-detail choice |
original | Keeps the original image | Small labels, dense charts, screenshots, or fine visual details |
auto | Automatic selection and currently equivalent to original | A documented automatic option whose present behavior should not be assumed permanent |
A larger source image does not bypass the model’s token-resizing rules. Detail selection controls the input treatment described by the interface, while DeepSeek’s separate image-token process still resizes images for billing. Test the visual quality required by your workload and avoid transmitting resolution that adds privacy exposure without improving the answer.
Request, image, and dimension limits
Vision requests have overlapping limits. Validate them before sending the request so that an oversized image, excessive total bytes, or a dimension rule does not become an avoidable API error.
| Limit | Current documented value |
|---|---|
| Supported formats | JPEG, PNG, GIF, WebP |
| Request body | 48 MiB |
| External image URL | 8,192 characters |
| External URL download | Must complete within 60 seconds |
| Single Base64 or external-URL image | 32 MiB |
Single Files API file_id image | 64 MiB |
| Images per request | 600 |
Total image bytes without file_id | 64 MiB |
Total image bytes including file_id | Up to 200 MiB |
| Maximum image dimension | 8,192 pixels per side |
| Maximum dimension with 15 or more images | 4,096 pixels per side |
The 600-image ceiling is not a target batch size. Fifteen or more images already change the per-side dimension ceiling from 8,192 to 4,096 pixels. Large collections also increase prompt complexity and make it harder to identify which visual evidence supports an answer. Split work into focused requests when the task can be decomposed without losing essential context.
DeepSeek detects the image format from file content rather than trusting a filename or declared MIME type. Validate content on your own server as well. Renaming an unsupported payload to .png does not make it a PNG, and client-supplied metadata should not be treated as a security boundary.
Automatic resizing and image-token billing
DeepSeek converts every image into input tokens and bills those tokens together with the request’s text input. According to the official Vision guide, an image below roughly 384 × 384 pixels is scaled up while preserving its aspect ratio. A larger image is scaled down while preserving aspect ratio so that the final pixel count is roughly equivalent to an 800 × 800 image.
The resulting charge has an upper bound of 384 tokens per image. If a request contains several images, each image is counted independently under the same rule. A very large source file therefore does not create an unlimited image-token count, but it can still violate file-size or dimension limits before inference. The request’s text input and generated output remain separate parts of the total bill.
Do not estimate a complete request from the 384-token image ceiling alone. The prompt, system instructions supplied by the application, conversation context, multiple images, output length, and any repeated request can materially change usage. Use the API’s returned usage information for actual accounting and the site’s DeepSeek pricing guide for broader budgeting context.
Current Vision Exp API pricing
DeepSeek lists prices in U.S. dollars per one million tokens. Peak hours are 01:00–04:00 UTC and 06:00–10:00 UTC from Monday through Friday only. Every other time—including all weekend hours—uses the off-peak rates. Peak rates are twice the off-peak rates shown below.
| Rate period | Cache-hit input / 1M | Cache-miss input / 1M | Output / 1M |
|---|---|---|---|
| Off-peak | $0.007 | $0.22 | $0.66 |
| Peak | $0.014 | $0.44 | $1.32 |
Image tokens are input tokens. The applicable input rate still depends on whether DeepSeek reports them within cache-hit or cache-miss usage, while generated text uses the output rate. The official model table lists a 1M context length, a 384K maximum output, and a concurrency limit of 2,500 for Vision Exp. These are service limits, not a fixed cost per request.
Prices and limits can change. Confirm the official DeepSeek Models & Pricing page immediately before budgeting or deployment. The site’s DeepSeek API updates tracker can help readers find dated changes, but the official provider page remains the source of truth.
Chat Completions, Responses, and Anthropic formats
The same model ID is documented across three request formats, but both the image block and its allowed location differ. Use a user message for Chat Completions. Responses permits input_image in user or developer input and in function_call_output or custom_tool_call_output. Anthropic-compatible requests use an image source of Base64, URL, or file; document blocks are not supported.
| Interface | Base or endpoint | Image shape and location |
|---|---|---|
| OpenAI-compatible Chat Completions | https://api.deepseek.com/chat/completions | image_url for Base64 or URL, or a file block with file_id; images are allowed in user messages only |
| OpenAI-compatible Responses | https://api.deepseek.com/responses | input_image with an image URL, Base64 data URL, or file_id; allowed in user, developer, function_call_output, and custom_tool_call_output |
| Anthropic-compatible messages | https://api.deepseek.com/anthropic | An image block whose source is Base64, URL, or file; document blocks are not supported |
Do not copy an image block or role rule from one format into another without adapting it. Review DeepSeek’s official Responses API guide and Anthropic API guide for the current schemas. Vision Exp does not support FIM Completion, and Anthropic document content remains unsupported.
cURL example with an external image
This documentation-based example uses Chat Completions and a public image URL. Store the key in DEEPSEEK_API_KEY; do not paste a real key into the article, frontend JavaScript, screenshots, or a public repository.
curl https://api.deepseek.com/chat/completions \
-H "Authorization: Bearer $DEEPSEEK_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-v4-flash-vision-exp",
"messages": [
{
"role": "user",
"content": [
{
"type": "text",
"text": "Describe the chart and identify its main trend."
},
{
"type": "image_url",
"image_url": {
"url": "https://example.com/chart.png",
"detail": "original"
}
}
]
}
],
"max_tokens": 800
}'Replace the example URL with a reachable supported image. Set explicit application timeouts and validate both HTTP status and response structure. Because this article did not run the request, the block is presented as an official-documentation pattern, not a recorded pass.
Python example with a local Base64 image
The next example reads a local PNG, encodes it, and supplies a data URL. See the site’s DeepSeek Python SDK guide for environment and client setup beyond this focused image example.
import base64
import os
from pathlib import Path
from openai import OpenAI
client = OpenAI(
api_key=os.environ["DEEPSEEK_API_KEY"],
base_url="https://api.deepseek.com",
)
image_path = Path("screenshot.png")
image_base64 = base64.b64encode(image_path.read_bytes()).decode("utf-8")
response = client.chat.completions.create(
model="deepseek-v4-flash-vision-exp",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Summarize the visible information in this screenshot.",
},
{
"type": "image_url",
"image_url": {
"url": f"data:image/png;base64,{image_base64}",
"detail": "original",
},
},
],
}
],
max_tokens=800,
)
print(response.choices[0].message.content)The data-URL media type should match the actual file. Reject an unsupported or malformed upload before encoding it, and remember that the final encoded request counts toward the 48 MiB body limit.
Python example with the Files API
Use a file reference when an image will be reused or when the inline path is unsuitable. This example uploads one supported image and uses the returned identifier in a user message.
import os
from openai import OpenAI
client = OpenAI(
api_key=os.environ["DEEPSEEK_API_KEY"],
base_url="https://api.deepseek.com",
)
with open("diagram.png", "rb") as image_file:
uploaded = client.files.create(
file=image_file,
purpose="user_data",
)
response = client.chat.completions.create(
model="deepseek-v4-flash-vision-exp",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Explain the process shown in this diagram.",
},
{
"type": "file",
"file_id": uploaded.id,
},
],
}
],
)
print(response.choices[0].message.content)Keep file ownership and retention within the application’s approved data policy. A successful upload does not remove the need to validate the later inference request or the returned interpretation.
Production evaluation checklist
- Use the exact model ID. Send
deepseek-v4-flash-vision-expfor an image request and do not assume another model processes visual content. - Validate the real file. Check content, format, size, dimensions, and image count on the server before sending it.
- Choose one delivery method deliberately. Use Base64 for a bounded local image, a URL for a reachable public asset, or Files API for reuse and the larger documented file limit.
- Apply the interface-specific placement rule. Chat images belong in
usermessages; Responses also permitsdeveloperand supported tool-output blocks; Anthropic uses its own image-source shape. - Limit the question. Ask for the specific observation needed and require uncertainty to be stated when visual evidence is unreadable.
- Budget all usage. Account for text, every image, output, repeated calls, and the UTC pricing window.
- Test locally before release. Use fixed fixtures and expected properties; the site’s API testing guide covers a broader validation approach.
- Monitor provider state. Check the official documentation and the site’s DeepSeek status page before diagnosing an incident from one failed request.
- Control connected actions. If the vision result feeds an automation or integration, validate it before granting another step permission to act. Review the DeepSeek integrations guide for the surrounding architecture.
- Plan for change. The model is experimental. Recheck limits, pricing, request shapes, and FIM status before production changes.
Frequently asked questions
What is DeepSeek V4 Flash Vision Exp?
DeepSeek V4 Flash Vision Exp is an experimental DeepSeek API model for requests that combine text and images. Its model ID is deepseek-v4-flash-vision-exp, its documented context length is 1 million tokens, and its maximum output is 384,000 tokens.
Which image formats does it support?
It supports JPEG, PNG, GIF, and WebP. DeepSeek detects the format from the actual file content, so changing only a filename extension does not convert an unsupported payload into a supported image.
How can I send an image to the API?
You can send an inline Base64 data URL, provide a reachable external HTTP or HTTPS URL, or upload the image through the Files API and reference its file_id. In Chat Completions, keep images in a user message. Responses also allows image input in developer and supported tool-output blocks, while Anthropic-compatible messages use an image source of Base64, URL, or file; Anthropic document blocks remain unsupported.
How are images resized and billed?
DeepSeek scales small images up from roughly the 384 × 384 range and scales larger images down toward roughly an 800 × 800-equivalent pixel count while preserving aspect ratio. Each image is capped at 384 input tokens for billing, and multiple images are counted independently.
What are the main image and request limits?
The request body is limited to 48 MiB; a Base64 or external image to 32 MiB; and a Files API image to 64 MiB. A request can contain up to 600 images, with 64 MiB total image data without file_id or up to 200 MiB when file_id images are included. Dimensions are limited to 8,192 pixels per side, falling to 4,096 with 15 or more images.
Does it support Chat Completions, Responses, and Anthropic-compatible requests?
Yes. DeepSeek documents the model for OpenAI-compatible Chat Completions, the Responses API, and Anthropic-compatible messages. The image block differs across those interfaces, so follow the current official schema for the endpoint you use. FIM Completion is not supported.
Official sources and review boundary
- DeepSeek Vision guide
- DeepSeek Models & Pricing
- DeepSeek Files API guide
- DeepSeek Responses API guide
- DeepSeek Anthropic API guide
- DeepSeek API change log
Editorial review: August 24, 2026. This page reports the official documented contract and clearly labeled implementation guidance. It does not report a live paid request, independent performance result, benchmark, architecture specification, or open-weight release. Recheck DeepSeek’s official sources before making a production, security, or budget decision.