Build a Discord Bot With Python

1What a Discord Bot Does

A Discord bot is a program that logs into Discord as an automated user and reacts to events — messages, commands, members joining — in real time. In Python you build one with discord.py, a library that wraps Discord's API and gateway so you can focus on your bot's behavior.

It is a fun and instructive project because it forces you to work with asynchronous code, event-driven design, and API authentication, all while producing something interactive you can use with friends. You will write async functions, handle secrets responsibly, and register commands that appear right in Discord's UI.

2Creating the Application and Bot

Before writing code, register your bot with Discord. Go to the Discord Developer Portal, create a new application, then add a bot user to it. Discord generates a secret token that authenticates your program — treat it like a password.

From the OAuth2 section, generate an invite URL with the bot scope and the permissions your bot needs, then use it to add the bot to a server you manage. Only then will your code have somewhere to act.

• Open the Discord Developer Portal and create a New Application.
• Under the Bot tab, add a bot and copy (then reset if needed) its token.
• Enable required intents, including Message Content if you read message text.
• Under OAuth2 URL Generator, select bot scope and permissions.
• Open the generated URL to invite the bot to your server.

3Installing discord.py

Install the library into a virtual environment with pip. discord.py is actively maintained and supports modern slash commands through its app_commands module.

You will also want python-dotenv so you can keep your token in a .env file instead of hardcoding it, which is the single most important security habit for bot development.

• python -m venv venv && source venv/bin/activate
• pip install discord.py python-dotenv

4Intents and the Token

Discord uses intents to control which events your bot receives. You must declare them when creating the client, and some — like message content — are privileged and must also be toggled on in the Developer Portal. Requesting only what you need keeps your bot efficient and compliant.

Load the token from the environment rather than pasting it into your code. A leaked token lets anyone control your bot, so keep it out of source control entirely.

import os, discord
from dotenv import load_dotenv
load_dotenv()
TOKEN = os.getenv('DISCORD_TOKEN')
intents = discord.Intents.default()
intents.message_content = True

5Responding to Events

The classic first bot listens for messages and replies. With discord.py you subclass or configure a client and decorate async functions with event handlers like on_ready and on_message. Because Discord is real-time, everything is asynchronous — your handlers are async def functions that await network calls.

Always ignore messages from the bot itself in on_message, or a bot that replies to 'hello' could end up replying to its own reply in an endless loop.

• client = discord.Client(intents=intents)
• @client.event
• async def on_message(message):
• if message.author == client.user: return
• if message.content == '!ping':
• await message.channel.send('Pong!')

6Adding Slash Commands

Modern Discord bots use slash commands, which appear in the command menu when a user types '/'. They are discoverable, support typed arguments, and are the recommended approach over parsing raw message text. discord.py exposes them through the app_commands system, usually via a commands.Bot and its command tree.

After defining commands you must sync them with Discord so they show up. Syncing to a single test guild is instant, while global syncing can take up to an hour to propagate.

from discord.ext import commands
bot = commands.Bot(command_prefix='!', intents=intents)
@bot.tree.command(name='greet', description='Say hello')
async def greet(interaction, name: str):
    await interaction.response.send_message(f'Hello, {name}!')
# in on_ready: await bot.tree.sync()

7Running and Hosting the Bot

Start the bot by calling client.run(TOKEN). While it runs, it stays connected to Discord's gateway and responds instantly. During development you run it from your own machine, but a bot needs to stay online to be useful.

For always-on hosting, deploy to a small cloud server or a platform-as-a-service. Keep the process alive with a service manager and set your token as an environment variable in the host's settings rather than uploading a .env file.

• Test locally with python bot.py while developing.
• For production, run on a VPS or a hosting platform.
• Set the token as an environment variable on the host.
• Use a process manager or systemd so the bot restarts on crash.
• Monitor logs so you catch errors and rate limits early.

8Best Practices

A few habits keep your bot secure, responsive, and easy to grow.

• Keep the token in an environment variable — never in code or Git.
• Request only the intents your bot actually uses.
• Prefer slash commands over parsing raw message content.
• Ignore the bot's own messages to prevent reply loops.
• Never block the event loop with slow synchronous code — use async libraries.

9Key Takeaways

Building a Discord bot is a hands-on lesson in async, events, and auth.

• discord.py connects to Discord's gateway and dispatches events to async handlers.
• Register an application, add a bot user, and guard its token carefully.
• Enable only the intents you need — message content is privileged.
• Use slash commands via app_commands, and sync them so they appear.
• Host the bot somewhere always-on and load the token from the environment.

10Frequently Asked Questions

Q: Why can't my bot read message content? A: Message content is a privileged intent. You must enable it both in your code (intents.message_content = True) and in the Bot settings of the Discord Developer Portal. Without both, message.content comes back empty.

Q: Should I use slash commands or message commands? A: Slash commands are the modern, recommended approach — they are discoverable in Discord's menu and support typed arguments. Message-based commands still work but require reading message content and manual parsing.

Q: Why don't my slash commands appear? A: You must sync the command tree with Discord. Syncing to a specific test guild is instant; global sync can take up to an hour to propagate to all servers.

Q: How do I keep my bot token safe? A: Store it in an environment variable or a .env file that is listed in .gitignore, and never commit it. If it leaks, reset the token immediately in the Developer Portal.