Discord Leveling Bot: XP for Messages, Leaderboard and Roles (Python and JavaScript)

discord.py
python-dotenv

DISCORD_TOKEN=paste-your-token-here

import os
import random
import sqlite3
import time

import discord
from discord import app_commands
from dotenv import load_dotenv

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

# Roles earned on reaching a level: {level: role id}. Empty, no roles.
LEVEL_ROLES = {
    # 5: 123456789012345678,
    # 10: 234567890123456789,
}
COOLDOWN = 60  # seconds: only one message per minute counts (against spam)

db = sqlite3.connect("levels.db")
db.execute(
    "CREATE TABLE IF NOT EXISTS xp (guild INTEGER, user INTEGER, name TEXT,"
    " xp INTEGER NOT NULL, last REAL NOT NULL, PRIMARY KEY (guild, user))"
)


def xp_to_level_up(level):
    """XP needed to go from this level to the next."""
    return 5 * level**2 + 50 * level + 100


def level_of(xp):
    """The level, the XP earned within it and the XP it takes to level up."""
    level = 0
    while xp >= xp_to_level_up(level):
        xp -= xp_to_level_up(level)
        level += 1
    return level, xp, xp_to_level_up(level)


intents = discord.Intents.default()  # receives messages, without reading their text
client = discord.Client(intents=intents)
tree = app_commands.CommandTree(client)


@client.event
async def on_message(message):
    if message.author.bot or message.guild is None:
        return
    now = time.time()
    row = db.execute(
        "SELECT xp, last FROM xp WHERE guild = ? AND user = ?",
        (message.guild.id, message.author.id),
    ).fetchone()
    xp, last = row or (0, 0)
    if now - last < COOLDOWN:
        return
    before = level_of(xp)[0]
    xp += random.randint(15, 25)
    db.execute(
        "INSERT OR REPLACE INTO xp VALUES (?, ?, ?, ?, ?)",
        (message.guild.id, message.author.id, message.author.display_name, xp, now),
    )
    db.commit()
    level = level_of(xp)[0]
    if level == before:
        return
    try:
        await message.channel.send(f"🎉 {message.author.mention} reached level {level}")
        role = message.guild.get_role(LEVEL_ROLES.get(level, 0))
        if role:
            await message.author.add_roles(role, reason=f"Level {level}")
    except discord.HTTPException as error:
        print(f"Couldn't announce or give the role: {error}")


@tree.command(name="level", description="Your level (or someone else's)")
@app_commands.guild_only()
async def show_level(interaction: discord.Interaction, user: discord.Member | None = None):
    user = user or interaction.user
    row = db.execute(
        "SELECT xp FROM xp WHERE guild = ? AND user = ?",
        (interaction.guild_id, user.id),
    ).fetchone()
    xp = row[0] if row else 0
    rank = db.execute(
        "SELECT COUNT(*) + 1 FROM xp WHERE guild = ? AND xp > ?",
        (interaction.guild_id, xp),
    ).fetchone()[0]
    level, inside, needed = level_of(xp)
    filled = inside * 10 // needed
    bar = "▰" * filled + "▱" * (10 - filled)
    card = discord.Embed(title=f"Level {level}", color=0x5B4AE8)
    card.set_author(name=user.display_name, icon_url=user.display_avatar.url)
    card.description = f"{bar} {inside}/{needed} XP\nRank {rank} · {xp} XP in total"
    await interaction.response.send_message(embed=card)


@tree.command(name="leaderboard", description="The 10 highest levels on the server")
@app_commands.guild_only()
async def leaderboard(interaction: discord.Interaction):
    rows = db.execute(
        "SELECT name, xp FROM xp WHERE guild = ? ORDER BY xp DESC LIMIT 10",
        (interaction.guild_id,),
    ).fetchall()
    if not rows:
        await interaction.response.send_message("Nobody has XP yet: start chatting!")
        return
    lines = [f"**{i}.** {name} · level {level_of(xp)[0]} ({xp} XP)" for i, (name, xp) in enumerate(rows, 1)]
    card = discord.Embed(title="🏆 Leaderboard", description="\n".join(lines), color=0x5B4AE8)
    await interaction.response.send_message(embed=card)


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


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

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

DISCORD_TOKEN=paste-your-token-here

require("dotenv").config(); // reads the token from the .env file
const { DatabaseSync } = require("node:sqlite"); // comes with Node.js 22.13 or newer
const { Client, EmbedBuilder, Events, GatewayIntentBits, InteractionContextType, SlashCommandBuilder } = require("discord.js");

// Roles earned on reaching a level: { level: "role id" }. Empty, no roles.
const LEVEL_ROLES = {
  // 5: "123456789012345678",
  // 10: "234567890123456789",
};
const COOLDOWN = 60_000; // milliseconds: only one message per minute counts (against spam)

const db = new DatabaseSync("levels.db");
db.exec(
  "CREATE TABLE IF NOT EXISTS xp (guild TEXT, user TEXT, name TEXT," +
    " xp INTEGER NOT NULL, last INTEGER NOT NULL, PRIMARY KEY (guild, user))",
);
const read = db.prepare("SELECT xp, last FROM xp WHERE guild = ? AND user = ?");
const save = db.prepare("INSERT OR REPLACE INTO xp VALUES (?, ?, ?, ?, ?)");
const rankOf = db.prepare("SELECT COUNT(*) + 1 AS rank FROM xp WHERE guild = ? AND xp > ?");
const top = db.prepare("SELECT name, xp FROM xp WHERE guild = ? ORDER BY xp DESC LIMIT 10");

// XP needed to go from this level to the next.
const xpToLevelUp = (level) => 5 * level ** 2 + 50 * level + 100;

// The level, the XP earned within it and the XP it takes to level up.
function levelOf(xp) {
  let level = 0;
  while (xp >= xpToLevelUp(level)) xp -= xpToLevelUp(level++);
  return { level, inside: xp, needed: xpToLevelUp(level) };
}

// Messages arrive without their text: the “Message Content Intent” isn't needed.
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages] });

client.on(Events.MessageCreate, async (message) => {
  if (message.author.bot || !message.inGuild()) return;
  const now = Date.now();
  const row = read.get(message.guildId, message.author.id) ?? { xp: 0, last: 0 };
  if (now - row.last < COOLDOWN) return;
  const before = levelOf(row.xp).level;
  const xp = row.xp + 15 + Math.floor(Math.random() * 11);
  save.run(message.guildId, message.author.id, message.member?.displayName ?? message.author.username, xp, now);
  const { level } = levelOf(xp);
  if (level === before) return;
  try {
    await message.channel.send(`🎉 ${message.author} reached level ${level}`);
    const role = LEVEL_ROLES[level];
    if (role && message.member) await message.member.roles.add(role, `Level ${level}`);
  } catch (error) {
    console.log(`Couldn't announce or give the role: ${error.message}`);
  }
});

const commands = [
  new SlashCommandBuilder()
    .setName("level")
    .setDescription("Your level (or someone else's)")
    .setContexts(InteractionContextType.Guild)
    .addUserOption((o) => o.setName("user").setDescription("Whose")),
  new SlashCommandBuilder().setName("leaderboard").setDescription("The 10 highest levels on the server").setContexts(InteractionContextType.Guild),
];

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand() || !i.inGuild()) return;
  if (i.commandName === "level") {
    const user = i.options.getMember("user") ?? i.member;
    const xp = read.get(i.guildId, user.id)?.xp ?? 0;
    const { rank } = rankOf.get(i.guildId, xp);
    const { level, inside, needed } = levelOf(xp);
    const filled = Math.floor((inside * 10) / needed);
    const card = new EmbedBuilder()
      .setColor(0x5b4ae8)
      .setTitle(`Level ${level}`)
      .setAuthor({ name: user.displayName, iconURL: user.displayAvatarURL() })
      .setDescription(`${"▰".repeat(filled)}${"▱".repeat(10 - filled)} ${inside}/${needed} XP\nRank ${rank} · ${xp} XP in total`);
    await i.reply({ embeds: [card] });
  }
  if (i.commandName === "leaderboard") {
    const rows = top.all(i.guildId);
    if (!rows.length) return i.reply("Nobody has XP yet: start chatting!");
    const lines = rows.map((r, n) => `**${n + 1}.** ${r.name} · level ${levelOf(r.xp).level} (${r.xp} XP)`);
    await i.reply({ embeds: [new EmbedBuilder().setColor(0x5b4ae8).setTitle("🏆 Leaderboard").setDescription(lines.join("\n"))] });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(commands.map((x) => x.toJSON())); // publishes /level and /leaderboard
  console.log(`Logged in as ${c.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);