How to build a Discord bot with discord.js or discord.py, from portal to server

What is a Discord bot, and what do you need to build one?

Discord’s documentation calls bots apps. An app is code that talks to Discord through its APIs, and a bot user lets that app appear in a server like a member. Discord’s getting started guide says newly created apps have a bot user enabled by default. You write the code, run it somewhere, and Discord sends it events such as someone using a command.

• A Discord account and a test server. Build and test in a server that nobody else uses. Discord’s guide says you can create one for free.
• A language you can run. discord.js is for JavaScript and Node.js. discord.py is for Python; its documentation says it works with Python 3.8 or higher.
• A place to keep a secret. The bot token is a password. Discord says never to share it or check it into version control.
• One clear job. Pick a single command that does something useful before you add a second.

Unlike a website, a bot has no page to visit. It is a program that must be running to answer. That shapes everything about where you host it, which is covered below. For the general approach to choosing and scoping a build, see how to make an app.

How do you set up the app in the Discord Developer Portal?

Every bot starts in the Developer Portal. These steps follow Discord’s official quick start.

1. Create the app. Create a new application, give it a name and press Create. You land on General Information, which shows the Application ID.
2. Reset and copy the token. On the Bot page, click Reset Token under Token. Discord says you cannot view the token again unless you regenerate it, so put it straight into a password manager or your .env file.
3. Pick the installation contexts. On the Installation page, choose where the app can be installed: servers, users or both. Server-installed apps must be authorized by a member with the Manage Server permission. User-installed apps are limited to commands.
4. Add scopes. For Guild Install, add the applications.commands scope and the bot scope. Choosing bot reveals a Permissions menu; select only what you need, such as Send Messages.
5. Install it. Copy the Install Link from the Installation page, open it in a browser and choose Add to server. Select your test server. The bot appears in the member list, offline until your code runs.

Keep permissions minimal. A bot that only answers slash commands needs very few, and every extra permission is something a server owner has to trust you with.

How do you build the bot with discord.js?

discord.js is a widely used JavaScript library for Discord, and its guide is the reference for the patterns below. Check the discord.js README for the Node.js version it currently requires. Create a folder and set it up:

mkdir my-bot && cd my-bot
npm init -y
npm pkg set type=module
npm install discord.js
printf 'DISCORD_TOKEN=\nCLIENT_ID=\nGUILD_ID=\n' > .env
printf '.env\nnode_modules\n' > .gitignore

Fill in .env: the token from the Bot page, the Application ID as CLIENT_ID, and your test server’s ID as GUILD_ID. To copy a server ID, turn on Developer Mode in Discord’s advanced settings and right-click the server name. The discord.js guide recommends Node’s --env-file flag for loading environment variables, which the commands below use.

import { REST, Routes } from "discord.js";

const { DISCORD_TOKEN, CLIENT_ID, GUILD_ID } = process.env;

const rest = new REST({ version: "10" }).setToken(DISCORD_TOKEN);

await rest.put(
  Routes.applicationGuildCommands(CLIENT_ID, GUILD_ID),
  { body: [{ name: "ping", description: "Replies with Pong!" }] },
);

console.log("Registered /ping");

import { Client, Events, GatewayIntentBits } from "discord.js";

const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.once(Events.ClientReady, (readyClient) => {
  console.log(`Logged in as ${readyClient.user.tag}`);
});

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isChatInputCommand()) return;
  if (interaction.commandName === "ping") {
    await interaction.reply("Pong!");
  }
});

const { DISCORD_TOKEN } = process.env;
client.login(DISCORD_TOKEN);

node --env-file=.env register.js
node --env-file=.env index.js

Type /ping in your test server. Discord’s command documentation says guild commands update instantly and recommends them for quick testing, with global commands for when the bot is ready for public use. That is why the registration script targets one server. When you move to global commands, switch Routes.applicationGuildCommands to Routes.applicationCommands(CLIENT_ID).

How do you build the bot with discord.py?

discord.py does the same job in Python. Install it with python3 -m pip install -U discord.py, preferably inside a virtual environment, and set DISCORD_TOKEN and GUILD_ID in your shell before running.

import os
import discord
from discord import app_commands

GUILD = discord.Object(id=int(os.environ["GUILD_ID"]))


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

    async def setup_hook(self):
        self.tree.copy_global_to(guild=GUILD)
        await self.tree.sync(guild=GUILD)


bot = Bot()


@bot.tree.command(name="ping", description="Replies with Pong!")
async def ping(interaction: discord.Interaction):
    await interaction.response.send_message("Pong!")


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

The setup_hook copies the command to your test server and syncs it, so it appears at once. Choose the library by the language you already know. The features line up closely enough that a first bot is the same in either.

What are intents, and what limits apply to slash commands?

Intents decide which events Discord sends your bot. Discord’s quick start says standard intents need no extra configuration, while privileged intents expose potentially sensitive data such as message contents and must be toggled on the Bot page. Discord’s Gateway documentation lists the privileged intents as GUILD_PRESENCES, GUILD_MEMBERS and MESSAGE_CONTENT, and says apps in 100 or more guilds must be verified and have those intents approved.

The practical advice is to design around slash commands. Reacting to every message needs the message content intent, which is the one most likely to stop you later. A command like /summarize gets what it needs in the interaction itself. Discord’s application commands documentation sets these limits:

• Command names are 1 to 32 characters, and chat input names must be lowercase where a lowercase form exists.
• Descriptions are 1 to 100 characters.
• A command can have at most 25 options.
• A closed connection with code 4014 means you requested a privileged intent that is not enabled or approved.

Where do you host a Discord bot, and can an AI agent write it?

A bot that connects through the Gateway answers only while its process is running. A laptop that sleeps is an offline bot. For real use you need a small always-on server or a host that runs long-lived processes, and you set the token as an environment variable there, not in the repository. Discord’s quick start also shows the other model: an Interactions Endpoint URL, where Discord sends your app web requests instead of holding a connection, which does not need a process holding a connection open. Check each host’s plan terms for sleep and uptime before relying on it.

Bots suit AI coding agents well, since the code is small and the loop is quick: edit, restart, try the command. Give the agent the constraints so it does not invent ones. The free AI Coding Prompt Builder can draft the brief, and the agent guide covers the working method.

Build a Discord bot called [name] in [JavaScript with discord.js / Python with discord.py], in the project folder that is already open.

User: [the kind of server and the people who will use the bot].
Job: [the one thing the bot does, in one sentence].
Commands:
1. /[command]: [what it does, its options and what it replies]
2. /[command]: [what it does]

Rules:
- Slash commands only. Do not use the message content intent or any other privileged intent.
- Read DISCORD_TOKEN, CLIENT_ID and GUILD_ID from environment variables. Never write a token in code.
- Register commands to my test guild first, and show me how to switch to global commands later.
- Reply with an ephemeral message when a command fails, and never crash on bad input.
- Request the fewest permissions possible and tell me which ones you need and why.
- Keep data in memory or a local file for now; no database.

Out of scope: music, moderation, dashboards, payments.

Before writing code, list the files, the commands and the permissions you will use, then wait for my go-ahead. After each step, tell me how to run it and what I should see in Discord.

Not sure what to build? The Discord bot ideas list has small, scoped starting points, and the board has more under categories like social and gaming. Each idea has a generated build prompt. If you have a bot idea you will not build yourself, post it; it is free and needs no account.