DeepSeek V4.1 Flash: Image Input and Vision Configuration

One-sentence takeaway

deepseek-flash (currently corresponding to DeepSeek-V4.1-Flash) accepts messages containing text and images through OpenAI-compatible Chat Completions; images can be supplied as Base64, a public URL, or a Files API file_id, and the choice should account for the 48 MiB request-body limit, per-image size, image-count, and image-token cost limits. The old name deepseek-v4-flash-vision-exp is still accepted, but the retired model's requests are handled by the latest Flash model. Official Vision Guide

Use cases

• Suitable tasks: Image descriptions, screenshot text recognition, chart analysis, and tasks that need both text instructions and one or more images.

• Unsuitable tasks: Putting images in system or assistant messages; the official documentation says this returns 400. Images that exceed the size, count, or dimension limits should also be compressed, split up, or sent through the Files API first.

• Applicable model versions: DeepSeek-V4.1-Flash, with deepseek-flash as the API model name. The old name deepseek-v4-flash-vision-exp is still accepted, but it is not an independent entry point to the old model's capabilities.

• Applicable clients, Agents, or APIs: OpenAI-compatible Chat Completions; the same three image sources also apply to the Responses API, while the Anthropic-compatible /messages endpoint uses a different image/source content structure.

• Recommended reasoning tiers and parameters: This article does not provide a unified reasoning tier for vision tasks. Choose detail according to the required visual detail: use low when detail is unimportant, and original when the original image must be retained; high is equivalent to original, and auto is also currently equivalent to original.

Ready-to-use content

Image-and-text request template

This is a request-structure template, not a complete official prompt. Replace <任务> with the action to perform, and pass the image as an image_url or file block in the same user message:

{
  "model": "deepseek-flash",
  "messages": [
    {
      "role": "user",
      "content": [
        {"type": "text", "text": "<任务>"},
        {"type": "image_url", "image_url": {"url": "<图片 URL>", "detail": "auto"}}
      ]
    }
  ]
}

Python: Complete core example with a Base64 image

Base64 is suitable for local files. The encoded result goes in a data: URL and counts toward the 48 MiB request-body limit.

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 image_file:
    encoded = base64.b64encode(image_file.read()).decode("utf-8")

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is in this image?"},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{encoded}",
                        "detail": "auto",
                    },
                },
            ],
        }
    ],
)

print(response.choices[0].message.content)

Two other image sources

• Public URL: Set image_url.url to a publicly accessible http(s) link. The URL can be up to 8192 characters long, and the download must complete within 60 seconds.

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

• Files API: Upload the image first, then put the returned file-api-... in a file block. This is suitable for repeatedly referencing the same image or for a single image larger than 32 MiB.

  {"type": "file", "file_id": "file-api-xxxxxxxxxxxxxxxx"}

  A file block can also carry a Base64 data: URL directly through file_data, but file_id and file_data are mutually exclusive. When referencing an image through a Files API file_id, detail has no effect.

detail values

The Responses API uses input_image content blocks; the Anthropic-compatible API uses image content blocks and a source object. Their field shapes differ, so the Chat Completions block above cannot be copied directly.

Testing or workflow steps

1. Choose an input method: use Base64 for a small local file, a URL for a public resource, and a Files API file_id for an image that needs to be reused or exceeds 32 MiB.

2. Put the image in the content array of a role="user" message and add a clear text task; do not put it in a system or assistant message.

3. Set detail according to the task's requirements. Start with low for thumbnails, coarse-grained classification, and similar tasks; use original when small text or chart details matter.

4. For multi-image requests, check the size, count, and total size of each image; the service calculates tokens for each image independently.

5. Read response.choices[0].message.content, and record the image source, detail, and task type before the call so that limit or recognition-quality issues can be investigated.

Original evidence and data

• The page says that deepseek-flash accepts images and text and lists four formats: JPEG, PNG, GIF, and WebP. The format is determined from the actual file content, not the filename or declared MIME type. Official Vision Guide

• The page specifies three input methods: a Base64 data: URL, a public http(s) URL, and a Files API file_id; all three use a content array in OpenAI-compatible Chat Completions.

• Base64 or file_data counts toward the 48 MiB request-body limit; the per-image limit is 32 MiB for Base64/public URLs and 64 MiB for a Files API file_id. A public URL can be at most 8192 characters long, and its download must complete within 60 seconds.

• A request can contain at most 600 images. The total image size is at most 64 MiB when no file_id images are included, and at most 200 MiB when file_id images are included. The maximum length of one side is 8192 px; for requests containing 15 or more images, the per-side limit drops to 4096 px.

• Images are converted to tokens based on their dimensions, and those tokens are billed together with text tokens. Before inference, images with fewer than approximately 544×544 total pixels are proportionally enlarged; larger images are proportionally reduced so that the total is approximately 1300×1300 pixels. Each image can use at most 1024 tokens; multi-image requests calculate each image separately under the same rules.

• low first resizes the image to 512×512; high and original are equivalent, and auto is currently equivalent to original. Images referenced by file_id ignore detail.

• Images are supported only in user messages; putting one in a system or assistant message returns 400.

Applicable boundaries

• 48 MiB is a request-body limit and cannot simply be equated with the original image-file size; Base64 encoding increases request-body volume. When close to the limit, use the Files API first.

• A “public URL” must be accessible to the service; a local path, a login-required address, or an address whose download takes more than 60 seconds does not meet the page's conditions.

• The 512×512 resize used by low may lose small text, fine lines, and chart details; original retains the input image, but the image is still preprocessed according to the dimension rules described on the page and counts toward token usage.

• The Files API changes only the upload and referencing method; it does not change the image-format, count, total-size, dimension, or user-message restrictions. File storage and upload quotas must be checked separately on the Files API limits page.

• The page gives no visual-recognition accuracy, OCR accuracy, or unified reasoning tier for vision tasks. API limits cannot be inferred to guarantee model performance.

Reproduction notes

1. On 2026-09-16, access Vision through the Tabbit browser and read the complete page body, code blocks, limits table, and limit descriptions; do not use search snippets or other visual materials.

2. Send an image-and-text request with a local JPEG and the Python example above using the default stream configuration, and verify the model, content array, image_url, and detail fields in the request body; do not write a real API key to logs.

3. Replace the image source separately with a public URL and a Files API file_id to confirm the three input structures; use test data that exceeds the URL-length, per-image-size, image-count, or image-dimension limits, record the server errors, and do not present unexecuted results as verified facts.

4. When Responses API or an Anthropic-compatible API is needed, rewrite the content block according to the corresponding input_image or image/source structure on the original page; do not directly reuse the Chat Completions JSON.