Discord Giveaway Bot in Python: Enter Button, Random Winners and Rerolls

discord.py
python-dotenv

DISCORD_TOKEN=paste-your-token-here

import json
import os
import secrets
import time
from pathlib import Path

import discord
from discord import app_commands
from discord.ext import tasks
from dotenv import load_dotenv

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

# Giveaways are saved next to the bot: a restart doesn't wipe them.
GIVEAWAYS = Path("giveaways.json")
rng = secrets.SystemRandom()  # the system's randomness: nobody can guess who wins


def load() -> dict:
    return json.loads(GIVEAWAYS.read_text("utf-8")) if GIVEAWAYS.exists() else {}


def save(data: dict) -> None:
    GIVEAWAYS.write_text(json.dumps(data, ensure_ascii=False, indent=2), "utf-8")


class Enter(discord.ui.View):
    def __init__(self):
        super().__init__(timeout=None)  # no expiry: the button keeps working after a restart

    @discord.ui.button(label="Enter", emoji="🎉", style=discord.ButtonStyle.success, custom_id="giveaway:enter")
    async def enter(self, interaction: discord.Interaction, button: discord.ui.Button):
        data = load()
        giveaway = data.get(str(interaction.message.id))
        if giveaway is None or giveaway["ended"]:
            await interaction.response.send_message("This giveaway has already ended.", ephemeral=True)
            return
        entrants = giveaway["entrants"]
        if interaction.user.id in entrants:
            entrants.remove(interaction.user.id)
            text = "You've left the giveaway. If you change your mind, click again."
        else:
            entrants.append(interaction.user.id)
            text = f"You're in! {len(entrants)} entered so far. To leave, click again."
        save(data)
        await interaction.response.send_message(text, ephemeral=True)


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.add_view(Enter())  # listens again to the buttons already posted
        await self.tree.sync()  # publishes /giveaway and /reroll
        check.start()


bot = Bot()


async def channel_of(giveaway: dict):
    return bot.get_channel(giveaway["channel"]) or await bot.fetch_channel(giveaway["channel"])


async def announce(message_id: str, giveaway: dict, winners: list[int]) -> None:
    """Mentions the winners by replying to the giveaway card."""
    channel = await channel_of(giveaway)
    if winners:
        mentions = ", ".join(f"<@{w}>" for w in winners)
        text = f"🎉 Congratulations, {mentions}! Prize: **{giveaway['prize']}**."
    else:
        text = f"Nobody entered the **{giveaway['prize']}** giveaway."
    card = discord.MessageReference(message_id=int(message_id), channel_id=channel.id, fail_if_not_exists=False)
    await channel.send(text, reference=card)


async def close_card(message_id: str, giveaway: dict) -> None:
    """Removes the button and notes how many entered."""
    try:
        message = await (await channel_of(giveaway)).fetch_message(int(message_id))
        card = message.embeds[0]
        card.color = 0x888888
        card.set_footer(text=f"Ended · {len(giveaway['entrants'])} entrants")
        await message.edit(embed=card, view=None)
    except (discord.HTTPException, IndexError):
        pass  # the card was deleted: the result is already announced


@tasks.loop(seconds=30)
async def check():
    now = time.time()
    for message_id, giveaway in load().items():
        if giveaway["ended"] or giveaway["end"] > now:
            continue
        # First it closes (nobody else can enter), then it picks.
        data = load()
        data[message_id]["ended"] = True
        save(data)
        giveaway = data[message_id]
        entrants = giveaway["entrants"]
        winners = rng.sample(entrants, min(giveaway["winners"], len(entrants)))
        try:
            await announce(message_id, giveaway, winners)
            await close_card(message_id, giveaway)
        except discord.HTTPException as error:
            print(f"Couldn't announce giveaway {message_id}: {error!r}")
        data = load()  # again: meanwhile, people may have entered other giveaways
        data[message_id]["winner_ids"] = winners
        save(data)


@check.before_loop
async def before_check():
    await bot.wait_until_ready()


@bot.tree.command(name="giveaway", description="Starts a giveaway in this channel")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
@app_commands.describe(prize="What's being given away", minutes="How long it lasts: from 1 minute to 28 days (40320)", winners="How many win")
async def giveaway(interaction: discord.Interaction, prize: str,
                   minutes: app_commands.Range[int, 1, 40320], winners: app_commands.Range[int, 1, 20] = 1):
    end = int(time.time()) + minutes * 60
    card = discord.Embed(
        title=f"🎁 Giveaway: {prize}",
        # <t:…:R> is a Discord timestamp: "in 2 hours", in each person's own time zone.
        description=f"Click **Enter** to join.\nEnds <t:{end}:R> (<t:{end}:f>).\nWinners: {winners}",
        color=0x5B4AE8,
    )
    card.set_footer(text=f"Hosted by {interaction.user.display_name}")
    await interaction.response.send_message(embed=card, view=Enter())
    message = await interaction.original_response()
    data = load()
    data[str(message.id)] = {
        "channel": interaction.channel_id, "prize": prize, "winners": winners, "end": end,
        "entrants": [], "ended": False, "winner_ids": [],
    }
    save(data)


@bot.tree.command(name="reroll", description="Picks another winner for an ended giveaway")
@app_commands.guild_only()
@app_commands.default_permissions(manage_guild=True)
@app_commands.describe(message_id="Right-click the giveaway card → “Copy Message ID”", count="How many new winners")
async def reroll(interaction: discord.Interaction, message_id: str, count: app_commands.Range[int, 1, 20] = 1):
    message_id = message_id.strip()
    giveaway = load().get(message_id)
    channel = bot.get_channel(giveaway["channel"]) if giveaway else None
    # It has to be from this server: an id from another server doesn't count here.
    if giveaway is None or not giveaway["ended"] or getattr(getattr(channel, "guild", None), "id", None) != interaction.guild_id:
        await interaction.response.send_message("I can't find an ended giveaway with that id on this server.", ephemeral=True)
        return
    # No repeats: whoever already won doesn't go back in.
    left = [p for p in giveaway["entrants"] if p not in giveaway["winner_ids"]]
    if not left:
        await interaction.response.send_message("There's nobody left to pick.", ephemeral=True)
        return
    new = rng.sample(left, min(count, len(left)))
    await interaction.response.send_message("Picked. I'll announce it in the giveaway channel.", ephemeral=True)
    await announce(message_id, giveaway, new)
    data = load()
    data[message_id]["winner_ids"] += new
    save(data)


@bot.event
async def on_ready():
    print(f"Logged in as {bot.user}")


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