Discord Verification Bot in Python: a Button and a Question Before Joining

Before the bot: what Discord already has

Every Discord server has a verification level in its settings. According to Discord's documentation there are five: none; verified email; account older than 5 minutes; member of your server for more than 10 minutes; and verified phone. Raise it first: it costs nothing and stops a lot of spam.

Community servers can also require members to accept the rules before talking. Until they do, Discord marks them as “pending”, and Discord's documentation says a pending member can't use buttons or commands. If you have it on, the order is: first they accept the rules, then they click your bot's button.

The bot adds what Discord doesn't: a question an automated account won't answer, and a role that only opens the channels to whoever answered it.

1. Set up the server: one role and one channel

1. Create the “Verified” role

   In Server Settings → “Roles”, create a “Verified” role with the “View Channels” permission. Take “View Channels” away from @everyone: that way, without the role nothing is visible.

2. Create the verification channel

   A text channel, for example #verification, that @everyone can see (in “Edit Channel” → “Permissions”, “View Channel” allowed for @everyone and “Send Messages” denied: only the button is needed).

3. Copy the role ID

   Turn on Developer Mode (User Settings → “Advanced”), right-click the “Verified” role and “Copy Role ID”. It goes in the .env file.

2. Invite the bot with “Manage Roles”

If you don't have the application and the token yet, follow the first step of the Python Discord bot guide. For this bot, tick “bot” and “applications.commands” in the invite link and the permissions “View Channels”, “Send Messages” and “Manage Roles”. The bot permissions calculator builds the link for you.

What fails most: a bot can only give roles that are below its own. In “Roles”, drag the bot's role (it has the bot's name) above “Verified”. It needs no privileged intent: it doesn't read messages, it only handles the button.

3. The full code

Three files. The button never expires (timeout=None and a fixed custom_id) and setup_hook registers it again at startup, so the message you post keeps working after every restart. The question is a sum that changes every time, in a Discord pop-up, and the replies are only seen by whoever clicked (ephemeral).

discord.py
python-dotenv

DISCORD_TOKEN=paste-your-token-here
VERIFIED_ROLE=the-role-id

import os
import random

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()

VERIFIED_ROLE = int(os.environ["VERIFIED_ROLE"])  # the ID of the role that gives access


class Question(discord.ui.Modal, title="A quick question"):
    def __init__(self):
        super().__init__()
        # A new sum every time someone clicks the button
        self.a, self.b = random.randint(2, 9), random.randint(2, 9)
        self.answer = discord.ui.TextInput(label=f"What is {self.a} + {self.b}?", max_length=3)
        self.add_item(self.answer)

    async def on_submit(self, interaction: discord.Interaction):
        if self.answer.value.strip() != str(self.a + self.b):
            await interaction.response.send_message("That's not right. Click the button and try again.", ephemeral=True)
            return
        role = interaction.guild.get_role(VERIFIED_ROLE)
        await interaction.user.add_roles(role, reason="Passed verification")
        await interaction.response.send_message("Done! You can now see the rest of the server.", ephemeral=True)


class Verify(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=None)  # never expires: the button always works

    @discord.ui.button(label="Verify me", style=discord.ButtonStyle.success, custom_id="verification:button")
    async def verify(self, interaction: discord.Interaction, button: discord.ui.Button):
        if interaction.user.get_role(VERIFIED_ROLE):
            await interaction.response.send_message("You're already verified.", ephemeral=True)
            return
        await interaction.response.send_modal(Question())


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

    async def setup_hook(self):
        # Listen again to the buttons posted before the restart
        self.add_view(Verify())
        await self.tree.sync()


client = MyBot()


@client.tree.command(name="post-verification", description="Posts the message with the verification button")
@app_commands.default_permissions(administrator=True)
@app_commands.guild_only()
async def post(interaction: discord.Interaction):
    await interaction.channel.send(
        "👋 Welcome! Click “Verify me” and answer one question to see the rest of the server.",
        view=Verify(),
    )
    await interaction.response.send_message("Posted.", ephemeral=True)


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

4. Post the button and test it

1. Start the bot

   On your computer, with Python 3.10 or newer: pip install -r requirements.txt and python app.py. If the command doesn't show up when you type /, it can take a while the first time: why slash commands don't show up.

2. Post the message

   In #verification type /post-verification. Only admins see it (default_permissions). The bot leaves the message with the “Verify me” button; you post it once and it works forever.

3. Test it with another account

   Join with an account that isn't an admin (an admin sees everything anyway), click the button, answer the sum and check that the channels appear.

If the button fails

“Missing Permissions” (403) in the console when giving the role: the bot lacks “Manage Roles” or its role is below “Verified”. Move its role up the list.

Discord says “This interaction failed”: the bot is offline, or the button wasn't registered at startup (self.add_view missing in setup_hook, or the custom_id in the code isn't the one in the posted message). A posted button only works while its bot is online.

The role is given but the channels don't appear: it's a channel permission. Some channel denies “View Channel” to “Verified” or only allows it for another role; check it in “Edit Channel” → “Permissions”.

Prefer JavaScript? In discord.js it's the same with ButtonBuilder, ModalBuilder and member.roles.add; the bot's base is in the discord.js guide.

Watch out for fake “verification bots”

There are scams dressed up as verification: a bot or a link that, to “verify” you, asks you to scan a QR code, log in on a site that isn't discord.com or run something in your browser. That's how they take over your account session. On GitHub there are even repositories that say so in their own description.

The verification in this guide never leaves Discord: a button, a Discord pop-up with a question and a role. If you copy a verification bot from the internet, read the code before giving it your token, and never ask for anything other than clicking a button. And if your token has ever been public, change it in the developer portal (“Reset Token”).

Keeping it online all the time

This bot has to be online around the clock: if it's offline when someone joins, the button fails and that person is left outside. On your computer that means leaving it on day and night; hosting it is better. Free and paid options, compared, in where to host your Discord bot.

NapNodes has a free 256 MB bot that isn't turned off for being idle; you renew it every 7 days with “Start” (its catches, in this guide). Create it, switch it to Python in “Settings” → “Language”, upload the three files in “Files” and click “Start”: the libraries in requirements.txt install themselves and app.py is the startup file already set. So you don't have to renew it, the Mini plan (512 MB) stays online all the time.

Frequently asked questions