DeepSeek has added image input to its API with deepseek-v4-flash-vision-exp, an experimental vision model built for text-and-image workflows.
The important part is not simply that it can describe a picture. The model is available through DeepSeek's OpenAI-compatible Chat Completions and Responses APIs, and its Anthropic-compatible Messages endpoint. It can be used inside workflows that already process screenshots, charts, documents, and visual state.
By zipflowxyz
This is an independent technical analysis based on DeepSeek's public documentation and publicly available coverage. At the time of writing, the upstream channel used by our team does not yet expose this vision model, so the examples below are documentation-based rather than hands-on results through that channel. Verify availability, limits, and pricing against the official documentation before deploying.
This article focuses on the API details that matter when moving from a demo to a real application.
What independent coverage tested
The most useful public hands-on report I found is QbitAI's Chinese-language test published by Tencent News on August 22, 2026:
The report describes tests of screenshot and image understanding, web-search-assisted identification, and agent workflows using DeepSeek Harness. It reports that simple visual questions were answered in a few seconds, while tasks requiring repeated web searches were slower; it also notes that counting fingers remained unreliable in its test. These are the author's observations, not an independent benchmark or a guarantee of production behavior.
The page is an article with embedded test material rather than a clearly identified standalone video review. I did not find a reliably verifiable English-language YouTube review during this search, so this article does not present an unverified video as evidence.
What the model supports
According to DeepSeek's current API documentation, deepseek-v4-flash-vision-exp accepts images alongside text. Typical tasks include:
- Reading text from screenshots
- Describing or classifying images
- Extracting information from charts
- Inspecting product or application interfaces
- Feeding visual observations into an agent workflow
The model is currently marked experimental. That makes it useful for prototyping, but production teams should keep a fallback model and monitor response quality before routing critical workloads through it.
Supported image formats are JPEG, PNG, GIF, and WebP. Images are accepted in user messages in the standard Chat Completions examples; placing them in system or assistant messages returns an error. The Responses API has additional documented input contexts, so check its input schema when using developer messages or tool outputs.
Three ways to send an image
The OpenAI-compatible endpoint is:
https://api.deepseek.com
1. Public image URL
For a publicly accessible image, send an image_url content block:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com",
)
response = client.chat.completions.create(
model="deepseek-v4-flash-vision-exp",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Describe the chart and call out the largest change."},
{
"type": "image_url",
"image_url": {
"url": "https://example.com/chart.png",
"detail": "high",
},
},
],
}
],
)
print(response.choices[0].message.content)
The external URL must be no longer than 8,192 characters. The image download must finish within 60 seconds, and the image may be at most 32 MiB when supplied this way.
2. Base64 data URL
For local files, an inline data URL is straightforward:
import base64
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com",
)
with open("screenshot.jpg", "rb") as image_file:
encoded = base64.b64encode(image_file.read()).decode("utf-8")
response = client.chat.completions.create(
model="deepseek-v4-flash-vision-exp",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Extract the visible error message."},
{
"type": "image_url",
"image_url": {
"url": f"data:image/jpeg;base64,{encoded}",
},
},
],
}
],
)
print(response.choices[0].message.content)
Base64 data URLs (and inline file_data) count toward the 48 MiB request-body limit. Base64 is convenient for one-off local requests, but it is usually not the best choice for a high-volume pipeline because it increases payload size.
3. Files API references
If the same image is reused, upload it once and reference its file_id:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com",
)
with open("invoice.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": "List the invoice number and total amount."},
{"type": "file", "file_id": uploaded.id},
],
}
],
)
print(response.choices[0].message.content)
The Files API is a better fit when an image is reused across requests or is too large for an inline payload. Use the returned DeepSeek file ID (in the documented file-api-... form); do not assume an arbitrary file ID from another provider is interchangeable. A file referenced by file_id may be up to 64 MiB.
Choosing the detail level
For image_url inputs, DeepSeek documents four detail values:
-
low: downscales the image to 512×512 before inference; useful when speed and cost matter more than fine detail -
high: keeps the original image; currently equivalent tooriginal -
original: keeps the original image -
auto: automatic selection; currently equivalent tooriginal
A practical routing policy is to use low for coarse classification and original for screenshots, small text, and charts. high is currently equivalent to original, while auto is currently equivalent to original. This is a quality-versus-cost trade-off, so it is worth measuring on your own image set instead of applying one setting everywhere.
Token usage and limits
Images are converted into tokens based on their dimensions and billed together with text tokens. Before inference, images are resized while preserving their aspect ratio. DeepSeek's documentation describes an upper bound of 384 tokens per image after resizing.
The main limits currently documented are:
| Limit | Value |
|---|---|
| Supported formats | JPEG, PNG, GIF, WebP |
| Maximum images per request | 600 |
| Maximum image dimension | 8,192 px per side |
| Maximum external/base64 image size | 32 MiB |
| Maximum Files API image size | 64 MiB |
| Request body limit | 48 MiB |
| Maximum total image size | 64 MiB without file references; up to 200 MiB when file references are included |
When a request contains 15 or more images, the documented maximum dimension drops to 4,096 pixels per side.
The 384-token ceiling is useful for rough budgeting, but it should not be mistaken for a guarantee that every image has identical cost. The actual conversion depends on dimensions and resizing behavior. For accurate estimates, use the token calculator linked in DeepSeek's documentation and log usage in your application.
Responses API and Anthropic compatibility
The same vision model is also available through DeepSeek's Responses API. The content block changes from image_url to input_image:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_DEEPSEEK_API_KEY",
base_url="https://api.deepseek.com",
)
response = client.responses.create(
model="deepseek-v4-flash-vision-exp",
input=[
{
"role": "user",
"content": [
{"type": "input_text", "text": "What changed between these screenshots?"},
{
"type": "input_image",
"image_url": "https://example.com/after.png",
"detail": "low",
},
],
}
],
)
print(response.output_text)
DeepSeek also documents an Anthropic-compatible /messages endpoint at:
https://api.deepseek.com/anthropic
This is useful if an existing application already uses Anthropic's message schema. The important engineering lesson is to keep the image-ingestion layer separate from the model adapter: then you can switch between Chat Completions, Responses, and Anthropic formats without rewriting the rest of the pipeline.
A production checklist
Before using the model in a larger visual workflow, test these cases explicitly:
- Small text: receipts, screenshots, and dense UI labels
- Charts: axes, legends, units, and missing-data interpretation
- Repeated images: whether Files API reuse simplifies your request path
- Low versus original detail: quality and latency on your own samples
- Malformed inputs: unsupported formats, oversized files, and inaccessible URLs
- Fallback behavior: what happens if the experimental model is unavailable
- Observability: prompt size, image dimensions, latency, errors, and token usage
For agent systems, add a confirmation step before allowing visual observations to trigger irreversible actions. A model can correctly read an interface and still misunderstand the intent of a button or the state of an application.
Final take
DeepSeek's vision release is interesting because it adds image understanding without requiring developers to abandon familiar API patterns. URL, base64, and file-reference inputs cover most ingestion paths, while Responses API and Anthropic compatibility make integration easier for existing agent stacks.
The model's experimental status is the main caveat. Treat the first release as an opportunity to build and benchmark, not as a reason to remove safeguards. Start with observable, reversible workflows; measure accuracy and cost; then expand into more autonomous visual agents.
Sources
Availability note: ZipFlow's upstream channel did not yet expose
deepseek-v4-flash-vision-expat the time of writing. This article does not claim that ZipFlow has successfully served or benchmarked the model.
Top comments (0)