DeepSeek Vision: How to Use Image Input with DeepSeek

Last reviewed: October 9, 2026

DeepSeek Vision is best understood as DeepSeek’s current image-input capability in the API, served through deepseek-flash, also known as DeepSeek-V4.1-Flash. It lets you send images with text prompts so the model can describe pictures, read text from screenshots, analyze charts, inspect UI images, and perform OCR-like extraction. It is not a separate model name you should call directly.

For new API code, use deepseek-flash for image input. DeepSeek’s change log says the older V4 Flash and V4 Flash Vision Exp models are retired, while deepseek-v4-flash and deepseek-v4-flash-vision-exp temporarily route to V4.1 Flash for compatibility. An accepted legacy name does not mean the retired model is still being served.

The current model list also matters: deepseek-flash supports text and image input, while deepseek-v4-pro is listed as text-only. That means deepseek-v4-pro should not be used for Vision requests unless DeepSeek changes the official model table in the future. DeepSeek Lists Models API

This guide covers Base64, external URLs, uploaded image IDs, detail settings, image limits, and billing. It also separates Chat Completions, Responses, and Anthropic-compatible request formats: their message roles and image blocks are not interchangeable.

DeepSeek Vision at a glance

What is DeepSeek Vision?

DeepSeek Vision is the practical name developers use for DeepSeek’s image-input API capability. In official docs, the actual model ID to use is deepseek-flash. With this model, you can combine text and images in one request and ask for visual understanding, OCR-like extraction, chart analysis, document triage, UI inspection, and image comparison. DeepSeek Vision guide

Do not confuse “Vision” with a standalone model name. You do not call deepseek-vision. You call deepseek-flash through the DeepSeek API and provide image content in the required request shape. For creating images rather than analyzing them, see whether DeepSeek can generate images.

Which DeepSeek model supports image input?

The current model table lists deepseek-flash as DeepSeek-V4.1-Flash with input modalities of text and image. It lists deepseek-v4-pro with input modality text only. DeepSeek Lists Models API

What happened to deepseek-v4-flash-vision-exp?

deepseek-v4-flash-vision-exp was an experimental image-input route. The Vision guide and change log say its name is still accepted for compatibility, but requests are served by the newer Flash model. Updating the model ID does not remove the need to use the correct image format for your endpoint.

The practical migration is simple:

What can DeepSeek Vision do?

DeepSeek Vision is useful when your task needs the model to inspect visual content. Common use cases include:

• Describe a photo or product image.
• Read visible text from a screenshot.
• Extract table text from an image.
• Analyze a chart, graph, or slide.
• Read labels from diagrams or UI screenshots.
• Extract fields from a receipt, invoice, or form.
• Compare two images and list visible differences.
• Ask whether a scanned page is legible enough for data extraction.

For OCR-like tasks, treat the output as model-generated extraction, not a guaranteed transcript. Tables, small text, handwriting, low-contrast scans, rotated pages, dense charts, legal clauses, medical images, and financial records should be reviewed against the source image.

Choose the message role and image format for your API

For a direct image question, user is the consistent starting point across these examples. The surrounding payload must still match the endpoint.

Sources: Chat Completions schema, Responses schema, and Anthropic-format image examples. Changing only role does not convert one API format into another. DeepSeek’s acceptance of developer in Responses does not give it a separate, higher-priority instruction role.

Images returned by tools are a separate path

At this review, DeepSeek’s documentation is not fully consistent: the Vision guide’s Restrictions section says images are supported only in user messages, while the Chat Completions schema also permits image/file content in a tool message with a matching tool_call_id. Keep direct uploads in user; test the documented tool-result path separately rather than asserting that all image-bearing messages must be user messages. Vision restrictions; tool-message schema.

Responses explicitly documents input_image inside function_call_output and supported custom_tool_call_output items. These are tool outputs with call-ID pairing, not a reason to use developer in Chat Completions. See Responses image input.

How to send images with Chat Completions

For client.chat.completions.create(), use https://api.deepseek.com, model="deepseek-flash", and a user message whose content is a list of blocks. Put the image URL inside an image_url object; do not use the flat Responses input_image shape. Chat Completions reference.

Install the OpenAI Python SDK and set a DeepSeek API key in the terminal running your script. The SDK is the client; DeepSeek receives and bills the requests.

python -m pip install openai

On macOS or Linux:

export DEEPSEEK_API_KEY="YOUR_DEEPSEEK_API_KEY"

On Windows PowerShell:

$env:DEEPSEEK_API_KEY = "YOUR_DEEPSEEK_API_KEY"

Use a real JPEG named screenshot.jpg for the local examples. Match the MIME type when using another format. The examples disable thinking and use a 2,048-token output budget to keep the first request bounded; these are demonstration settings, not image limits or guarantees of complete extraction. For Chat Completions, the OpenAI Python SDK sends the DeepSeek-specific thinking field through extra_body; the other SDK examples use their own request controls. Request options.

Base64 image example in Python

Use Base64 when the image is local and small enough to fit inside the request body limit.

import base64
import os
from pathlib import Path
from openai import OpenAI

image_path = Path("screenshot.jpg")
image_b64 = base64.b64encode(image_path.read_bytes()).decode("ascii")

with OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
) as client:
    response = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Read the visible text. Preserve line breaks and mark unreadable text as unclear."},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{image_b64}",
                        "detail": "original",
                    },
                },
            ],
        }],
        max_tokens=2048,
        extra_body={"thinking": {"type": "disabled"}},
    )

if not response.choices:
    raise RuntimeError("No response choice was returned.")
choice = response.choices[0]
if choice.finish_reason != "stop" or not choice.message.content:
    raise RuntimeError("No complete text answer; inspect the finish reason before using it.")
print(choice.message.content)

External image URL example

Use a reachable HTTP(S) URL for an image already approved for external access. DeepSeek documents a maximum URL length of 8,192 characters and a download timeout of 60 seconds. Replace the placeholder below with an actual image URL; example.com/chart.png is not a working sample image. Do not publish confidential images just to make a URL fetch work. External-image requirements.

import os
from openai import OpenAI

image_url = "https://example.com/chart.png"  # Replace with your real image URL.
if image_url == "https://example.com/chart.png":
    raise ValueError("Replace the placeholder with a reachable image URL.")

with OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
) as client:
    response = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Read the chart title, axes, legend, and labeled values. Do not invent unlabeled values."},
                {"type": "image_url", "image_url": {"url": image_url, "detail": "original"}},
            ],
        }],
        max_tokens=2048,
        extra_body={"thinking": {"type": "disabled"}},
    )

if not response.choices:
    raise RuntimeError("No response choice was returned.")
choice = response.choices[0]
if choice.finish_reason != "stop" or not choice.message.content:
    raise RuntimeError("No complete text answer was returned.")
print(choice.message.content)

Files API file_id example

Use the Files API when the same image will be reused across multiple requests, when an inline Base64 request would exceed the request body limit, or when the image is larger than the inline/external image limit. DeepSeek’s Vision guide says Files API image references can be used through a file content block with a file_id like file-api-.... DeepSeek Files API

import os
from openai import OpenAI

with OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
) as client:
    with open("screenshot.jpg", "rb") as image:
        uploaded = client.files.create(file=image, purpose="user_data")

    print("Uploaded file ID:", uploaded.id)
    response = client.chat.completions.create(
        model="deepseek-flash",
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe this image and list the visible text. Mark unreadable text as unclear."},
                {"type": "file", "file_id": uploaded.id},
            ],
        }],
        max_tokens=2048,
        extra_body={"thinking": {"type": "disabled"}},
    )

if not response.choices:
    raise RuntimeError("No response choice was returned.")
choice = response.choices[0]
if choice.finish_reason != "stop" or not choice.message.content:
    raise RuntimeError("No complete text answer was returned.")
print(choice.message.content)

In DeepSeek’s Chat Completions format, file_id is directly inside the file block, as shown. The alternative file_data field contains an inline image data URL; do not combine it with file_id. Uploaded files belong to the API key. The example omits expiration, so the file remains stored until deleted; retain the returned ID for reuse and manage its lifecycle. Files API reference.

After all requests using the file have finished, delete it with client.files.delete(file_id) using an active client and the saved ID, or set a documented expiration at upload. Reusing a stored file avoids repeated uploads; it does not make model inference free.

Image input methods: which one should you use?

Detail levels: low, high, original, and auto

The detail field controls how image URL inputs are processed. DeepSeek’s Vision docs define these values: low downsamples the image to 512×512 before inference; high and original keep the original image; auto is currently equivalent to original. DeepSeek Vision guide

For dense screenshots or chart labels, start with original and check the extracted text. This avoids the specific low downsampling step, but does not bypass the model’s normal pre-inference resizing. For broad scene description, test whether low is adequate instead of assuming more detail is always necessary.

Image limits and token billing

DeepSeek’s Vision docs list shared image limits for Vision requests. These limits matter because many image failures are caused by oversized files, too many images, or sending images in the wrong format. DeepSeek Vision guide

All applicable limits must be satisfied together. Base64 increases the serialized body size, so the image-byte allowance is not the same as the 48 MiB JSON-body allowance. A file_id avoids embedding the image bytes in that body, but does not remove image-count, dimension, aggregate-size, or context limits. Here, MiB means 1,048,576 bytes.

DeepSeek says images are converted into tokens based on dimensions and billed together with text tokens. The Vision guide also says images are automatically resized before inference and that there is an upper bound of 1024 tokens per image after resizing. Each image in a multi-image request is counted independently. DeepSeek Vision guide

Use the official image token calculator for estimates and response usage for actual billing. Smaller files reduce transfer size, but images already at the same post-resize token cap need not become cheaper merely by reducing their source dimensions. Compare detail settings, image count, and output length, using current model prices.

Using images with the Responses API

For client.responses.create(), use input_text and input_image. Unlike Chat Completions, the image URL is a string directly on the content part. The example uses user; DeepSeek also accepts developer here and treats it as user. Responses compatibility guide.

import base64
import os
from pathlib import Path
from openai import OpenAI

image_b64 = base64.b64encode(Path("screenshot.jpg").read_bytes()).decode("ascii")

with OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
) as client:
    response = client.responses.create(
        model="deepseek-flash",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Describe the main visible elements. Do not guess unreadable text."},
                {
                    "type": "input_image",
                    "image_url": f"data:image/jpeg;base64,{image_b64}",
                    "detail": "low",
                },
            ],
        }],
        reasoning={"effort": "none"},
        max_output_tokens=2048,
    )

if response.status != "completed" or not response.output_text:
    raise RuntimeError("The response is incomplete or has no final text; inspect its status.")
print(response.output_text)

Choose exactly one source per input_image: image_url or file_id. DeepSeek documents HTTP 400 when both or neither are supplied, or when an image appears in a system or assistant message. detail is ignored for file_id images. Referenced images are supported; that does not imply support for a generic PDF input_file block. Responses request reference.

Using images with the Anthropic-compatible API

For the Anthropic SDK, use https://api.deepseek.com/anthropic and a user message with an image block containing source. Do not send Chat Completions image_url blocks or Responses input_image blocks to this interface. Official Anthropic-format image example.

Install anthropic with python -m pip install anthropic. This example reuses the same DEEPSEEK_API_KEY and local JPEG. For this SDK’s Base64 image source, data contains only the encoded bytes, not a data:image/... prefix.

import base64
import os
from pathlib import Path
import anthropic

image_b64 = base64.b64encode(Path("screenshot.jpg").read_bytes()).decode("ascii")

with anthropic.Anthropic(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com/anthropic",
) as client:
    message = client.messages.create(
        model="deepseek-flash",
        max_tokens=2048,
        thinking={"type": "disabled"},
        messages=[{
            "role": "user",
            "content": [
                {"type": "text", "text": "Describe the main visible elements. Do not guess unreadable text."},
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": image_b64,
                    },
                },
            ],
        }],
    )

if message.stop_reason != "end_turn":
    raise RuntimeError("The response did not finish normally; inspect stop_reason.")
text = "\n".join(block.text for block in message.content if block.type == "text")
if not text:
    raise RuntimeError("No final text was returned.")
print(text)

The documented source.type variants are base64, url, and file. Base64 pairs the encoded string with a MIME type such as image/jpeg. A file source uses file_id and requires anthropic-beta: files-api-2025-04-14; add it through extra_headers when referencing a stored image. Source variants; Files API header requirements.

DeepSeek Vision vs DeepSeek-OCR

DeepSeek Vision and DeepSeek-OCR are related but not the same. DeepSeek Vision through deepseek-flash is a hosted image-understanding API. DeepSeek-OCR and DeepSeek-OCR-2 are separate OCR/document-understanding model routes used for local or self-managed workflows. DeepSeek-OCR GitHub DeepSeek-OCR-2 GitHub

Use careful wording: DeepSeek Vision can perform OCR-like tasks, but it is not the same thing as a dedicated local OCR pipeline. For invoices, contracts, financial statements, medical records, or regulated documents, validate the extracted text against the source image.

Best prompts for screenshots, OCR, charts, and documents

Specify what to extract, how to format it, and how to report missing or unreadable information. These prompt templates are starting points, not accuracy guarantees.

A prompt asking for JSON is not a schema validator. Parse the response, validate the expected fields and types, and check important values against the image. For API-enforced formatting, follow the options for the chosen endpoint rather than copying parameters between APIs; our DeepSeek JSON Output guide covers that distinction.

Troubleshooting DeepSeek Vision image input

Inspect the actual error body before retrying. If a text-only request works, add one small image using the schema for that same endpoint. An SDK accepting a dictionary does not prove DeepSeek accepts every role or content type supported by the SDK’s original provider.

Privacy and security when uploading images

DeepSeek Vision is a hosted API workflow. If you send an image to deepseek-flash, that image is sent to DeepSeek’s API. Do not upload sensitive images unless your organization allows it and you understand the data flow.

Sensitive images can include passports, driver’s licenses, government IDs, medical images, legal documents, financial statements, internal dashboards, source-code screenshots, credentials, API keys, client documents, home addresses, or children’s data. DeepSeek’s Privacy Policy says its services may collect prompts, uploaded files, photos, feedback, and chat history, and says the service is not designed to process sensitive personal data. DeepSeek Privacy Policy

For business or regulated workflows, review DeepSeek’s policy and terms, decide whether the image can be sent to a hosted API, and use approved infrastructure. If the image must remain private, evaluate a local OCR or local vision workflow instead of sending it to any hosted model.

Common mistakes from old DeepSeek Vision tutorials

Frequently asked questions

What is DeepSeek Vision?

DeepSeek Vision is DeepSeek’s image-input capability in the API, currently served through deepseek-flash. It lets you send images with text prompts for description, screenshot reading, OCR-like extraction, and chart analysis.

Does DeepSeek support images?

Yes. The current deepseek-flash model supports text and image input according to DeepSeek’s model table.

Which DeepSeek model supports image input?

Use deepseek-flash, the current DeepSeek-V4.1-Flash model ID.

Does deepseek-v4-pro support Vision?

No, not in the current model list. deepseek-v4-pro is listed as text-only.

Is deepseek-v4-flash-vision-exp still current?

No. It is a legacy compatibility name. DeepSeek says the old V4 Flash Vision Exp model is retired and requests are served by the latest Flash model. Use deepseek-flash in new code.

Can DeepSeek Vision read screenshots?

Yes. DeepSeek’s Vision guide lists reading text from screenshots as a supported use case. Use detail: "original" for dense UI screenshots or small text.

Can DeepSeek Vision do OCR?

It can perform OCR-like extraction from images and screenshots, but it should not be treated as a perfect OCR engine. Validate extracted fields against the source image, especially for legal, medical, financial, and compliance workflows.

Can DeepSeek Vision analyze charts?

Yes. DeepSeek’s Vision guide mentions chart analysis. Ask the model to read the title, axis labels, legend, visible values, and main trend, then verify important numbers manually.

What image formats does DeepSeek support?

The Vision docs list JPEG, PNG, GIF, and WebP.

How many images can I send?

DeepSeek’s Vision docs list a maximum of 600 images per request, subject to total size and dimension limits.

What is the image size limit?

The current Vision docs list 32 MiB for a single Base64 or external URL image and 64 MiB for a single Files API file_id image. They also list total request image-size limits and dimension limits.

How are images billed?

DeepSeek says images are converted into tokens based on their dimensions and billed together with text tokens. The Vision guide describes resizing behavior and an upper bound of 1024 tokens per image after resizing.

What does detail=low do?

detail=low downsamples the image to 512×512 before inference. It is faster and cheaper when fine visual detail is not important, but it is not ideal for small text or dense charts.

Should I use Files API or Base64?

Use Base64 for small local images and quick scripts. Use the Files API when the image is reused across requests, when inline request size is too large, or when the image is too large for the Base64/external URL limit.

Is DeepSeek Vision the same as DeepSeek-OCR?

No. DeepSeek Vision is hosted image input through deepseek-flash. DeepSeek-OCR and DeepSeek-OCR-2 are separate OCR/document model routes for local or self-managed workflows.

Is it safe to upload private images?

Do not upload private images unless your policy allows it. Hosted Vision API requests send images to DeepSeek’s API. For sensitive IDs, medical images, financial records, legal documents, internal dashboards, or client materials, use an approved workflow and review DeepSeek’s privacy policy first.

Can I use developer for images in Chat Completions?

Not as a documented DeepSeek Chat Completions role. Use user for direct image input. The accepted developer role belongs to DeepSeek’s Responses format, where it is treated as user.

Can a tool return an image to DeepSeek?

Responses explicitly supports image content in the documented tool-output items. The Chat Completions schema also lists it for tool messages, although the general Vision restriction is narrower. Follow the endpoint-specific schema, preserve the matching call ID, and verify that path separately.

Bottom line

DeepSeek Vision today means image input through deepseek-flash. Use that model for image description, screenshots, OCR-like extraction, chart analysis, and document image tasks. Do not use deepseek-v4-flash-vision-exp as the default for new code, and do not send images to deepseek-v4-pro unless DeepSeek changes its official model table.

Choose the input method that fits the job: Base64 for small local files, external URLs for reachable approved images, and Files API IDs for reused or larger images. Match the endpoint’s role and block format: user with image_url/file for direct Chat Completions, input_image for Responses, and image/source for Anthropic-compatible Messages.

Treat Vision output as model-generated analysis, not a certified transcript. Check completion status and validate important values. Keep private data within approved boundaries, and do not extend Responses-only role support to Chat Completions or confuse tool-returned images with direct user uploads.

Official sources checked

• DeepSeek Vision guide
• DeepSeek Chat Completions reference
• DeepSeek Responses API reference
• DeepSeek Responses compatibility guide
• DeepSeek Files API
• DeepSeek Lists Models
• DeepSeek Token & Token Usage
• DeepSeek Models & Pricing
• DeepSeek change log
• OpenAI Python SDK reference
• DeepSeek Privacy Policy
• DeepSeek-OCR repository
• DeepSeek-OCR-2 repository