You want a Discord bot that answers in your server’s voice, costs pennies a day, and uses an open-weight model you can swap out later. A DeepSeek Discord bot built on `deepseek-v4-flash` gets you there: 1,000,000-token context, OpenAI-compatible SDK, and input-miss pricing of $0.14 per million tokens as of April 2026. The tutorial below walks through registering a Discord application, wiring up `discord.py` 2.7.1 to the DeepSeek `POST /chat/completions` endpoint, adding slash commands and streaming, controlling spend with context caching, and shipping the bot to a small VPS. By the end you’ll have a working bot, a cost model, and a checklist for keeping it healthy.

What you’ll build

The bot in this guide listens on Discord for two things: an /ask slash command (one-shot question, optional thinking mode) and an @mention in any channel it can read (multi-turn chat that remembers the last few messages). Replies stream into Discord as they generate, so users see tokens arrive instead of waiting for a wall of text. Cost lives on deepseek-v4-flash by default, with an opt-in flag to escalate a single question to deepseek-v4-pro for harder problems.

You can extend the same skeleton to summarise threads, translate messages, or run a moderator assistant. For a different chat surface using the same underlying model, see our DeepSeek Telegram bot tutorial — about 80 % of the code is shared.

Prerequisites

• Python 3.10+ (3.11 or 3.12 recommended).
• A Discord account with permission to create applications at the Developer Portal.
• A DeepSeek API key — see get a DeepSeek API key if you don’t have one.
• ~$5 of API balance for testing. A small server burns through cents, not dollars.
• A machine that stays online — your laptop for testing, a $5/month VPS or a free-tier Fly.io machine for production.

The model and endpoint you’re calling

DeepSeek’s current generation is DeepSeek V4, released April 24, 2026, and shipped as two open-weight Mixture-of-Experts models under the MIT license. DeepSeek V4-Flash is the cost-efficient tier (284B total parameters, 13B active) and is the right default for a chat bot. DeepSeek V4-Pro is the frontier tier (1.6T / 49B active) for harder reasoning or coding work. Both share a 1,000,000-token context window with up to 384,000 output tokens.

Chat requests hit POST /chat/completions, the OpenAI-compatible endpoint at https://api.deepseek.com. Once you have an API key you can access DeepSeek using example scripts in the OpenAI API format; the same endpoint accepts a stream parameter, and an Anthropic-compatible surface is available against the same base URL. Thinking mode is a request parameter on either V4 model, not a separate model ID — set reasoning_effort="high" with extra_body={"thinking": {"type": "enabled"}} to enable it.

If you maintain an older bot using deepseek-chat or deepseek-reasoner, those legacy IDs still work but route to deepseek-v4-flash. DeepSeek has stated that deepseek-chat and deepseek-reasoner will be fully retired and inaccessible after July 24, 2026, 15:59 UTC, and are currently routed to deepseek-v4-flash in both modes. Migration is a one-line model= swap; the base_url does not change.

Step 1: Register a Discord application and bot

1. Open discord.com/developers/applications and click New Application. Give it a name (the bot’s display name).
2. In the left sidebar, open Bot. Click Reset Token and copy the token to your password manager. You will not see it again.
3. Still under Bot, scroll to Privileged Gateway Intents and toggle on Message Content Intent (required to read @mention text) and Server Members Intent.
4. Open OAuth2 → URL Generator. Tick bot and applications.commands under scopes, then under bot permissions tick Send Messages, Read Message History, Use Slash Commands, and Embed Links.
5. Copy the generated URL into a browser and invite the bot to a test server you own.

Step 2: Install dependencies

Create a project folder and a virtual environment, then install the two libraries you need. discord.py is a Python wrapper for the Discord API; the latest version, 2.7.1, was released March 3, 2026.

python3 -m venv .venv
source .venv/bin/activate          # Windows: .venvScriptsactivate
pip install -U "discord.py==2.7.1" "openai>=1.40.0" python-dotenv

Create a .env file in the project root:

DISCORD_TOKEN=paste-your-bot-token-here
DEEPSEEK_API_KEY=paste-your-deepseek-key-here

Add .env to .gitignore immediately. Leaking either token is a bad afternoon.

Step 3: Minimal working bot

Save the following Python as bot.py. It registers a single /ask slash command that forwards the user’s question to DeepSeek and replies with the answer.

import os
import discord
from discord import app_commands
from dotenv import load_dotenv
from openai import AsyncOpenAI

load_dotenv()

deepseek = AsyncOpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

SYSTEM_PROMPT = (
    "You are a concise Discord assistant. "
    "Answer in under 1500 characters. Use Markdown for code."
)

intents = discord.Intents.default()
intents.message_content = True

class Bot(discord.Client):
    def __init__(self):
        super().__init__(intents=intents)
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()

bot = Bot()

@bot.tree.command(name="ask", description="Ask DeepSeek a question")
@app_commands.describe(prompt="What do you want to ask?", think="Use thinking mode")
async def ask(interaction: discord.Interaction, prompt: str, think: bool = False):
    await interaction.response.defer(thinking=True)
    kwargs = {
        "model": "deepseek-v4-flash",
        "messages": [
            {"role": "system", "content": SYSTEM_PROMPT},
            {"role": "user", "content": prompt},
        ],
        "max_tokens": 1024,
        "temperature": 1.3,
    }
    if think:
        kwargs["reasoning_effort"] = "high"
        kwargs["extra_body"] = {"thinking": {"type": "enabled"}}
        kwargs.pop("temperature", None)  # ignored in thinking mode

    resp = await deepseek.chat.completions.create(**kwargs)
    answer = resp.choices[0].message.content or "(empty response)"
    await interaction.followup.send(answer[:1990])

bot.run(os.environ["DISCORD_TOKEN"])

Run it: python bot.py. In Discord, type /ask in any channel where the bot is present and ask a question. The first slash-command sync can take a minute to propagate to the Discord client.

A few details worth understanding before moving on:

• Async client. The OpenAI SDK ships an AsyncOpenAI class. Using the sync client inside discord.py would block the event loop and freeze the bot under load.
• Temperature 1.3 matches DeepSeek’s official guidance for general conversation. Use 0.0 for code, 1.5 for creative writing.
• Thinking mode rules. Thinking mode does not support temperature, top_p, presence_penalty, or frequency_penalty; for compatibility, setting these will not trigger an error but will have no effect. The code drops temperature when think=True.
• Defer the interaction. Discord requires a response within 3 seconds. defer() buys you up to 15 minutes.

Step 4: Add multi-turn @mention chat

The API is stateless — DeepSeek does not remember prior turns on its side, so the client must resend the conversation history with every request. Contrast this with the DeepSeek web chat and mobile app, which keep session state for the user. To support a back-and-forth conversation in Discord, the bot has to read recent channel messages and rebuild the message list itself.

Add this handler to bot.py above bot.run(...):

HISTORY_TURNS = 6  # last 6 message pairs ≈ ~1500 input tokens typical

@bot.event
async def on_message(message: discord.Message):
    if message.author == bot.user or bot.user not in message.mentions:
        return

    # Build conversation history from the channel
    history = []
    async for m in message.channel.history(limit=HISTORY_TURNS * 2):
        if m.author == bot.user:
            history.append({"role": "assistant", "content": m.clean_content})
        elif bot.user in m.mentions:
            text = m.clean_content.replace(f"@{bot.user.display_name}", "").strip()
            history.append({"role": "user", "content": text})
    history.reverse()

    messages = [{"role": "system", "content": SYSTEM_PROMPT}, *history]

    async with message.channel.typing():
        resp = await deepseek.chat.completions.create(
            model="deepseek-v4-flash",
            messages=messages,
            max_tokens=1024,
            temperature=1.3,
        )
    await message.reply(resp.choices[0].message.content[:1990])

Cap the history. Six turns is plenty for casual conversation and keeps your input bill predictable. If you want long-running threads, store conversation IDs in SQLite and prune by token count rather than message count.

Step 5: Stream replies into Discord

Streaming makes the bot feel faster even when it isn’t. Discord allows up to five message edits per second per channel, so you can update a single placeholder message with the partial response.

import asyncio

async def stream_to_message(stream, placeholder: discord.Message):
    buffer = ""
    last_edit = 0.0
    async for chunk in stream:
        delta = chunk.choices[0].delta.content or ""
        buffer += delta
        now = asyncio.get_event_loop().time()
        if now - last_edit > 0.7 and buffer:
            await placeholder.edit(content=buffer[:1990])
            last_edit = now
    await placeholder.edit(content=(buffer or "(empty)")[:1990])

Then call it from your handler with stream=True on the chat-completion request. The placeholder pattern — send a “thinking…” message, then edit it as tokens arrive — keeps the API call count to one and respects Discord’s rate limits.

Step 6: Verify it worked

Run through this checklist before claiming victory:

• Slash command appears. Type / in a channel and confirm /ask shows up. If not, give it 60 seconds and retry — global command sync is cached.
• Mention reply works. Type @YourBot what's 2+2?. You should see a typing indicator and then a reply.
• Thinking mode flag. Run /ask prompt:"Plan a 3-day Tokyo itinerary" think:True. The reply should be slower and more structured.
• Cost dashboard. Open the DeepSeek billing console and confirm token usage is logged.

Cost: a worked example for a 100-user server

Assume a small server: 1,000 bot interactions per month, average 800 input tokens (system prompt + history) and 400 output tokens. The system prompt repeats so DeepSeek’s context cache will hit on the prefix; the per-call user message is always an uncached miss against that prefix.

Rates as of April 2026 — confirm against the DeepSeek API pricing page before committing budget. The example below costs out deepseek-v4-flash:

Input, cache hit (system 600 tokens × 1,000)   :   600,000 × $0.028/M = $0.0168
Input, cache miss (200 tokens × 1,000)         :   200,000 × $0.14/M  = $0.0280
Output (400 tokens × 1,000)                    :   400,000 × $0.28/M  = $0.1120
                                                                       --------
Total                                                                    $0.1568

Roughly $0.16/month for a thousand replies. The same workload on deepseek-v4-pro at $0.145 / $1.74 / $3.48 per 1M tokens runs about $1.83 — about 11× the cost, which only makes sense for harder questions. For more aggressive cost controls see the page on DeepSeek context caching.

Common errors and fixes

JSON mode deserves its own line. Setting response_format to json_object enables JSON Output; you must also instruct the model to produce JSON via a system or user message, otherwise the model may generate an unending stream of whitespace until the token limit, resulting in a long-running and seemingly stuck request. The DeepSeek docs describe JSON mode as designed to return valid JSON, not guaranteed — handle empty content gracefully and always include an example schema.

Hardening for production

• Rate-limit per user. A simple in-memory defaultdict with timestamps stops one user from spending your monthly budget in an afternoon.
• Allow-list channels. Pass a CHANNEL_IDS env var and reject messages from anywhere else.
• Log usage. The API response includes usage.prompt_cache_hit_tokens and usage.prompt_cache_miss_tokens — write them to SQLite to monitor cache effectiveness.
• Wrap the call in try/except for openai.APIError and asyncio.TimeoutError. Reply with a friendly message instead of crashing.
• Run under a process supervisor (systemd, pm2, Fly.io machines). The bot must reconnect after gateway disconnects, which discord.py handles, but the process itself can OOM.

Next steps

From here, two natural extensions are worth your time:

1. Sharpen the bot’s voice with stronger system prompts — see DeepSeek prompt engineering for patterns that work in chat-style applications.
2. Give it knowledge about your server’s wiki, FAQ, or codebase by wiring up retrieval-augmented generation. The DeepSeek RAG tutorial walks through embeddings, chunking, and a vector store.

If you’d like the same workflow on the web instead, the broader DeepSeek tutorials hub indexes every step-by-step guide on the site.

Last verified: 2026-04-25. DeepSeek AI Guide is an independent resource and is not affiliated with DeepSeek or its parent company. Model IDs, pricing and API behaviour change; check the official DeepSeek documentation and pricing page before committing to a production decision.