How to Use DeepSeek V4 in VS Code: Flash, Pro, Vision & Agents

Last verified: August 23, 2026. API facts were checked against the live DeepSeek documentation; VS Code integration behavior was checked against each client’s current documentation or listing.

You can use DeepSeek V4 in VS Code with an API key, a compatible editor client, the OpenAI-format base URL https://api.deepseek.com, and one of three current model IDs: deepseek-v4-flash, deepseek-v4-pro, or the experimental multimodal deepseek-v4-flash-vision-exp. The important distinction is that API support and editor-client support are separate: Flash and Pro are text models, while Vision Exp accepts images only when the VS Code integration actually forwards multimodal content.

Quick Answer

• Create a DeepSeek API key from the DeepSeek Platform.
• Install a compatible VS Code integration: Copilot Chat provider, Continue, Cline, Kilo Code, or Deep Code.
• Use the OpenAI-format base URL: https://api.deepseek.com.
• Choose deepseek-v4-pro for complex coding, large refactors, architecture, and agent tasks.
• Choose deepseek-v4-flash for everyday chat, quick edits, autocomplete, and cost-sensitive work.
• Choose deepseek-v4-flash-vision-exp when screenshots, diagrams, charts, or other image pixels must reach DeepSeek natively.
• Confirm the client exposes the exact model ID and image capability; then test with a small read-only prompt before allowing edits.

If you want a separate browser-based agent interface rather than a VS Code extension, follow the DeepSeek Harness install and safety guide.

DeepSeek V4 Preview launched on April 24, 2026. Flash was updated on July 31, Pro reached GA on August 13, and the DeepSeek-V4-Flash-Vision-Exp release added native image understanding on August 21. The base URL is unchanged; selecting the correct current model ID is what changes the capability.

DeepSeek V4 VS Code Setup Options Compared

VS Code path	Documented model access	Image path	Best fit	Confidence
DeepSeek V4 for Copilot Chat	Flash, Pro, Vision Exp	Vision Exp native; Flash/Pro use configurable Vision Proxy	Copilot agent mode, tools, skills, MCP	Verified in current Marketplace listing
Continue	Exact custom model IDs	Add image_input for Vision Exp	Chat, edit, apply, autocomplete	Supported by current config reference; verify one image
Cline	OpenAI-compatible custom model ID	Enable Image Support only for Vision Exp	Autonomous multi-file work	Supported by current provider settings; verify one image
Kilo Code	Official guide lists Flash and Pro	No verified Vision selector in the current guide	CLI/editor agent workflow	Do not assume native vision
Deep Code	Official guide config lists Flash and Pro	Image paste UI exists, but Vision model routing is not documented	DeepSeek-first terminal/editor agent	Do not assume native vision

DeepSeek’s current model table lists Flash, Pro, and Vision Exp with a 1M context length, a maximum 384K output, thinking and non-thinking modes, JSON output, tool calls, Responses API, Anthropic API, and chat prefix completion. FIM completion is available only for non-thinking Flash/Pro and is not supported by Vision Exp. Current versions are DeepSeek-V4-Flash-0731, DeepSeek-V4-Pro-0813, and DeepSeek-V4-Flash-Vision-Exp.

What Is DeepSeek V4 in VS Code?

DeepSeek V4 in VS Code means using a current V4 API model as the backend for coding chat, code edits, inline help, visual debugging, or agentic development. The three current model IDs are:

deepseek-v4-flash
deepseek-v4-pro
deepseek-v4-flash-vision-exp

DeepSeek V4 Flash is the practical default for everyday coding, quick explanations, small edits, and cost-sensitive agent loops. DeepSeek V4 Pro is better for difficult reasoning, multi-file refactors, debugging, architecture, and high-risk agent work. DeepSeek V4 Flash Vision Exp is the experimental choice for screenshots, diagrams, charts, UI bugs, and other tasks where the original pixels—not a separate model’s text description—must reach DeepSeek.

Flash and Vision Exp have the same current token prices and the same 2,500-request concurrency limit; Pro is more expensive and has a 500-request limit. Vision Exp’s pure-text capability is described as comparable to Flash, but it adds native visual understanding and remains explicitly experimental.

DeepSeek V4 supports thinking mode and non-thinking mode. In Chat Completions, thinking.type can be set to enabled or disabled; thinking is enabled by default with an effort of high. Choose the direct reasoning_effort values low, high, or max. Compatibility values medium and xhigh are accepted and both map to high; this mapping is identical for V4 Flash and V4 Pro. This is the Chat Completions contract, not the separate Responses reasoning.effort field.

Do not generalize “DeepSeek V4 is text-only.” Flash and Pro are text-only API models. Vision Exp accepts JPEG, PNG, GIF, and WebP images through an external URL, an inline Base64 data URL, or an image file_id from the Files API. General documents such as PDF and DOCX are not supported by that Files API. A VS Code client must still expose the Vision model and serialize the image correctly; otherwise the API capability is irrelevant to the editor workflow.

Prerequisites

Before you start, prepare the following:

• Updated VS Code.
• A DeepSeek account and API key.
• Billing balance or credits if your account requires paid API usage.
• A GitHub Copilot subscription if you want to use the Copilot Chat method.
• Node.js where required by CLI tools such as Kilo Code or Deep Code.
• A small test project so you can verify behavior safely.

For the DeepSeek-documented third-party Copilot Chat method, DeepSeek’s docs specify VS Code 1.116 or later, a GitHub Copilot subscription, and the DeepSeek V4 for Copilot Chat extension. The same page says the Copilot free tier works for this integration.

Step 1 — Create and Secure Your DeepSeek API Key

Create your API key from the DeepSeek Platform, then store it securely. Do not paste it into a public GitHub issue, commit it to a repository, or save it in a shared settings.json file.

For terminal testing, store the key as an environment variable:

export DEEPSEEK_API_KEY="sk-your-key-here"

On Windows PowerShell:

$env:DEEPSEEK_API_KEY="sk-your-key-here"

Optionally run a small smoke test. This call is token-billed; the editorial QA for this page did not send it:

curl https://api.deepseek.com/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [
      {
        "role": "user",
        "content": "Reply with OK if the API works."
      }
    ],
    "thinking": {
      "type": "disabled"
    },
    "max_tokens": 20,
    "stream": false
  }'

The official DeepSeek quick start uses the OpenAI-compatible /chat/completions endpoint with Authorization: Bearer, model, messages, optional thinking, reasoning_effort, and stream.

Method 1 — Use DeepSeek V4 in VS Code with Copilot Chat

This is the best default option if you already use Copilot Chat in VS Code.

DeepSeek’s GitHub Copilot integration page labels this extension as a third-party tool and says DeepSeek cannot guarantee its effectiveness or security. The official guide still describes Flash and Pro, while the current Marketplace listing now exposes Flash, Pro, and Flash Vision Exp while retaining Copilot agent mode, tool calling, instructions, skills, and MCP. Review the publisher, permissions, source code, release history, and data path before entering an API key.

Setup Steps

1. Update VS Code to version 1.116 or later.
2. Make sure GitHub Copilot Chat is installed and active.
3. Install DeepSeek V4 for Copilot Chat from the VS Code Marketplace.
4. Open the Command Palette with Cmd+Shift+P or Ctrl+Shift+P.
5. Run:

DeepSeek: Set API Key

6. Paste your DeepSeek API key.
7. Open Copilot Chat with Cmd+Shift+I or Ctrl+Shift+I.
8. Click the model picker.
9. Choose DeepSeek V4 Flash, DeepSeek V4 Pro, or DeepSeek V4 Flash Vision Exp.
10. Start with a safe prompt:

Read the open file and explain what it does. Do not edit anything.

The Marketplace listing says the API key is stored in VS Code SecretStorage / the OS keychain, not in settings.json. It positions Flash for everyday coding, Pro for complex refactors and agent work, and Vision Exp for direct experimental image understanding.

Native Vision vs Vision Proxy

With Flash Vision Exp, image attachments are sent as native multimodal input. With Flash or Pro, the extension can ask a separate image-capable model to describe the attachment, then pass that text description to DeepSeek. Proxy mode preserves the text model choice but is not the same as the original pixels reaching DeepSeek.

For screenshot-driven debugging, start the conversation with Vision Exp. The listing says Vision Exp does not silently fall back when a custom endpoint lacks its model ID, which is safer than believing an image was processed when it was not.

Thinking Effort

The current extension listing offers none, low, high, and max. Use none for the fastest non-thinking response, low for light reasoning, high for normal coding, and max for difficult debugging or large refactors. DeepSeek’s API guide says compatibility values medium and xhigh map to high; use the direct documented values when the client allows them.

When to Use This Method

Use Copilot Chat integration when you want the most familiar VS Code workflow: chat panel, model picker, agent mode, tools, MCP, and project context inside Copilot.

The main limitation is dependency on Copilot and the extension’s compatibility with current VS Code/Copilot APIs. If the model picker does not show DeepSeek, update VS Code, update the extension, confirm Copilot is enabled, and re-run the API key command.

Method 2 — Use DeepSeek V4 with Continue in VS Code

Continue is a good choice if you want a flexible open-source coding assistant for chat, edit, apply, autocomplete, and agent-like workflows.

Continue’s DeepSeek provider documentation uses provider: deepseek, model, and apiKey in config.yaml. Continue’s config reference also supports model roles such as chat, autocomplete, edit, apply, and summarize.

Create or edit your Continue config.yaml:

name: DeepSeek V4
version: 1.0.0
schema: v1

models:
  - name: DeepSeek V4 Flash
    provider: deepseek
    model: deepseek-v4-flash
    apiKey: <YOUR_DEEPSEEK_API_KEY>
    roles: [chat, edit, apply, autocomplete]

  - name: DeepSeek V4 Pro
    provider: deepseek
    model: deepseek-v4-pro
    apiKey: <YOUR_DEEPSEEK_API_KEY>
    roles: [chat, edit, apply]
    capabilities: [tool_use]

  - name: DeepSeek V4 Flash Vision Exp
    provider: deepseek
    model: deepseek-v4-flash-vision-exp
    apiKey: <YOUR_DEEPSEEK_API_KEY>
    roles: [chat, edit, apply]
    capabilities: [tool_use, image_input]

Use Flash for autocomplete and routine chat, Pro for code review and multi-file planning, and Vision Exp for screenshots or diagrams. Continue’s current config reference says tool_use enables Agent mode and image_input enables image upload and processing. These flags override capability autodetection, so do not add image_input to Flash or Pro.

For local alternatives, Continue can also connect to Ollama and auto-detect installed models, but local Ollama setups depend on the exact model tag, local hardware, context configuration, and tool support.

Method 3 — Use DeepSeek V4 with Cline

Cline is best when you want an AI agent that can inspect a project, propose changes, edit files, run commands, and iterate. It is powerful, so start conservatively.

Cline’s documentation says the OpenAI Compatible provider requires three main settings: base URL, API key, and model ID.

Use these values:

API Provider: OpenAI Compatible
Base URL: https://api.deepseek.com
API Key: your DeepSeek API key
Model ID: deepseek-v4-pro

For cheaper routine tasks, switch the model ID to:

deepseek-v4-flash

For native image input, use the experimental Vision model and enable Cline’s Image Support capability in Model Configuration:

API Provider: OpenAI Compatible
Base URL: https://api.deepseek.com
Model ID: deepseek-v4-flash-vision-exp
Image Support: enabled

Do not enable Image Support for deepseek-v4-flash or deepseek-v4-pro; DeepSeek rejects images sent to non-vision models. Because Cline’s documentation exposes a generic capability switch rather than a DeepSeek-specific Vision recipe, verify one harmless screenshot before relying on it for production work.

Start with this read-only prompt:

Read the project structure and summarize what this repository does. Do not modify files.

Only allow edits after Cline has produced a plan you understand. For larger jobs, ask it to edit specific files instead of the entire repository:

Plan a fix for the failing auth tests. Do not edit files yet.

Then:

Apply the smallest safe change only in src/auth/session.ts and tests/auth/session.test.ts.

Use V4 Pro for Cline when the task involves multiple files, unclear bugs, refactoring, or test failures. Use Flash for explanation, quick cleanup, and low-risk changes.

Method 4 — Use DeepSeek V4 with Kilo Code or Deep Code

Kilo Code and Deep Code are better when you want a terminal-first or agent-first workflow rather than a simple VS Code chat panel.

Kilo Code

DeepSeek’s official Kilo Code integration says Kilo Code is available as a CLI and editor extension. The documented setup is to install the CLI, run it inside your project, connect the DeepSeek provider, and select DeepSeek V4 Flash or DeepSeek V4 Pro from the model selector.

Install:

npm install -g @kilocode/cli
kilo --version

Run it inside a project:

cd /path/to/my-project
kilo

Then use:

/connect

Search for DeepSeek, enter your API key, then use:

/models

Choose DeepSeek V4 Pro for agentic coding or DeepSeek V4 Flash for faster tasks. The current official Kilo Code guide does not list Vision Exp, so do not assume the selector sends native images until Kilo documents or exposes that model ID.

Deep Code

DeepSeek’s Deep Code page describes Deep Code as an open-source terminal AI coding assistant for DeepSeek V4 with deep thinking, reasoning effort control, and Agent Skills. It requires Node.js 18+ and uses @vegamo/deepcode-cli.

Install:

npm install -g @vegamo/deepcode-cli
deepcode --version

Create:

~/.deepcode/settings.json

Add:

{
  "env": {
    "MODEL": "deepseek-v4-pro",
    "BASE_URL": "https://api.deepseek.com",
    "API_KEY": "sk-your-key-here"
  },
  "thinkingEnabled": true,
  "reasoningEffort": "max"
}

Then run:

cd /path/to/my-project
deepcode

DeepSeek’s docs note that the same settings file is shared with the Deep Code VS Code extension. The guide shows image paste as a shortcut, but its documented MODEL examples still name Flash and Pro; an image button alone does not prove native Vision routing. Keep the documented models unless your installed version explicitly supports deepseek-v4-flash-vision-exp.

How Native Vision Should Reach DeepSeek

For a VS Code integration to provide native DeepSeek vision, it must select deepseek-v4-flash-vision-exp and serialize the attachment as multimodal input. DeepSeek accepts three image paths: a public image URL, an inline Base64 data URL, or an image file_id created through the Files API. Chat Completions uses image_url or file content blocks; Responses uses input_image.

• Supported formats: JPEG, PNG, GIF, and WebP.
• Images are allowed in user messages only for Chat Completions.
• Maximum 600 images per request; maximum side 8,192 px, reduced to 4,096 px with 15 or more images.
• The Files API is image-only; PDF, DOCX, ZIP, and arbitrary project files remain unsupported.

For the full payload shapes and size limits, use our DeepSeek Vision input guide. A successful image upload to the editor is not enough; confirm that the request uses the Vision model and that the answer reflects details found only in the image.

Which DeepSeek V4 Model Should You Use in VS Code?

Task	Recommended model	Why
Tab autocomplete or quick explanation	V4 Flash	Fast, inexpensive, text-only
Routine agent loop	V4 Flash	2,500 concurrency and lower token price
Large refactor or hard bug	V4 Pro	Stronger fit for complex reasoning and agent work
Architecture or high-risk change	V4 Pro with human review	Use stronger reasoning; review every diff
Screenshot, UI bug, diagram, chart	V4 Flash Vision Exp	Native image input instead of a text proxy
Text task with Vision already selected	Vision Exp or Flash	Vision Exp is comparable to Flash on pure text and has the same price
PDF or DOCX review	Not directly supported	DeepSeek Files API is for images, not general documents

A practical rule: default to Flash, escalate to Pro when difficult reasoning justifies the higher price, and choose Vision Exp when the pixels themselves matter. If an editor client cannot prove it forwards image content to the Vision model, treat its image feature as unverified.

Pricing and Cost Control

Current pricing verified August 23, 2026: Flash and Vision Exp share the same rates per 1M tokens: off-peak $0.007 cache-hit input / $0.22 cache-miss input / $0.66 output; peak $0.014 / $0.44 / $1.32. Pro costs off-peak $0.022 / $0.66 / $1.98 and peak $0.044 / $1.32 / $3.96. Weekday peak windows are 01:00–04:00 and 06:00–10:00 UTC; weekends are entirely off-peak by Beijing time under the rule effective August 23. Check the official pricing table before a large agent run.

The extension may be free, but DeepSeek API calls are token-billed. Vision images are converted into input tokens—up to 384 tokens per image after resizing—and billed with text input. Use the DeepSeek API Cost Calculator for scenarios, while treating the official pricing page as the source of truth.

Cost-control tips:

• Use Flash for routine text chat and autocomplete; use Vision Exp only when image input is required.
• Use Pro only when the task requires stronger reasoning.
• Avoid asking tools to read the whole repository unless necessary.
• Start agent tasks with “inspect and plan only.”
• Limit output tokens when your extension supports it.
• Ask for diffs, not full rewritten files, when possible.
• Review every file before accepting changes.

Agent loops can become expensive because the tool may repeatedly send file contents, command outputs, errors, and revised prompts. Output tokens are often the most expensive part of a long refactor, especially when thinking mode is enabled.

Common Errors and Fixes

Error / symptom	Likely cause	Fix
401 authentication failed	Wrong, revoked, or missing API key	Re-enter or rotate the key; verify SecretStorage/environment variable
402 insufficient balance	No usable account balance	Check credits or top up before a paid test
429 rate limit	Concurrency exceeded	Reduce parallel work; current limits are Pro 500, Flash/Vision 2,500
Model not found	Wrong ID or client allowlist	Use an exact current ID and update the client/provider configuration
Wrong base URL	OpenAI default or stale proxy URL	Use https://api.deepseek.com for OpenAI format
Image rejected with 400	Image sent to Flash/Pro	Select deepseek-v4-flash-vision-exp
Image attaches but answer ignores it	Client omitted multimodal content or used a proxy	Enable image_input/Image Support and run a screenshot-specific check
PDF/DOCX upload fails	Files API is image-only	Convert relevant pages to images or extract text outside the API
reasoning_content must be passed back	Client drops thinking history in tool conversations	Update the client, preserve reasoning history, or disable thinking temporarily
Context appears lower than 1M	Client-side cap	Adjust the extension context setting if supported
API key saved in settings.json	Unsafe manual setup	Rotate it and move it to SecretStorage, keychain, or environment variables

DeepSeek’s error-code page lists 401 for authentication failure, 402 for insufficient balance, 429 for rate limit, and 500/503 for server-side issues.

The reasoning_content error is not usually an API-key problem. DeepSeek’s Copilot CLI docs say OpenAI-type integrations can trigger a 400 error when thinking-mode reasoning_content is not echoed back on later requests. A Marketplace DeepSeek V4 provider page describes the same issue with generic OpenAI-compatible bridges dropping reasoning_content in tools-enabled thinking conversations.

Security and Privacy Notes

Any API-based DeepSeek V4 setup sends prompts, selected code context, tool outputs, and—when Vision is used—attached screenshots or images to the configured provider. Crop or redact screenshots that contain API keys, customer data, internal URLs, production identifiers, or regulated information unless your organization explicitly allows that transfer.

Use .gitignore, secret scanning, environment variables, OS keychain storage, and extension secret storage. The Copilot Chat extension listing says its API key is stored in VS Code SecretStorage / OS keychain rather than settings.json; prefer that kind of storage whenever possible.

If privacy is the top priority, consider local models. DeepSeek’s Hugging Face page says official DeepSeek V4 weights are available and includes local-running guidance, but local deployment is not the same experience as the hosted API unless you reproduce compatible serving, context, quantization, and hardware conditions.

Ollama also lists DeepSeek V4 Pro and Flash cloud entries, but the visible tags are deepseek-v4-pro:cloud and deepseek-v4-flash:cloud, so treat them as cloud-model routes rather than assuming an offline local model.

Best Workflow for Real Projects

Use this workflow for safer DeepSeek V4 VS Code development:

1. Start with a read-only prompt.
2. Ask for a plan before edits.
3. Limit the scope to specific files.
4. Let the agent edit only the files you name.
5. Review the diff.
6. Run tests locally.
7. Ask the model to explain failures, not blindly retry.
8. Commit manually.
9. Use V4 Flash for daily work.
10. Use V4 Pro for hard bugs, architecture, and multi-file changes.
11. Use Vision Exp only when the visual input changes the answer, and test the client with one harmless screenshot first.

A good first agent prompt is:

Inspect the project and create a plan to fix the failing tests. Do not edit files or run destructive commands.

A good second prompt is:

Apply only the smallest safe change. Edit only the files you named in the plan. After editing, summarize the diff.

FAQ

Conclusion

The best DeepSeek V4 VS Code setup depends on both the task and the client. Copilot Chat now offers the simplest documented path to all three models, including native Vision Exp. Continue and Cline can also expose Vision when their image capability is configured and verified. Kilo Code and Deep Code remain strong agent paths for Flash/Pro, but their current guides do not prove native Vision routing.

Default to deepseek-v4-flash for everyday text coding, switch to deepseek-v4-pro for difficult reasoning and high-risk changes, and choose deepseek-v4-flash-vision-exp when the original image matters. The safe setup is: protected API key, exact model ID, correct base URL, a client that declares the required capability, and one small verification before any autonomous edit.