DeepSeek is not only a chatbot website. It is also a model platform/API that you can connect with terminal coding agents, VS Code extensions, IDEs, Python apps, Node.js apps, LangChain, LiteLLM, Open WebUI, local model runners, no-code automations, and production backends.
The most important thing to understand first:
DeepSeek does not work like one single “DeepSeek CLI installer.”
DeepSeek provides the model + API. Then you connect that API to the tool you want: curl, Python, Node.js, OpenCode, Claude Code, Aider, Cline, Continue.dev, Open WebUI, LiteLLM, LangChain, or your own application.
As of DeepSeek’s current API docs, the main API models are:
deepseek-v4-pro
deepseek-v4-flash
Older model aliases like:
deepseek-chat
deepseek-reasoner
are marked by DeepSeek as compatibility names and scheduled for retirement on 2026-07-24. DeepSeek says deepseek-chat maps to the non-thinking mode of deepseek-v4-flash, and deepseek-reasoner maps to the thinking mode of deepseek-v4-flash. (api-docs.deepseek.com)
1. Quick DeepSeek API basics
Before learning every method, know these core values.
API base URLs
DeepSeek supports both OpenAI-compatible and Anthropic-compatible API formats. Official docs list:
OpenAI-compatible base URL:
https://api.deepseek.com
Anthropic-compatible base URL:
https://api.deepseek.com/anthropic
Some third-party tools ask for an “OpenAI-compatible base URL” and may expect /v1, for example Open WebUI documents DeepSeek as https://api.deepseek.com/v1. The practical rule is simple: follow the exact format required by the tool, and never accidentally duplicate /v1/v1. (api-docs.deepseek.com)
Current API model names
deepseek-v4-pro
deepseek-v4-flash
Thinking mode
DeepSeek V4 models support both thinking and non-thinking mode. In Chat Completions, DeepSeek documents this parameter:
"thinking": { "type": "enabled" }
or:
"thinking": { "type": "disabled" }
The API also supports reasoning_effort with high and max. For complex agent requests such as Claude Code or OpenCode, DeepSeek says effort may automatically be set to max. (api-docs.deepseek.com)
API features
DeepSeek API supports:
Chat Completions
Streaming
Thinking mode
JSON output
Tool/function calling
Chat prefix completion
FIM / fill-in-the-middle completion
Context caching
OpenAI-compatible SDK usage
Anthropic-compatible SDK/tool usage
DeepSeek’s docs list these guides directly, and the API reference confirms JSON output, tool calls, and thinking controls. (api-docs.deepseek.com)
Method 1: Use DeepSeek from the official web/app interface
This is the easiest way for normal users.
Best for
General chat
Quick coding questions
Debugging snippets
Content writing
Learning concepts
Explaining errors
Architecture discussion
Steps
- Open DeepSeek official website.
- Sign in or use the available chat interface.
- Ask coding or reasoning questions.
- Paste code snippets, errors, logs, or requirements.
Pros
No installation
No API key required for basic usage
Good for quick learning and debugging
Simple for non-developers
Cons
Not ideal for full project editing
Cannot automatically modify files like Claude Code or Codex
Manual copy-paste workflow
Less suitable for production automation
When to use this method
Use this when you want answers, explanations, blog content, tutorials, SQL queries, DevOps commands, or code examples — but not automatic project-level coding.
Method 2: Use DeepSeek API directly with curl
This is the simplest developer method. It proves your API key works.
Best for
Testing API key
Server debugging
Shell scripts
CI/CD automation
Simple command-line prompts
Installation
No package installation needed. You only need curl.
On Ubuntu/Debian:
sudo apt update
sudo apt install -y curl
On macOS, curl is usually already installed.
Configuration
Create your DeepSeek API key from the DeepSeek platform, then export it:
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
For permanent Linux/macOS setup:
echo 'export DEEPSEEK_API_KEY="your_deepseek_api_key_here"' >> ~/.bashrc
source ~/.bashrc
For Zsh/macOS:
echo 'export DEEPSEEK_API_KEY="your_deepseek_api_key_here"' >> ~/.zshrc
source ~/.zshrc
Basic API call
curl https://api.deepseek.com/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
-d '{
"model": "deepseek-v4-pro",
"messages": [
{
"role": "system",
"content": "You are a senior software engineer."
},
{
"role": "user",
"content": "Explain how to fix Laravel 500 errors step by step."
}
],
"thinking": {
"type": "enabled"
},
"reasoning_effort": "high",
"stream": false
}'
DeepSeek’s official first-call docs use the same Chat Completions pattern with bearer authentication, model name, messages, thinking mode, and reasoning effort. (api-docs.deepseek.com)
Streaming response
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": "Write a shell script to backup a Laravel project."
}
],
"stream": true
}'
Pros
Fastest way to test DeepSeek API
Works on any server
Good for Bash automation
No SDK dependency
Easy to debug request/response
Cons
Not comfortable for long coding sessions
JSON escaping becomes painful
No automatic file editing
No project context unless you manually pass files
Best use case
Use curl to confirm API connectivity before configuring bigger tools like OpenCode, Claude Code, Aider, Cline, Continue.dev, or Open WebUI.
Method 3: Use DeepSeek API with Python using OpenAI-compatible SDK
DeepSeek supports OpenAI-compatible API usage, so you can use the OpenAI Python SDK by changing the base_url. (api-docs.deepseek.com)
Best for
Python apps
Automation scripts
Data processing
Backend services
AI tools
Internal company assistants
DevOps scripts
Installation
python3 -m pip install --upgrade openai
Configuration
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Example: Basic Python chat
Create a file:
nano deepseek_chat.py
Add:
import os
from openai import OpenAI
api_key = os.getenv("DEEPSEEK_API_KEY")
if not api_key:
raise RuntimeError("Missing DEEPSEEK_API_KEY environment variable")
client = OpenAI(
api_key=api_key,
base_url="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[
{"role": "system", "content": "You are a senior DevOps and Laravel engineer."},
{"role": "user", "content": "Create a Laravel deployment checklist for Ubuntu server."}
],
thinking={"type": "enabled"},
reasoning_effort="high"
)
print(response.choices[0].message.content)
Run:
python3 deepseek_chat.py
Example: Streaming Python output
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
stream = client.chat.completions.create(
model="deepseek-v4-flash",
messages=[
{"role": "user", "content": "Write 10 Linux commands to troubleshoot high CPU."}
],
stream=True
)
for chunk in stream:
delta = chunk.choices[0].delta.content
if delta:
print(delta, end="", flush=True)
Pros
Excellent for automation
Easy to integrate with Django, Flask, FastAPI, scripts
Can process files, logs, CSV, JSON
Can be used in CI/CD pipelines
Cons
You must build your own app logic
No built-in project editing unless you code it
You handle retries, rate limits, logging, and security
Best use case
Use Python when you want to build your own AI-powered tool, dashboard, script, chatbot, report generator, or internal automation.
Method 4: Use DeepSeek API with Node.js / JavaScript
This is ideal for web apps, Express APIs, Next.js, CLI tools, and developer tooling.
Best for
Node.js backend
Next.js apps
Express APIs
JavaScript automation
CLI wrappers
Chat widgets
SaaS products
Installation
mkdir deepseek-node-demo
cd deepseek-node-demo
npm init -y
npm install openai dotenv
Create .env:
nano .env
Add:
DEEPSEEK_API_KEY=your_deepseek_api_key_here
Basic Node.js example
Create:
nano index.js
Add:
import OpenAI from "openai";
import "dotenv/config";
const client = new OpenAI({
apiKey: process.env.DEEPSEEK_API_KEY,
baseURL: "https://api.deepseek.com",
});
async function main() {
const response = await client.chat.completions.create({
model: "deepseek-v4-pro",
messages: [
{
role: "system",
content: "You are a senior full-stack developer.",
},
{
role: "user",
content: "Generate a secure Express.js login API design.",
},
],
thinking: {
type: "enabled",
},
reasoning_effort: "high",
});
console.log(response.choices[0].message.content);
}
main().catch(console.error);
Update package.json:
{
"type": "module"
}
Run:
node index.js
Pros
Best for web apps and APIs
Easy to add to SaaS products
Works with frontend/backend JavaScript stacks
Good for chat widgets and dashboards
Cons
You must secure API key on backend only
Not suitable to expose directly in browser
Requires custom rate limiting and logging
Best use case
Use Node.js when building a website assistant, AI API, coding helper, support bot, document summarizer, or SaaS feature.
Method 5: Use DeepSeek with Claude Code using Anthropic-compatible API
This is one of the most interesting methods.
Claude Code is Anthropic’s terminal coding assistant, but DeepSeek documents how to point Claude Code to DeepSeek using DeepSeek’s Anthropic-compatible endpoint. DeepSeek’s docs show environment variables like ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN, and DeepSeek model names. (api-docs.deepseek.com)
Best for
Claude Code-style terminal coding
Project reading
Code editing
Refactoring
Debugging
Running commands
Multi-file changes
Installation
Install Node.js 18+ first.
Then install Claude Code:
npm install -g @anthropic-ai/claude-code
Check:
claude --version
Linux/macOS configuration
export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
export ANTHROPIC_AUTH_TOKEN="your_deepseek_api_key_here"
export ANTHROPIC_MODEL="deepseek-v4-pro[1m]"
export ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-v4-pro[1m]"
export ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-v4-pro[1m]"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4-flash"
export CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4-flash"
export CLAUDE_CODE_EFFORT_LEVEL=max
Windows PowerShell configuration
$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN="your_deepseek_api_key_here"
$env:ANTHROPIC_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-v4-pro[1m]"
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4-flash"
$env:CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4-flash"
$env:CLAUDE_CODE_EFFORT_LEVEL="max"
Run inside project
cd /path/to/your/project
claude
Example prompts:
Read this Laravel project and explain the route/controller/model structure.
Find why this page is giving 500 error and suggest a safe fix.
Refactor this Blade form and keep all existing backend logic unchanged.
Pros
Very close to Claude Code workflow
Can work inside real project directories
Can inspect and modify code
DeepSeek V4 Pro can be cheaper than some premium coding models
Uses Anthropic-compatible endpoint
Cons
Claude Code itself is still Anthropic’s tool
Some Claude-native features may not behave exactly the same with DeepSeek backend
Environment variables must be correct
Model/tool behavior can differ from native Claude models
Best use case
Use this if you already like Claude Code but want to experiment with DeepSeek as the model backend.
Method 6: Use DeepSeek with OpenCode
OpenCode is an open-source coding assistant available in terminal, web, and other forms. DeepSeek has an official integration guide for OpenCode and recommends using OpenCode version >= v1.14.24. (api-docs.deepseek.com)
Best for
Claude Code alternative
Terminal coding agent
Project-level edits
Reading codebase
AI pair programming
Installation
Use the OpenCode install command from OpenCode docs:
curl -fsSL https://opencode.ai/install | bash
Restart shell and verify:
opencode --version
Configuration
Go to your project:
cd /path/to/your/project
Start OpenCode:
opencode
Inside OpenCode:
/connect
Select:
deepseek
Paste your DeepSeek API key.
Select:
DeepSeek-V4-Pro
DeepSeek’s OpenCode guide says to run opencode, type /connect, choose DeepSeek, enter the API key, and select DeepSeek-V4-Pro. (api-docs.deepseek.com)
Example prompts
Analyze this project and tell me the top 5 risky files.
Fix the broken route without changing existing database schema.
Add validation to this Laravel controller and update the Blade form accordingly.
Pros
Open-source
Terminal-first
Simple DeepSeek connection flow
Good Claude Code alternative
Works directly in project folder
Cons
Still a separate tool to learn
File edits need review
Large codebases can consume many tokens
Best use case
Use OpenCode when you want the closest open-source Claude Code / Codex-like experience with DeepSeek.
Method 7: Use DeepSeek with Aider
Aider is a strong terminal-based AI coding tool. It works with Git and can edit files in your repo. Aider’s docs say it can connect to DeepSeek API by setting DEEPSEEK_API_KEY. (aider.chat)
Best for
Git-based coding
Patch-style file editing
Refactoring
Test-driven changes
Multi-file modifications
Installation
python3 -m pip install aider-install
aider-install
Restart terminal if needed.
Configuration
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Run Aider
cd /path/to/your/project
aider --model deepseek/deepseek-v4-pro
If your Aider version does not recognize the newest model name, use the documented DeepSeek format or check:
aider --list-models deepseek
Common older examples use:
aider --model deepseek/deepseek-chat
But for a fresh setup, prefer the current DeepSeek V4 model names where supported.
Example prompts
Fix the failing PHPUnit test. Do not change the test unless needed.
Refactor this controller into a service class and update imports.
Add form validation and preserve existing route names.
Pros
Very good for real code edits
Git-aware workflow
Clear diffs
Strong for incremental changes
Can combine architect/editor style workflows
Cons
Model-name support depends on Aider version
Best results require Git repo
Not as visual as IDE tools
Best use case
Use Aider when you want serious terminal-based coding with reviewable Git diffs.
Method 8: Use DeepSeek with Crush terminal coding agent
Crush supports custom OpenAI-compatible providers. DeepSeek’s docs include a Crush integration with config file locations and provider JSON. (api-docs.deepseek.com)
Best for
Terminal coding
OpenAI-compatible coding agent workflow
Model switching
Large-context DeepSeek V4 usage
Installation
Install Node.js first.
Then:
npm install -g @charmland/crush
Check:
crush --version
macOS users can also use Homebrew according to DeepSeek’s Crush guide:
brew install charmbracelet/tap/crush
Configuration file
Linux/macOS:
mkdir -p ~/.config/crush
nano ~/.config/crush/crush.json
Windows path:
%USERPROFILE%\.config\crush\crush.json
Add:
{
"$schema": "https://charm.land/crush.json",
"providers": {
"deepseek": {
"type": "openai-compat",
"base_url": "https://api.deepseek.com",
"api_key": "$DEEPSEEK_API_KEY",
"models": [
{
"id": "deepseek-v4-pro",
"name": "DeepSeek-V4-Pro",
"context_window": 1048576,
"default_max_tokens": 32768,
"can_reason": true
},
{
"id": "deepseek-v4-flash",
"name": "DeepSeek-V4-Flash",
"context_window": 1048576,
"default_max_tokens": 32768,
"can_reason": true
}
]
}
}
}
Export key:
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Run:
cd /path/to/my-project
crush
Use model switcher:
Ctrl + L
or:
/model
Then select DeepSeek provider and model.
Pros
Good terminal workflow
OpenAI-compatible provider config
Supports DeepSeek V4 model configuration
Large context configuration possible
Cons
Another coding-agent tool to learn
Config file must be correct
Less commonly used than Aider/OpenCode/Claude Code
Best use case
Use Crush if you like terminal-first tools and want explicit provider/model configuration.
Method 9: Use DeepSeek with OpenClaw
OpenClaw is an open-source personal AI assistant that can connect to chat tools like Feishu and WeChat and can be extended through Skills. DeepSeek’s official guide includes OpenClaw setup with DeepSeek provider selection. (api-docs.deepseek.com)
Best for
Personal AI assistant
Terminal chat
Web dashboard
Chat-tool integration
Skill-based workflows
Installation on Linux/macOS
curl -fsSL https://openclaw.ai/install.sh | bash
Installation on Windows PowerShell
iwr -useb https://openclaw.ai/install.ps1 | iex
Configuration
During setup:
Model/auth provider: DeepSeek
Enter DeepSeek API key: your key
Default model: deepseek-v4-pro or deepseek-v4-flash
If already installed:
openclaw onboard --install-daemon
Run
Web UI:
openclaw dashboard
Terminal UI:
openclaw tui
Terminal chat:
openclaw terminal
Pros
More than a coding assistant
Can act as personal assistant
Supports web UI and terminal UI
Can connect to chat tools
Cons
More moving parts than simple CLI tools
May be overkill for only code editing
Requires careful configuration for shared/multi-user use
Best use case
Use OpenClaw when you want a broader personal AI assistant, not only a code editor.
Method 10: Use DeepSeek in VS Code with Continue.dev
Continue.dev is an open-source AI coding assistant for IDEs. DeepSeek’s integration repository includes Continue configuration using ~/.continue/config.yaml on Linux/macOS and %USERPROFILE%\.continue\config.yaml on Windows. (GitHub)
Best for
VS Code coding
Code explanation
Inline edits
Autocomplete
Refactoring
Chat with codebase
Installation
- Open VS Code.
- Go to Extensions.
- Search for:
Continue
- Install Continue.dev extension.
Configuration file
Linux/macOS:
mkdir -p ~/.continue
nano ~/.continue/config.yaml
Windows:
%USERPROFILE%\.continue\config.yaml
Example configuration
Update this with current DeepSeek model names if your Continue version supports them:
name: Local Assistant
version: 1.0.0
schema: v1
models:
- name: DeepSeek V4 Pro
provider: deepseek
model: deepseek-v4-pro
apiKey: YOUR_DEEPSEEK_API_KEY
apiBase: https://api.deepseek.com
roles:
- chat
- edit
- apply
- summarize
- autocomplete
contextLength: 1048576
defaultCompletionOptions:
temperature: 0.0
maxTokens: 2048
context:
- provider: code
- provider: docs
- provider: diff
- provider: terminal
- provider: problems
- provider: folder
- provider: codebase
If your Continue version still expects older examples, you may see configurations using deepseek-chat and https://api.deepseek.com/beta; DeepSeek’s older integration example shows that style, but new tutorials should prefer current model names and official base URL where supported. (GitHub)
Pros
Best for VS Code users
Good UI
Supports chat, edit, apply, summarize, autocomplete
Can use codebase context
Cons
Config changes can break if extension format changes
Autocomplete can consume tokens quickly
Large projects can be expensive
Older DeepSeek examples may use deprecated model aliases
Best use case
Use Continue.dev if you want DeepSeek directly inside VS Code without leaving your editor.
Method 11: Use DeepSeek with Cline
Cline is an AI coding agent for VS Code and terminal workflows. It supports OpenAI-compatible providers, where the important settings are base URL, API key, and model ID. (Cline)
Best for
VS Code agentic coding
Plan/Act coding workflow
File editing with approval
Terminal command execution with approval
Browser/debug workflows
Installation
In VS Code:
- Open Extensions.
- Search:
Cline
- Install it.
Or if using CLI where available:
npm install -g cline
Configuration
In Cline settings:
API Provider: OpenAI Compatible
Base URL: https://api.deepseek.com
API Key: your_deepseek_api_key_here
Model ID: deepseek-v4-pro
If your Cline setup requires /v1, use:
https://api.deepseek.com/v1
The exact suffix depends on the provider configuration field and whether the tool appends API paths internally.
Pros
Powerful VS Code agent
Human approval before file changes/commands
Good for real project work
Can inspect files and terminal output
Cons
Can use many tokens on large projects
Needs careful approval discipline
Some users report large-context workflows can become slow or costly
DeepSeek’s own integration repository advises caution with Cline on large projects because big code context can slow API processing and increase cost. (GitHub)
Best use case
Use Cline when you want VS Code-based agentic coding with file/terminal approval.
Method 12: Use DeepSeek with Cursor or other AI code editors
Cursor and similar AI editors often support custom OpenAI-compatible API settings, depending on plan/version. The general idea is:
Provider: OpenAI-compatible
Base URL: https://api.deepseek.com or https://api.deepseek.com/v1
API Key: DeepSeek API key
Model: deepseek-v4-pro or deepseek-v4-flash
Best for
AI-native editor workflow
Chat with project
Inline code generation
Refactoring
Developer productivity
General setup pattern
- Open editor settings.
- Find Models / API Keys.
- Add custom model.
- Set model name:
deepseek-v4-pro
- Set API key:
your_deepseek_api_key_here
- Enable OpenAI-compatible base URL override.
- Set base URL:
https://api.deepseek.com/v1
or:
https://api.deepseek.com
- Save and test.
Pros
Smooth editor experience
Good for daily programming
Inline code generation
Less terminal-heavy
Cons
Support changes by editor version and subscription plan
Some tools do not expose full custom provider settings
Thinking mode may not be fully supported by all editors
Best use case
Use Cursor-like editors if your workflow is mostly visual IDE coding instead of terminal coding.
Method 13: Use DeepSeek with LangChain
LangChain now has a dedicated DeepSeek integration package named langchain-deepseek. LangChain docs say you need a DeepSeek account, API key, and the langchain-deepseek package. (LangChain Docs)
Best for
AI applications
Agents
Tool calling
Structured workflows
RAG pipelines
Chatbots
Backend automation
Installation
pip install -qU langchain-deepseek
Configuration
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Basic example
import os
from langchain_deepseek import ChatDeepSeek
if not os.getenv("DEEPSEEK_API_KEY"):
raise RuntimeError("Missing DEEPSEEK_API_KEY")
llm = ChatDeepSeek(
model="deepseek-v4-pro",
temperature=0,
max_retries=2,
)
messages = [
("system", "You are a senior DevOps engineer."),
("human", "Create a Kubernetes troubleshooting checklist.")
]
response = llm.invoke(messages)
print(response.content)
If your installed LangChain DeepSeek package does not yet support deepseek-v4-pro, use the currently supported model names and upgrade the package.
Pros
Great for production AI workflows
Supports agents and tool calling patterns
Good for RAG and business apps
Cleaner than raw API calls
Cons
Framework overhead
Version compatibility matters
Tool-calling support differs by model/mode
LangChain’s DeepSeek docs note that model feature support can differ; for example, earlier docs mention different support for tool calling and structured output across DeepSeek model aliases. (LangChain Docs)
Best use case
Use LangChain when you are building a real AI application, not just chatting.
Method 14: Use DeepSeek with LlamaIndex for RAG/document applications
LlamaIndex is a framework for building LLM applications with private/custom data and context augmentation. IBM describes LlamaIndex as an open-source data orchestration framework for LLM applications, especially useful for Retrieval-Augmented Generation workflows. (IBM)
Best for
Chat with documents
Company knowledge base
PDF/document search
RAG applications
Private data Q&A
Internal support bot
Installation
pip install llama-index llama-index-llms-openai
Configuration using OpenAI-compatible endpoint
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Example:
from llama_index.llms.openai import OpenAI
llm = OpenAI(
model="deepseek-v4-pro",
api_key="your_deepseek_api_key_here",
api_base="https://api.deepseek.com"
)
response = llm.complete("Explain what RAG means in simple words.")
print(response)
Pros
Excellent for document-based AI
Good RAG abstractions
Useful for enterprise knowledge assistants
Supports many data connectors
Cons
Requires embedding model and vector database choices
More setup than simple chat
Quality depends heavily on chunking and retrieval
Best use case
Use LlamaIndex when you want DeepSeek to answer from your own documents, PDFs, manuals, policies, website content, or internal knowledge base.
Method 15: Use DeepSeek with LiteLLM as an AI gateway
LiteLLM provides a unified interface across many LLM providers. LiteLLM docs say it supports DeepSeek models by using the deepseek/ prefix and the DEEPSEEK_API_KEY environment variable. (LiteLLM)
Best for
Multi-model routing
Fallbacks
Central LLM gateway
Cost tracking
Production AI platform
Teams using many providers
Installation
pip install litellm
Configuration
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
Python SDK example
from litellm import completion
response = completion(
model="deepseek/deepseek-v4-pro",
messages=[
{"role": "user", "content": "Write a Terraform module checklist."}
],
)
print(response.choices[0].message.content)
Streaming example
from litellm import completion
response = completion(
model="deepseek/deepseek-v4-flash",
messages=[
{"role": "user", "content": "Explain Docker networking in simple terms."}
],
stream=True,
)
for chunk in response:
print(chunk)
LiteLLM proxy server concept
LiteLLM can also run as a proxy so your internal apps call one unified endpoint instead of calling DeepSeek directly. LiteLLM’s docs describe the proxy as a central service with authentication, spend tracking, budgets, logging, caching, and virtual keys. (LiteLLM)
Pros
Best for organizations
One gateway for many models
Can add budgets, logs, fallbacks
Good for production governance
Cons
Extra service to run
Requires secure configuration
Adds operational responsibility
Best use case
Use LiteLLM when your company wants one AI gateway for DeepSeek, OpenAI, Anthropic, Gemini, Groq, OpenRouter, local models, and more.
Method 16: Use DeepSeek in Open WebUI
Open WebUI is a self-hosted chat UI that supports OpenAI-compatible providers. Its docs list DeepSeek as OpenAI-compatible with working /models auto-detection, using URL https://api.deepseek.com/v1. (docs.openwebui.com)
Best for
Self-hosted ChatGPT-like UI
Team chat interface
Internal AI portal
RAG UI
Multiple model providers
Docker installation
docker run -d \
-p 3000:8080 \
-v open-webui:/app/backend/data \
--name open-webui \
--restart always \
ghcr.io/open-webui/open-webui:main
Open:
http://localhost:3000
Configure DeepSeek
Inside Open WebUI:
Admin Settings → Connections → OpenAI → Add Connection
Use:
URL: https://api.deepseek.com/v1
API Key: your_deepseek_api_key_here
Model IDs: auto-detected, or manually add deepseek-v4-pro and deepseek-v4-flash
Save and test.
Pros
Nice browser UI
Good for teams
Can connect multiple providers
Can support RAG workflows
No need to build your own chat frontend
Cons
Requires Docker/server
You must secure user access
API cost can grow with many users
Best use case
Use Open WebUI when you want a private ChatGPT-like interface using DeepSeek API.
Method 17: Use DeepSeek API in Laravel/PHP
DeepSeek does not require a special PHP SDK. Since it is HTTP/JSON based and OpenAI-compatible, Laravel can call it using Laravel HTTP client.
Best for
Laravel SaaS
Admin panels
AI content generation
Support chatbot
SEO tools
Report generator
Internal automation
Install Laravel HTTP client dependency
Laravel already includes the HTTP client in most modern versions. If needed:
composer require guzzlehttp/guzzle
Add .env
DEEPSEEK_API_KEY=your_deepseek_api_key_here
DEEPSEEK_API_BASE=https://api.deepseek.com
DEEPSEEK_MODEL=deepseek-v4-pro
Create service class
mkdir -p app/Services
nano app/Services/DeepSeekService.php
Add:
<?php
namespace App\Services;
use Illuminate\Support\Facades\Http;
class DeepSeekService
{
public function chat(string $prompt): string
{
$apiKey = config('services.deepseek.key');
$baseUrl = config('services.deepseek.base_url', 'https://api.deepseek.com');
$model = config('services.deepseek.model', 'deepseek-v4-pro');
$response = Http::withToken($apiKey)
->timeout(120)
->post($baseUrl . '/chat/completions', [
'model' => $model,
'messages' => [
[
'role' => 'system',
'content' => 'You are a helpful assistant.',
],
[
'role' => 'user',
'content' => $prompt,
],
],
'thinking' => [
'type' => 'enabled',
],
'reasoning_effort' => 'high',
]);
if ($response->failed()) {
throw new \RuntimeException('DeepSeek API error: ' . $response->body());
}
return $response->json('choices.0.message.content') ?? '';
}
}
Add config
In config/services.php:
'deepseek' => [
'key' => env('DEEPSEEK_API_KEY'),
'base_url' => env('DEEPSEEK_API_BASE', 'https://api.deepseek.com'),
'model' => env('DEEPSEEK_MODEL', 'deepseek-v4-pro'),
],
Controller example
use App\Services\DeepSeekService;
use Illuminate\Http\Request;
Route::post('/ai/generate', function (Request $request, DeepSeekService $deepSeek) {
$request->validate([
'prompt' => ['required', 'string', 'max:5000'],
]);
return response()->json([
'answer' => $deepSeek->chat($request->input('prompt')),
]);
});
Pros
Perfect for your Laravel products
Easy to add AI content, SEO, support, summarization
No frontend API key exposure
Can integrate with queues
Cons
Need rate limiting
Need user-level cost controls
Long responses should use queue/streaming
Best use case
Use this for Wizbrand-style AI tools, hospital profile content generation, SEO assistants, blog generation, and internal admin AI features.
Method 18: Use DeepSeek API in shell scripts for DevOps automation
This is very useful for logs, Nginx errors, Laravel errors, Kubernetes events, Terraform plans, and CI/CD failures.
Best for
Linux troubleshooting
CI/CD log explanation
Kubernetes error summarization
Terraform plan review
Security scan explanation
Example: Analyze last 100 Nginx errors
export DEEPSEEK_API_KEY="your_deepseek_api_key_here"
ERRORS=$(sudo tail -100 /var/log/nginx/error.log | sed 's/"/\\"/g')
curl https://api.deepseek.com/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
-d "{
\"model\": \"deepseek-v4-pro\",
\"messages\": [
{
\"role\": \"system\",
\"content\": \"You are a senior Linux and Nginx troubleshooting expert.\"
},
{
\"role\": \"user\",
\"content\": \"Analyze these Nginx errors and give root cause and commands to fix:\\n${ERRORS}\"
}
]
}"
Example: Explain Kubernetes pod failure
kubectl describe pod my-pod -n my-namespace > /tmp/pod.txt
python3 - <<'PY'
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
with open("/tmp/pod.txt", "r", encoding="utf-8", errors="ignore") as f:
data = f.read()
resp = client.chat.completions.create(
model="deepseek-v4-pro",
messages=[
{"role": "system", "content": "You are a Kubernetes SRE."},
{"role": "user", "content": "Analyze this pod describe output and suggest fix:\n\n" + data}
]
)
print(resp.choices[0].message.content)
PY
Pros
Excellent for DevOps/SRE tasks
Works on servers
Can analyze logs quickly
Great for CI/CD failure summaries
Cons
Be careful not to send secrets
Logs may contain tokens/passwords
Needs masking before sending to external API
Best use case
Use this for troubleshooting automation, but always sanitize secrets before sending logs.
Method 19: Use DeepSeek API for JSON output and structured data extraction
DeepSeek supports JSON output with response_format: {"type":"json_object"}. Its docs warn that you should also instruct the model to output JSON in the prompt; otherwise, generation may behave badly or get stuck producing whitespace. (api-docs.deepseek.com)
Best for
Extracting data from text
Parsing emails
Converting logs to structured reports
Creating API-ready output
Generating config files
Example
curl https://api.deepseek.com/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${DEEPSEEK_API_KEY}" \
-d '{
"model": "deepseek-v4-pro",
"response_format": {
"type": "json_object"
},
"messages": [
{
"role": "system",
"content": "You output valid JSON only."
},
{
"role": "user",
"content": "Extract name, email, phone, and issue from this text as JSON: Rajesh, common.cotocus@gmail.com, issue is Laravel queue failing."
}
]
}'
Pros
Great for automation
Machine-readable output
Useful for APIs and workflows
Cons
Must write strict prompts
Set max_tokens carefully
Validate JSON in your app
Best use case
Use JSON mode when another system needs to consume the AI result.
Method 20: Use DeepSeek API for function calling / tool calling
DeepSeek supports function calling compatible with OpenAI-style APIs. DeepSeek says function calling can support multiple functions in one call and parallel function calls. (api-docs.deepseek.com)
Best for
Agents
Database lookup
Weather/search tools
Internal APIs
Ticket creation
Server automation
Concept
Instead of only answering text, the model can decide:
“I need to call a function.”
Example functions:
get_user_order_status()
search_knowledge_base()
create_jira_ticket()
check_server_cpu()
restart_failed_service()
Pros
Turns model into an agent
Connects AI to real systems
Useful for enterprise workflows
Cons
You must implement function execution safely
Never allow dangerous commands without approval
Needs strong permission design
Best use case
Use function calling for internal AI agents that need to query databases, APIs, monitoring systems, or ticketing tools.
Method 21: Use DeepSeek API for FIM / fill-in-the-middle code completion
DeepSeek supports FIM Completion in beta for code-completion-like workflows. FIM means you provide the beginning and ending of code, and the model fills the missing middle. DeepSeek documents FIM as a beta /completions feature and says it is commonly used for code completion. (api-docs.deepseek.com)
Best for
Code editor autocomplete
Completing functions
Generating missing logic
IDE extensions
Custom coding tools
Concept
Input:
prefix: function start
suffix: function end
model fills: missing middle
Pros
Better for autocomplete than normal chat
Useful for IDE-like tools
Good for code generation between existing context
Cons
Beta feature
Not needed for normal chatbot use
Client support varies
Best use case
Use FIM if you are building your own coding assistant or editor extension.
Method 22: Use DeepSeek through local/open-weight models with Ollama
This is different from using DeepSeek’s hosted API. DeepSeek also releases open-weight models on platforms like Hugging Face, and local runners like Ollama host DeepSeek model variants. Ollama lists DeepSeek models such as deepseek-r1 and deepseek-v3.1, with different sizes/tags depending on the model. (Hugging Face)
Best for
Local privacy
Offline experiments
No API bill during testing
Learning
Small local coding assistant
Installation
Install Ollama.
On Linux:
curl -fsSL https://ollama.com/install.sh | sh
Run a DeepSeek model:
ollama run deepseek-r1
For smaller machines, use smaller tags, for example:
ollama run deepseek-r1:7b
Use Ollama API
Ollama exposes a local API, often at:
http://localhost:11434
Example:
curl http://localhost:11434/api/generate \
-d '{
"model": "deepseek-r1",
"prompt": "Explain Linux file permissions with examples."
}'
Pros
Local/private
No hosted API cost
Good for experiments
Can work offline after model download
Cons
Quality depends on local model size
Large DeepSeek models require serious hardware
Not the same as DeepSeek hosted V4 API
Can be slower on CPU/laptop
Best use case
Use Ollama for local experiments, privacy-sensitive drafts, and low-cost learning.
Method 23: Serve DeepSeek models yourself with vLLM
vLLM provides an OpenAI-compatible HTTP server for serving models. vLLM docs say it implements OpenAI Completions, Chat API, and more, allowing interaction through HTTP clients. (docs.vllm.ai)
Best for
Self-hosted production inference
GPU servers
Enterprise deployment
OpenAI-compatible local endpoint
High-throughput serving
Basic concept
You download/serve a DeepSeek-compatible model and expose:
/chat/completions
similar to OpenAI-compatible APIs.
Example command pattern
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
--host 0.0.0.0 \
--port 8000
Then call:
curl http://localhost:8000/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
"messages": [
{
"role": "user",
"content": "Explain Kubernetes Ingress."
}
]
}'
Pros
Full infrastructure control
OpenAI-compatible local server
Good for internal enterprise workloads
Can integrate with Open WebUI/LiteLLM
Cons
Needs GPU knowledge
Needs server management
You handle scaling, security, monitoring
Large models are expensive to host
Best use case
Use vLLM if your company wants to self-host models and expose an internal OpenAI-compatible API.
Method 24: Use DeepSeek in no-code/low-code automation tools
Even if a tool has no DeepSeek plugin, you can often use DeepSeek through an HTTP request step because the API is simple JSON over HTTPS.
Best for
n8n workflows
Make/Zapier-style automations
Google Sheets automation
Form processing
Email summarization
Lead classification
Generic HTTP setup
Method:
POST
URL:
https://api.deepseek.com/chat/completions
Headers:
Content-Type: application/json
Authorization: Bearer YOUR_DEEPSEEK_API_KEY
Body:
{
"model": "deepseek-v4-flash",
"messages": [
{
"role": "system",
"content": "You are an automation assistant."
},
{
"role": "user",
"content": "Summarize this lead inquiry and classify priority."
}
]
}
Pros
No coding required
Good for business automation
Easy to connect forms, sheets, emails, CRMs
Cons
Secrets must be stored carefully
Error handling can be weak
Complex agents are harder to build
Best use case
Use this for lead processing, email summary, blog outline generation, CRM enrichment, support ticket classification, and SEO workflows.
Method 25: Use DeepSeek inside your own chatbot or website widget
You can build your own chatbot UI and call DeepSeek from your backend.
Best for
Customer support chatbot
Website assistant
Documentation assistant
SaaS help bot
Internal employee bot
Safe architecture
Browser UI
↓
Your backend API
↓
DeepSeek API
Never call DeepSeek directly from frontend JavaScript because your API key will be exposed.
Node backend example
app.post("/api/chat", async (req, res) => {
const userMessage = req.body.message;
const response = await client.chat.completions.create({
model: "deepseek-v4-flash",
messages: [
{
role: "system",
content: "You are a helpful support assistant."
},
{
role: "user",
content: userMessage
}
]
});
res.json({
answer: response.choices[0].message.content
});
});
Pros
Full control over UI
Can connect to your database
Can add login, history, analytics
Can add RAG and business rules
Cons
You must build security
Need rate limits
Need abuse protection
Need cost monitoring
Best use case
Use this for production SaaS and business websites.
Method 26: Use DeepSeek through OpenRouter or third-party model gateways
Some model gateways provide access to DeepSeek models through one unified API. This is different from DeepSeek’s official API.
Best for
Comparing providers
Fallback routing
One API key for many models
Testing availability
Generic setup
Provider: OpenRouter or gateway
Base URL: gateway URL
API key: gateway key
Model: provider-specific DeepSeek model ID
Pros
One key for many models
Can compare providers
May help during official API outages
Cons
Not official DeepSeek API
Pricing and latency differ
Model versions may differ
Data path includes another provider
Best use case
Use gateways when you want fallback or multi-model routing, but use official DeepSeek API when you want the cleanest direct path.
Which method should you choose?
For command-line coding like Claude Code / Codex
Use:
1. OpenCode + DeepSeek
2. Claude Code + DeepSeek Anthropic endpoint
3. Aider + DeepSeek
4. Crush + DeepSeek
For VS Code coding
Use:
1. Continue.dev + DeepSeek
2. Cline + DeepSeek
3. Cursor/custom OpenAI-compatible setup
For application development
Use:
1. Python OpenAI SDK
2. Node.js OpenAI SDK
3. Laravel HTTP client
4. LangChain
5. LlamaIndex
For company-wide AI platform
Use:
1. LiteLLM gateway
2. Open WebUI
3. vLLM self-hosting
4. RAG stack with LlamaIndex/LangChain
For local/private experiments
Use:
1. Ollama
2. LM Studio
3. vLLM
4. Open WebUI + local backend
Recommended setup for developers
For a practical developer, I would use this stack:
Daily terminal coding:
OpenCode + DeepSeek V4 Pro
Git-based code editing:
Aider + DeepSeek
VS Code:
Continue.dev or Cline + DeepSeek
Backend apps:
Python/Node/Laravel direct API
Team chat UI:
Open WebUI + DeepSeek API
Production gateway:
LiteLLM + DeepSeek
Common mistakes and fixes
Mistake 1: Searching for official DeepSeek CLI installer
DeepSeek is mainly a model/API provider. For CLI coding, use tools like OpenCode, Claude Code with DeepSeek endpoint, Aider, Crush, or Cline.
Mistake 2: Using deprecated model names in new tutorials
Avoid relying only on:
deepseek-chat
deepseek-reasoner
Prefer:
deepseek-v4-pro
deepseek-v4-flash
DeepSeek’s docs say the older names are compatibility aliases and are scheduled to be retired. (api-docs.deepseek.com)
Mistake 3: Wrong base URL
For raw API and OpenAI SDK:
https://api.deepseek.com
For some OpenAI-compatible tools:
https://api.deepseek.com/v1
For Anthropic-compatible tools:
https://api.deepseek.com/anthropic
Mistake 4: Exposing API key in frontend
Bad:
Browser → DeepSeek API
Good:
Browser → Your backend → DeepSeek API
Mistake 5: Sending secrets in logs
Before sending logs to DeepSeek, mask:
passwords
tokens
API keys
database credentials
private keys
customer data
Final conclusion
DeepSeek can be used in many ways, but all methods fall into a few major categories:
Official chat
Direct API
OpenAI-compatible SDKs
Anthropic-compatible tools
Terminal coding agents
VS Code/IDE assistants
AI frameworks
RAG frameworks
LLM gateways
Self-hosted chat UIs
Local open-weight models
Production backend integration
No-code automation
Self-hosted inference
For your case — coding from command line like Claude or Codex — the best choices are:
OpenCode + DeepSeek V4 Pro
Aider + DeepSeek
Claude Code + DeepSeek Anthropic endpoint
Crush + DeepSeek
For building products, use:
Laravel/PHP backend
Node.js backend
Python backend
LangChain/LlamaIndex
LiteLLM gateway
Open WebUI
That combination gives you both:
developer productivity and production-ready DeepSeek API integration.