Subclassing Context in

Start by reading the guide on subclassing the Bot class. A subclass of Bot has to be used to inject your custom context subclass into


The way this works is by creating a subclass of's Context class adding whatever functionality you wish. Usually this is done by adding custom methods or properties, so that you don't need to copy it around or awkwardly import it elsewhere.

This guide will show you how to add a prompt() method to the context and how to use it in a command.

Example subclass and code

The first part - of course - is creating the actual context subclass. This is done similarly to creating a bot subclass, it will look like this:

import asyncio
from typing import Optional

from discord import RawReactionActionEvent
from discord.ext import commands

class CustomContext(commands.Context):
    async def prompt(
            message: str,
    ) -> Optional[bool]:
        """Prompt the author with an interactive confirmation message.

        This method will send the `message` content, and wait for max `timeout` seconds
        (default is `30`) for the author to react to the message.

        If `delete_after` is `True`, the message will be deleted before returning a
        True, False, or None indicating whether the author confirmed, denied,
        or didn't interact with the message.
        msg = await self.send(message)

        for reaction in ('✅', '❌'):
            await msg.add_reaction(reaction)

        confirmation = None

        # This function is a closure because it is defined inside of another
        # function. This allows the function to access the self and msg
        # variables defined above.

        def check(payload: RawReactionActionEvent):
            # 'nonlocal' works almost like 'global' except for functions inside of
            # functions. This means that when 'confirmation' is changed, that will
            # apply to the variable above
            nonlocal confirmation

            if payload.message_id != or payload.user_id !=
                return False

            emoji = str(payload.emoji)

            if emoji == '✅':
                confirmation = True
                return True

            elif emoji == '❌':
                confirmation = False
                return True

            # This means that it was neither of the two emojis added, so the author
            # added some other unrelated reaction.
            return False

            await'raw_reaction_add', check=check, timeout=timeout)
        except asyncio.TimeoutError:
            # The 'confirmation' variable is still None in this case

        if delete_after:
            await msg.delete()

        return confirmation

After creating your context subclass, you need to override the get_context() method on your Bot class and change the default of the cls parameter to this subclass:

from discord.ext import commands

class CustomBot(commands.Bot):
    async def get_context(self, message, *, cls=CustomContext):  # From the above codeblock
        return await super().get_context(message, cls=cls)

Now that is using your custom context, you can use it in a command. For example:

import discord
from discord.ext import commands

# Enable the message intent so that we get message content. This is needed for
# the commands we define below
intents = discord.Intents.default()
intents.message_content = True

# Replace '...' with any additional arguments for the bot
bot = CustomBot(intents=intents, ...)

async def massban(ctx: CustomContext, members: commands.Greedy[discord.Member]):
    prompt = await ctx.prompt(f"Are you sure you want to ban {len(members)} members?")
    if not prompt:
        # Return if the author cancelled, or didn't react in time

    ...  # Perform the mass-ban, knowing the author has confirmed this action