跪拜 Guibai
← Back to the summary

DeepSeek's Vision API Lands at 0.12 Cents Per Image — but 800×800 Cap and CDN Blocks Bite

After waiting for nearly four months, DeepSeek's API is finally no longer "blind." On the afternoon of August 21, deepseek-v4-flash-vision-exp quietly appeared in the API documentation, with no launch event or warm-up. I immediately ran a round of tests with my API key, stepping on basically every pitfall I could find, and here are the results.

URL images work, but some domestic CDNs get rejected

DeepSeek's vision API supports two input methods—base64 encoding and URL links. I tested six URLs from different sources, and the results were surprising:

Source Status
Baidu Logo ✅
Pixabay public image ✅
Unsplash landscape ✅
Alibaba Cloud CDN (alicdn) ❌
ByteDance CDN (bytetos/bytescm) ❌
Juejin Logo ❌

Baidu images and foreign public image sources all worked fine, but Alibaba CDN and ByteDance CDN all failed. The error message was Failed to download image, because these CDNs have Referer checks or signed hotlink protection mechanisms—DeepSeek's servers get blocked when trying to fetch the images. So the conclusion isn't "URLs don't work," but rather if you need to process images on Alibaba or ByteDance CDNs, the URL method will fail; you need to download them locally first and use base64. For images from other sources, direct URL uploads are fine.

# URL method (works for public image sources)
response = 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.png"}}
        ]
    }]
)

# For Alibaba/ByteDance CDN images, convert to base64 first
with open("downloaded_image.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")
# Then pass in using f"data:image/png;base64,{b64}"

Text recognition: can read it, but details go wrong

I made a test card with a dark blue background and red border, wrote four lines of text on it (Hello DeepSeek!, Vision Test 2026, 5 fingers: 🖐, Price: ¥0.01/image), and asked the model to identify the content and colors. Results:

Three out of four lines had their main content recognized correctly, but symbols and emojis were basically hopeless, and color judgment had deviations. This accuracy isn't enough for OCR, but it's sufficient for scenarios involving "roughly understanding screenshot content"—like checking page layouts or identifying key text in error messages.

Counting fingers: classic fail, no exception

Tested counting fingers. I drew a simple sketch of a hand, five fingers, and asked the model "how many fingers is this." The model answered: "4. The four long bars above represent four fingers, the circle below represents the palm." It only counted four out of five fingers. Basically no multimodal model at this stage can pass this test, and DeepSeek is no exception. Don't count on this; wait for future versions to optimize it.

An unexpected discovery: the reasoning_effort parameter might not work

DeepSeek's thinking mode supports the reasoning_effort parameter, which can be set to none to turn off deep reasoning. I passed this parameter hoping to save some tokens, but found that the returned data still contained a large amount of reasoning_tokens. Comparing two calls:

Thinking on: completion=278, reasoning=177 (63.7%)
Thinking off: completion=325, reasoning=207 (63.7%)

After turning off thinking, the reasoning tokens didn't disappear; the proportion was exactly the same. This parameter's behavior might be inconsistent with the documentation, or the vision model might not support this parameter yet. In other words, there is currently no reliable way to turn off thinking mode.

9 images for 1 cent, what does this price mean

V4 Flash Vision Exp's pricing is the same as the V4 Flash text-only version. Images are converted to tokens based on size and billed uniformly, with no multimodal surcharge. A single image is capped at 384 tokens—no matter how large the original image is, it will be scaled to around 800×800 before calculation.

During peak hours (Beijing time 9:00-12:00, 14:00-18:00), the cache miss input price is 3 yuan per million tokens. 384 tokens is 0.001152 yuan, about 0.12 cents. 1 cent can view roughly 9 images. During off-peak hours, it's half price.

Let's compare with competitors (competitor data from official model pricing pages, queried August 22):

Model Token consumption per image Cost for 1000 images
Claude Sonnet 4.6 ~1334 ~29 yuan
GPT-5.4 Vision ~765 ~13.8 yuan
Gemini 3.1 Pro ~258 ~3.6 yuan
V4 Flash Vision (Peak) 384 1.15 yuan
V4 Flash Vision (Off-peak) 384 0.58 yuan

For viewing 1000 images, Claude charges you 29 yuan, DeepSeek charges you 1.1 yuan—a 25x difference. This isn't a numbers game; it's a fundamental difference in product design. At 29 yuan per image, you hesitate: "Should I really let the AI look at this image for this step?" At 1.1 yuan per image, you can let your Agent take a screenshot for analysis at every step. People doing UI automation testing should understand this difference—when the screenshot volume reaches a certain level, cost becomes the line that determines "to do or not to do."

But there's a prerequisite: the 384-token ceiling means the resolution cap is 800×800. It's fine for seeing a rough page layout, identifying chart trends, or reading key information in error screenshots. But if you need to recognize small fonts or fine UI details, this resolution might not be enough. 800×800 is Super VGA-level resolution from 1995; people doing fine OCR will be disappointed.

What it can actually do

Having mentioned so many limitations, let's summarize the scenarios where this model is actually usable:

Usable for:

Unusable or use with caution:

API access quick reference

If you've previously used DeepSeek's text API, the changes are minimal. Change the model name, and change the content from a plain string to an array format:

from openai import OpenAI
import base64

client = OpenAI(
    api_key="sk-xxx",
    base_url="https://api.deepseek.com"
)

# Image via base64 (Alibaba/ByteDance CDN image URLs will fail due to hotlink protection)
with open("screenshot.png", "rb") as f:
    b64 = base64.b64encode(f.read()).decode("utf-8")

response = client.chat.completions.create(
    model="deepseek-v4-flash-vision-exp",  # -exp suffix is required
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What UI issues does this page have?"},
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}}
        ]
    }]
)
print(response.choices[0].message.content)

A few points to note:

Additionally, the Files API was launched simultaneously, free of charge. Upload an image first to get a file_id, then reference the ID in subsequent requests, so the same image doesn't need to be transmitted repeatedly. This is quite practical for Agent scenarios where the same design draft is viewed repeatedly.

Limitations stated clearly

Finally, a dose of cold water.

Hard resolution cap at 800×800: Fine small text, dense table data, high-resolution code screenshots might be unclear. Currently, this can only be mitigated through crop+zoom Agent workflows.

The Exp suffix means experimental version: The model name, behavior, and even API format may change. Don't put it directly into production; run it in your own test pipeline first. DeepSeek previously released V3.2 as an Exp version first, and it took two months to upgrade to the official version.

Some CDN image URLs are unusable: Alibaba CDN (alicdn) and ByteDance CDN (bytetos/bytescm) will reject download requests from DeepSeek's servers due to hotlink protection mechanisms; you need to download the images locally first and pass them in via base64. Baidu and other public image source URLs work normally.

Thinking mode has no reliable way to turn off: The reasoning_effort: none parameter was tested and did not take effect; reasoning tokens are still consumed. The good news is there's no situation where 100% of the output is consumed, but it will cost extra tokens.

My own judgment: This step by DeepSeek fills the most basic perception entry point for Agent systems. Enabling the model to "see" is a prerequisite for all subsequent automation workflows. The price is cheap enough, and base64 integration isn't too troublesome, making it suitable for high-frequency, low-precision screenshot analysis scenarios. But the two shortcomings—fine recognition and direct URL uploads—will need to wait for future versions to resolve.

That's all for now. I'll talk more if there's news about Harness adaptation later.