Bot contador de miembros para Discord: canales con miembros, conectados y mejoras (Python y JavaScript)

discord.py
python-dotenv

DISCORD_TOKEN=pega-aquí-tu-token

import json
import os
from pathlib import Path

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

load_dotenv()  # lee el token del fichero .env

# Los canales de cada servidor se guardan junto al bot: un reinicio no los pierde.
CONTADORES = Path("contadores.json")
# Lo que pone cada canal. {n} es la cifra.
TEXTOS = {
    "miembros": "👥 Miembros: {n}",
    "conectados": "🟢 Conectados: {n}",
    "mejoras": "🚀 Mejoras: {n}",
}


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


def guardar(datos: dict) -> None:
    CONTADORES.write_text(json.dumps(datos, indent=2), "utf-8")


def cifra(n: int) -> str:
    return f"{n:,}".replace(",", ".")  # 1.234, con el punto de los miles


class Bot(discord.Client):
    def __init__(self):
        # Sin intents privilegiados: las cifras se piden a Discord, no se cuentan a mano.
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()  # publica /contador
        actualizar.start()


bot = Bot()


async def cifras(guild_id: int) -> dict[str, int]:
    # with_counts=True trae los recuentos aproximados de Discord: miembros y conectados.
    guild = await bot.fetch_guild(guild_id, with_counts=True)
    return {
        "miembros": guild.approximate_member_count or 0,
        "conectados": guild.approximate_presence_count or 0,
        "mejoras": guild.premium_subscription_count or 0,
    }


@tasks.loop(minutes=10)  # no menos: Discord solo deja renombrar un canal 2 veces cada 10 minutos
async def actualizar():
    for guild_id, canales in leer().items():
        try:
            cuentas = await cifras(int(guild_id))
            for clave, id_canal in canales.items():
                canal = bot.get_channel(id_canal)
                if canal is None:
                    continue  # han borrado el canal: no se hace nada
                nombre = TEXTOS[clave].format(n=cifra(cuentas[clave]))
                if canal.name != nombre:  # solo si ha cambiado: cada cambio gasta uno de los 2
                    await canal.edit(name=nombre, reason="Contador de miembros")
        except discord.HTTPException as error:
            print(f"No he podido actualizar el servidor {guild_id}: {error!r}")


@actualizar.before_loop
async def antes_de_actualizar():
    await bot.wait_until_ready()


@bot.tree.command(name="contador", description="Crea los canales con los miembros, los conectados y las mejoras")
@app_commands.guild_only()
@app_commands.default_permissions(manage_channels=True)
async def contador(interaction: discord.Interaction):
    guild = interaction.guild
    datos = leer()
    if any(guild.get_channel(c) for c in datos.get(str(guild.id), {}).values()):
        await interaction.response.send_message("Ya están creados. Para empezar de cero, borra la categoría y vuelve a escribir /contador.", ephemeral=True)
        return
    await interaction.response.defer(ephemeral=True)  # crear canales puede tardar unos segundos
    # Todos ven los canales, pero nadie puede entrar en ellos: son solo un cartel.
    permisos = {
        guild.default_role: discord.PermissionOverwrite(view_channel=True, connect=False),
        guild.me: discord.PermissionOverwrite(view_channel=True, manage_channels=True),
    }
    try:
        categoria = await guild.create_category("📊 Estadísticas", overwrites=permisos, position=0)
        cuentas = await cifras(guild.id)
        canales = {}
        for clave, texto in TEXTOS.items():
            canal = await guild.create_voice_channel(texto.format(n=cifra(cuentas[clave])), category=categoria, overwrites=permisos)
            canales[clave] = canal.id
    except discord.Forbidden:
        await interaction.followup.send("Me faltan permisos: necesito «Ver canales», «Gestionar canales» y «Conectarse».", ephemeral=True)
        return
    datos[str(guild.id)] = canales
    guardar(datos)
    await interaction.followup.send("Hecho: arriba del todo tienes la categoría «📊 Estadísticas». Las cifras se ponen al día cada 10 minutos.", ephemeral=True)


@bot.event
async def on_ready():
    print(f"Conectado como {bot.user}")


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

{
  "name": "bot-contador",
  "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 fs = require("node:fs");
const path = require("node:path");
const { ChannelType, Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags, PermissionFlagsBits, SlashCommandBuilder } = require("discord.js");

// Los canales de cada servidor se guardan junto al bot: un reinicio no los pierde.
const CONTADORES = path.join(__dirname, "contadores.json");
// Lo que pone cada canal. {n} es la cifra.
const TEXTOS = {
  miembros: "👥 Miembros: {n}",
  conectados: "🟢 Conectados: {n}",
  mejoras: "🚀 Mejoras: {n}",
};
const DIEZ_MINUTOS = 10 * 60 * 1000; // no menos: Discord solo deja renombrar un canal 2 veces cada 10 minutos

const leer = () => (fs.existsSync(CONTADORES) ? JSON.parse(fs.readFileSync(CONTADORES, "utf8")) : {});
const guardar = (datos) => fs.writeFileSync(CONTADORES, JSON.stringify(datos, null, 2));
const cifra = (n) => n.toLocaleString("es-ES", { useGrouping: "always" }); // 1.234, con el punto de los miles
const nombre = (clave, n) => TEXTOS[clave].replace("{n}", cifra(n));

// Sin intents privilegiados: las cifras se piden a Discord, no se cuentan a mano.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

async function cifras(guildId) {
  // withCounts trae los recuentos aproximados de Discord: miembros y conectados.
  const guild = await client.guilds.fetch({ guild: guildId, withCounts: true, force: true });
  return {
    miembros: guild.approximateMemberCount ?? 0,
    conectados: guild.approximatePresenceCount ?? 0,
    mejoras: guild.premiumSubscriptionCount ?? 0,
  };
}

async function actualizar() {
  for (const [guildId, canales] of Object.entries(leer())) {
    try {
      const cuentas = await cifras(guildId);
      for (const [clave, idCanal] of Object.entries(canales)) {
        const canal = client.channels.cache.get(idCanal);
        if (!canal) continue; // han borrado el canal: no se hace nada
        const nuevo = nombre(clave, cuentas[clave]);
        if (canal.name !== nuevo) await canal.setName(nuevo, "Contador de miembros"); // solo si ha cambiado
      }
    } catch (error) {
      console.error(`No he podido actualizar el servidor ${guildId}:`, error);
    }
  }
}

const comando = new SlashCommandBuilder()
  .setName("contador")
  .setDescription("Crea los canales con los miembros, los conectados y las mejoras")
  .setContexts(InteractionContextType.Guild)
  .setDefaultMemberPermissions(PermissionFlagsBits.ManageChannels); // de serie, solo quien puede gestionar canales

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand() || i.commandName !== "contador") return;
  const datos = leer();
  if (Object.values(datos[i.guildId] ?? {}).some((id) => i.guild.channels.cache.has(id))) {
    await i.reply({ content: "Ya están creados. Para empezar de cero, borra la categoría y vuelve a escribir /contador.", flags: MessageFlags.Ephemeral });
    return;
  }
  await i.deferReply({ flags: MessageFlags.Ephemeral }); // crear canales puede tardar unos segundos
  // Todos ven los canales, pero nadie puede entrar en ellos: son solo un cartel.
  const permisos = [
    { id: i.guild.roles.everyone.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.Connect] },
    { id: client.user.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.ManageChannels] },
  ];
  try {
    const categoria = await i.guild.channels.create({ name: "📊 Estadísticas", type: ChannelType.GuildCategory, permissionOverwrites: permisos, position: 0 });
    const cuentas = await cifras(i.guildId);
    const canales = {};
    for (const clave of Object.keys(TEXTOS)) {
      const canal = await i.guild.channels.create({ name: nombre(clave, cuentas[clave]), type: ChannelType.GuildVoice, parent: categoria.id, permissionOverwrites: permisos });
      canales[clave] = canal.id;
    }
    datos[i.guildId] = canales;
    guardar(datos);
    await i.editReply("Hecho: arriba del todo tienes la categoría «📊 Estadísticas». Las cifras se ponen al día cada 10 minutos.");
  } catch (error) {
    console.error(error);
    await i.editReply("Me faltan permisos: necesito «Ver canales», «Gestionar canales» y «Conectarse».");
  }
});

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set([comando.toJSON()]); // publica /contador
  console.log(`Conectado como ${c.user.tag}`);
  setInterval(actualizar, DIEZ_MINUTOS);
  actualizar();
});

client.login(process.env.DISCORD_TOKEN);