Discord Role Bot: Buttons So Everyone Picks Their Own Roles (Python and JavaScript)

discord.py
python-dotenv

DISCORD_TOKEN=paste-your-token-here

import os

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()  # reads the token from the .env file

# Only the default intents are needed: buttons arrive as interactions.
client = discord.Client(intents=discord.Intents.default())
tree = app_commands.CommandTree(client)


@tree.command(name="role-panel", description="Posts a message with buttons to pick roles")
@app_commands.guild_only()
@app_commands.default_permissions(manage_roles=True)  # only visible to whoever manages roles
@app_commands.describe(
    title="What goes above the buttons",
    role1="A role people can pick",
    role2="Another role (optional)",
    role3="Another role (optional)",
    role4="Another role (optional)",
    role5="Another role (optional)",
)
async def role_panel(
    interaction: discord.Interaction,
    title: str,
    role1: discord.Role,
    role2: discord.Role | None = None,
    role3: discord.Role | None = None,
    role4: discord.Role | None = None,
    role5: discord.Role | None = None,
):
    roles = [r for r in (role1, role2, role3, role4, role5) if r]
    mine = interaction.guild.me.top_role
    # A bot can't give a role equal to or higher than its own, nor other bots' roles or @everyone.
    impossible = [r.name for r in roles if r >= mine or r.managed or r.is_default()]
    if impossible:
        await interaction.response.send_message(
            f"I can't give {', '.join(impossible)}: move my role above them in “Server Settings” → “Roles”.",
            ephemeral=True,
        )
        return
    view = discord.ui.View(timeout=None)
    for role in roles:
        # The role id goes in the button itself: no database needed.
        view.add_item(discord.ui.Button(label=role.name, custom_id=f"rid:{role.id}"))
    card = discord.Embed(title=title, description="Click a button to add or remove the role.", color=0x5B4AE8)
    await interaction.channel.send(embed=card, view=view)
    await interaction.response.send_message("Panel posted.", ephemeral=True)


@client.event
async def on_interaction(interaction: discord.Interaction):
    # Every button click arrives here, also on panels posted before the bot restarted.
    if interaction.type is not discord.InteractionType.component:
        return
    custom_id = interaction.data.get("custom_id", "")
    if not custom_id.startswith("rid:") or interaction.guild is None:
        return
    role = interaction.guild.get_role(int(custom_id[4:]))
    if role is None:
        await interaction.response.send_message("That role no longer exists.", ephemeral=True)
        return
    try:
        if role in interaction.user.roles:
            await interaction.user.remove_roles(role, reason="Role panel")
            text = f"I've removed {role.mention}."
        else:
            await interaction.user.add_roles(role, reason="Role panel")
            text = f"You now have {role.mention}."
    except discord.Forbidden:
        text = "I can't give you that role: tell whoever manages the server (my role has to be above it)."
    await interaction.response.send_message(text, ephemeral=True)


@client.event
async def on_ready():
    await tree.sync()  # publishes /role-panel
    print(f"Logged in as {client.user}")


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

{
  "name": "role-bot",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "discord.js": "^14.17.0",
    "dotenv": "^16.4.0"
  }
}

DISCORD_TOKEN=paste-your-token-here

require("dotenv").config(); // reads the token from the .env file
const {
  ActionRowBuilder,
  ButtonBuilder,
  ButtonStyle,
  Client,
  EmbedBuilder,
  Events,
  GatewayIntentBits,
  InteractionContextType,
  MessageFlags,
  PermissionFlagsBits,
  SlashCommandBuilder,
} = require("discord.js");

// Only Guilds is needed: buttons arrive as interactions.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

const command = new SlashCommandBuilder()
  .setName("role-panel")
  .setDescription("Posts a message with buttons to pick roles")
  .setContexts(InteractionContextType.Guild)
  .setDefaultMemberPermissions(PermissionFlagsBits.ManageRoles) // only visible to whoever manages roles
  .addStringOption((o) => o.setName("title").setDescription("What goes above the buttons").setRequired(true))
  .addRoleOption((o) => o.setName("role1").setDescription("Role").setRequired(true));
for (let n = 2; n <= 5; n++) command.addRoleOption((o) => o.setName(`role${n}`).setDescription("Another role (optional)"));

const privately = (content) => ({ content, flags: MessageFlags.Ephemeral });

client.on(Events.InteractionCreate, async (i) => {
  if (!i.inCachedGuild()) return;

  if (i.isChatInputCommand() && i.commandName === "role-panel") {
    const roles = [1, 2, 3, 4, 5].map((n) => i.options.getRole(`role${n}`)).filter(Boolean);
    const mine = i.guild.members.me.roles.highest;
    // A bot can't give a role equal to or higher than its own, nor other bots' roles or @everyone.
    const impossible = roles.filter((r) => r.managed || r.id === i.guildId || r.comparePositionTo(mine) >= 0);
    if (impossible.length) {
      const names = impossible.map((r) => r.name).join(", ");
      return i.reply(privately(`I can't give ${names}: move my role above them in “Server Settings” → “Roles”.`));
    }
    // The role id goes in the button itself: no database needed.
    const row = new ActionRowBuilder().addComponents(
      roles.map((r) => new ButtonBuilder().setCustomId(`rid:${r.id}`).setLabel(r.name).setStyle(ButtonStyle.Secondary)),
    );
    const card = new EmbedBuilder()
      .setColor(0x5b4ae8)
      .setTitle(i.options.getString("title"))
      .setDescription("Click a button to add or remove the role.");
    await i.channel.send({ embeds: [card], components: [row] });
    return i.reply(privately("Panel posted."));
  }

  // Every button click arrives here, also on panels posted before the bot restarted.
  if (i.isButton() && i.customId.startsWith("rid:")) {
    const role = i.guild.roles.cache.get(i.customId.slice(4));
    if (!role) return i.reply(privately("That role no longer exists."));
    let text;
    try {
      if (i.member.roles.cache.has(role.id)) {
        await i.member.roles.remove(role, "Role panel");
        text = `I've removed ${role}.`;
      } else {
        await i.member.roles.add(role, "Role panel");
        text = `You now have ${role}.`;
      }
    } catch {
      text = "I can't give you that role: tell whoever manages the server (my role has to be above it).";
    }
    await i.reply(privately(text));
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set([command.toJSON()]); // publishes /role-panel
  console.log(`Logged in as ${c.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);