Bot de niveles para Discord: XP por mensajes, ranking y roles (Python y JavaScript)

discord.py
python-dotenv

DISCORD_TOKEN=pega-aquí-tu-token

import os
import random
import sqlite3
import time

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()  # lee el token del fichero .env

# Roles que se ganan al llegar a un nivel: {nivel: id del rol}. Vacío, sin roles.
ROLES_POR_NIVEL = {
    # 5: 123456789012345678,
    # 10: 234567890123456789,
}
ESPERA = 60  # segundos: solo cuenta un mensaje por minuto (contra el spam)

bd = sqlite3.connect("niveles.db")
bd.execute(
    "CREATE TABLE IF NOT EXISTS xp (servidor INTEGER, usuario INTEGER, nombre TEXT,"
    " xp INTEGER NOT NULL, ultimo REAL NOT NULL, PRIMARY KEY (servidor, usuario))"
)


def xp_para_subir(nivel):
    """XP que hace falta para pasar de este nivel al siguiente."""
    return 5 * nivel**2 + 50 * nivel + 100


def nivel_de(xp):
    """El nivel, la XP que lleva dentro de él y la que pide para subir."""
    nivel = 0
    while xp >= xp_para_subir(nivel):
        xp -= xp_para_subir(nivel)
        nivel += 1
    return nivel, xp, xp_para_subir(nivel)


intents = discord.Intents.default()  # trae los mensajes, sin leer su texto
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
    ahora = time.time()
    fila = bd.execute(
        "SELECT xp, ultimo FROM xp WHERE servidor = ? AND usuario = ?",
        (message.guild.id, message.author.id),
    ).fetchone()
    xp, ultimo = fila or (0, 0)
    if ahora - ultimo < ESPERA:
        return
    antes = nivel_de(xp)[0]
    xp += random.randint(15, 25)
    bd.execute(
        "INSERT OR REPLACE INTO xp VALUES (?, ?, ?, ?, ?)",
        (message.guild.id, message.author.id, message.author.display_name, xp, ahora),
    )
    bd.commit()
    nivel = nivel_de(xp)[0]
    if nivel == antes:
        return
    try:
        await message.channel.send(f"🎉 {message.author.mention} sube a nivel {nivel}")
        rol = message.guild.get_role(ROLES_POR_NIVEL.get(nivel, 0))
        if rol:
            await message.author.add_roles(rol, reason=f"Nivel {nivel}")
    except discord.HTTPException as error:
        print(f"No he podido avisar o dar el rol: {error}")


@tree.command(name="nivel", description="Tu nivel (o el de otro)")
@app_commands.guild_only()
async def ver_nivel(interaction: discord.Interaction, usuario: discord.Member | None = None):
    usuario = usuario or interaction.user
    fila = bd.execute(
        "SELECT xp FROM xp WHERE servidor = ? AND usuario = ?",
        (interaction.guild_id, usuario.id),
    ).fetchone()
    xp = fila[0] if fila else 0
    puesto = bd.execute(
        "SELECT COUNT(*) + 1 FROM xp WHERE servidor = ? AND xp > ?",
        (interaction.guild_id, xp),
    ).fetchone()[0]
    nivel, dentro, falta = nivel_de(xp)
    llenos = dentro * 10 // falta
    barra = "▰" * llenos + "▱" * (10 - llenos)
    tarjeta = discord.Embed(title=f"Nivel {nivel}", color=0x5B4AE8)
    tarjeta.set_author(name=usuario.display_name, icon_url=usuario.display_avatar.url)
    tarjeta.description = f"{barra} {dentro}/{falta} XP\nPuesto {puesto} · {xp} XP en total"
    await interaction.response.send_message(embed=tarjeta)


@tree.command(name="ranking", description="Los 10 con más nivel del servidor")
@app_commands.guild_only()
async def ranking(interaction: discord.Interaction):
    filas = bd.execute(
        "SELECT nombre, xp FROM xp WHERE servidor = ? ORDER BY xp DESC LIMIT 10",
        (interaction.guild_id,),
    ).fetchall()
    if not filas:
        await interaction.response.send_message("Aún nadie tiene XP: ¡a escribir!")
        return
    lineas = [f"**{i}.** {nombre} · nivel {nivel_de(xp)[0]} ({xp} XP)" for i, (nombre, xp) in enumerate(filas, 1)]
    tarjeta = discord.Embed(title="🏆 Ranking", description="\n".join(lineas), color=0x5B4AE8)
    await interaction.response.send_message(embed=tarjeta)


@client.event
async def on_ready():
    await tree.sync()  # publica /nivel y /ranking
    print(f"Conectado como {client.user}")


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

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

DISCORD_TOKEN=pega-aquí-tu-token

require("dotenv").config(); // lee el token del fichero .env
const { DatabaseSync } = require("node:sqlite"); // viene con Node.js 22.13 o más nuevo
const { Client, EmbedBuilder, Events, GatewayIntentBits, InteractionContextType, SlashCommandBuilder } = require("discord.js");

// Roles que se ganan al llegar a un nivel: { nivel: "id del rol" }. Vacío, sin roles.
const ROLES_POR_NIVEL = {
  // 5: "123456789012345678",
  // 10: "234567890123456789",
};
const ESPERA = 60_000; // milisegundos: solo cuenta un mensaje por minuto (contra el spam)

const bd = new DatabaseSync("niveles.db");
bd.exec(
  "CREATE TABLE IF NOT EXISTS xp (servidor TEXT, usuario TEXT, nombre TEXT," +
    " xp INTEGER NOT NULL, ultimo INTEGER NOT NULL, PRIMARY KEY (servidor, usuario))",
);
const leer = bd.prepare("SELECT xp, ultimo FROM xp WHERE servidor = ? AND usuario = ?");
const guardar = bd.prepare("INSERT OR REPLACE INTO xp VALUES (?, ?, ?, ?, ?)");
const puestoDe = bd.prepare("SELECT COUNT(*) + 1 AS puesto FROM xp WHERE servidor = ? AND xp > ?");
const primeros = bd.prepare("SELECT nombre, xp FROM xp WHERE servidor = ? ORDER BY xp DESC LIMIT 10");

// XP que hace falta para pasar de este nivel al siguiente.
const xpParaSubir = (nivel) => 5 * nivel ** 2 + 50 * nivel + 100;

// El nivel, la XP que lleva dentro de él y la que pide para subir.
function nivelDe(xp) {
  let nivel = 0;
  while (xp >= xpParaSubir(nivel)) xp -= xpParaSubir(nivel++);
  return { nivel, dentro: xp, falta: xpParaSubir(nivel) };
}

// Los mensajes llegan sin leer su texto: no hace falta el «Message Content Intent».
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages] });

client.on(Events.MessageCreate, async (message) => {
  if (message.author.bot || !message.inGuild()) return;
  const ahora = Date.now();
  const fila = leer.get(message.guildId, message.author.id) ?? { xp: 0, ultimo: 0 };
  if (ahora - fila.ultimo < ESPERA) return;
  const antes = nivelDe(fila.xp).nivel;
  const xp = fila.xp + 15 + Math.floor(Math.random() * 11);
  guardar.run(message.guildId, message.author.id, message.member?.displayName ?? message.author.username, xp, ahora);
  const { nivel } = nivelDe(xp);
  if (nivel === antes) return;
  try {
    await message.channel.send(`🎉 ${message.author} sube a nivel ${nivel}`);
    const rol = ROLES_POR_NIVEL[nivel];
    if (rol && message.member) await message.member.roles.add(rol, `Nivel ${nivel}`);
  } catch (error) {
    console.log(`No he podido avisar o dar el rol: ${error.message}`);
  }
});

const comandos = [
  new SlashCommandBuilder()
    .setName("nivel")
    .setDescription("Tu nivel (o el de otro)")
    .setContexts(InteractionContextType.Guild)
    .addUserOption((o) => o.setName("usuario").setDescription("De quién")),
  new SlashCommandBuilder().setName("ranking").setDescription("Los 10 con más nivel del servidor").setContexts(InteractionContextType.Guild),
];

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand() || !i.inGuild()) return;
  if (i.commandName === "nivel") {
    const usuario = i.options.getMember("usuario") ?? i.member;
    const xp = leer.get(i.guildId, usuario.id)?.xp ?? 0;
    const { puesto } = puestoDe.get(i.guildId, xp);
    const { nivel, dentro, falta } = nivelDe(xp);
    const llenos = Math.floor((dentro * 10) / falta);
    const tarjeta = new EmbedBuilder()
      .setColor(0x5b4ae8)
      .setTitle(`Nivel ${nivel}`)
      .setAuthor({ name: usuario.displayName, iconURL: usuario.displayAvatarURL() })
      .setDescription(`${"▰".repeat(llenos)}${"▱".repeat(10 - llenos)} ${dentro}/${falta} XP\nPuesto ${puesto} · ${xp} XP en total`);
    await i.reply({ embeds: [tarjeta] });
  }
  if (i.commandName === "ranking") {
    const filas = primeros.all(i.guildId);
    if (!filas.length) return i.reply("Aún nadie tiene XP: ¡a escribir!");
    const lineas = filas.map((f, n) => `**${n + 1}.** ${f.nombre} · nivel ${nivelDe(f.xp).nivel} (${f.xp} XP)`);
    await i.reply({ embeds: [new EmbedBuilder().setColor(0x5b4ae8).setTitle("🏆 Ranking").setDescription(lineas.join("\n"))] });
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(comandos.map((x) => x.toJSON())); // publica /nivel y /ranking
  console.log(`Conectado como ${c.user.tag}`);
});

client.login(process.env.DISCORD_TOKEN);