Discord member count bot: channels with members, online and boosts (Python and JavaScript)

discord.py
python-dotenv

DISCORD_TOKEN=paste-your-token-here

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()  # reads the token from the .env file

# Each server's channels are saved next to the bot: a restart doesn't lose them.
COUNTERS = Path("counters.json")
# What each channel says. {n} is the number.
LABELS = {
    "members": "👥 Members: {n}",
    "online": "🟢 Online: {n}",
    "boosts": "🚀 Boosts: {n}",
}


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


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


def number(n: int) -> str:
    return f"{n:,}"  # 1,234, with the thousands separator


class Bot(discord.Client):
    def __init__(self):
        # No privileged intents: the numbers are asked from Discord, not counted by hand.
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()  # publishes /counter
        update.start()


bot = Bot()


async def numbers(guild_id: int) -> dict[str, int]:
    # with_counts=True brings Discord's approximate counts: members and online.
    guild = await bot.fetch_guild(guild_id, with_counts=True)
    return {
        "members": guild.approximate_member_count or 0,
        "online": guild.approximate_presence_count or 0,
        "boosts": guild.premium_subscription_count or 0,
    }


@tasks.loop(minutes=10)  # no less: Discord only lets you rename a channel twice every 10 minutes
async def update():
    for guild_id, channels in load().items():
        try:
            counts = await numbers(int(guild_id))
            for key, channel_id in channels.items():
                channel = bot.get_channel(channel_id)
                if channel is None:
                    continue  # the channel was deleted: nothing to do
                name = LABELS[key].format(n=number(counts[key]))
                if channel.name != name:  # only if it changed: each change uses up one of the 2
                    await channel.edit(name=name, reason="Member counter")
        except discord.HTTPException as error:
            print(f"Couldn't update server {guild_id}: {error!r}")


@update.before_loop
async def before_update():
    await bot.wait_until_ready()


@bot.tree.command(name="counter", description="Creates the channels with members, online and boosts")
@app_commands.guild_only()
@app_commands.default_permissions(manage_channels=True)
async def counter(interaction: discord.Interaction):
    guild = interaction.guild
    data = load()
    if any(guild.get_channel(c) for c in data.get(str(guild.id), {}).values()):
        await interaction.response.send_message("They already exist. To start over, delete the category and type /counter again.", ephemeral=True)
        return
    await interaction.response.defer(ephemeral=True)  # creating channels can take a few seconds
    # Everyone sees the channels, but nobody can join them: they're just a sign.
    overwrites = {
        guild.default_role: discord.PermissionOverwrite(view_channel=True, connect=False),
        guild.me: discord.PermissionOverwrite(view_channel=True, manage_channels=True),
    }
    try:
        category = await guild.create_category("📊 Server stats", overwrites=overwrites, position=0)
        counts = await numbers(guild.id)
        channels = {}
        for key, text in LABELS.items():
            channel = await guild.create_voice_channel(text.format(n=number(counts[key])), category=category, overwrites=overwrites)
            channels[key] = channel.id
    except discord.Forbidden:
        await interaction.followup.send("I'm missing permissions: I need View Channels, Manage Channels and Connect.", ephemeral=True)
        return
    data[str(guild.id)] = channels
    save(data)
    await interaction.followup.send("Done: the “📊 Server stats” category is at the very top. The numbers refresh every 10 minutes.", ephemeral=True)


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


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

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

// Each server's channels are saved next to the bot: a restart doesn't lose them.
const COUNTERS = path.join(__dirname, "counters.json");
// What each channel says. {n} is the number.
const LABELS = {
  members: "👥 Members: {n}",
  online: "🟢 Online: {n}",
  boosts: "🚀 Boosts: {n}",
};
const TEN_MINUTES = 10 * 60 * 1000; // no less: Discord only lets you rename a channel twice every 10 minutes

const load = () => (fs.existsSync(COUNTERS) ? JSON.parse(fs.readFileSync(COUNTERS, "utf8")) : {});
const save = (data) => fs.writeFileSync(COUNTERS, JSON.stringify(data, null, 2));
const number = (n) => n.toLocaleString("en-GB"); // 1,234, with the thousands separator
const label = (key, n) => LABELS[key].replace("{n}", number(n));

// No privileged intents: the numbers are asked from Discord, not counted by hand.
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

async function numbers(guildId) {
  // withCounts brings Discord's approximate counts: members and online.
  const guild = await client.guilds.fetch({ guild: guildId, withCounts: true, force: true });
  return {
    members: guild.approximateMemberCount ?? 0,
    online: guild.approximatePresenceCount ?? 0,
    boosts: guild.premiumSubscriptionCount ?? 0,
  };
}

async function update() {
  for (const [guildId, channels] of Object.entries(load())) {
    try {
      const counts = await numbers(guildId);
      for (const [key, channelId] of Object.entries(channels)) {
        const channel = client.channels.cache.get(channelId);
        if (!channel) continue; // the channel was deleted: nothing to do
        const fresh = label(key, counts[key]);
        if (channel.name !== fresh) await channel.setName(fresh, "Member counter"); // only if it changed
      }
    } catch (error) {
      console.error(`Couldn't update server ${guildId}:`, error);
    }
  }
}

const command = new SlashCommandBuilder()
  .setName("counter")
  .setDescription("Creates the channels with members, online and boosts")
  .setContexts(InteractionContextType.Guild)
  .setDefaultMemberPermissions(PermissionFlagsBits.ManageChannels); // by default, only those who can manage channels

client.on(Events.InteractionCreate, async (i) => {
  if (!i.isChatInputCommand() || i.commandName !== "counter") return;
  const data = load();
  if (Object.values(data[i.guildId] ?? {}).some((id) => i.guild.channels.cache.has(id))) {
    await i.reply({ content: "They already exist. To start over, delete the category and type /counter again.", flags: MessageFlags.Ephemeral });
    return;
  }
  await i.deferReply({ flags: MessageFlags.Ephemeral }); // creating channels can take a few seconds
  // Everyone sees the channels, but nobody can join them: they're just a sign.
  const overwrites = [
    { id: i.guild.roles.everyone.id, allow: [PermissionFlagsBits.ViewChannel], deny: [PermissionFlagsBits.Connect] },
    { id: client.user.id, allow: [PermissionFlagsBits.ViewChannel, PermissionFlagsBits.ManageChannels] },
  ];
  try {
    const category = await i.guild.channels.create({ name: "📊 Server stats", type: ChannelType.GuildCategory, permissionOverwrites: overwrites, position: 0 });
    const counts = await numbers(i.guildId);
    const channels = {};
    for (const key of Object.keys(LABELS)) {
      const channel = await i.guild.channels.create({ name: label(key, counts[key]), type: ChannelType.GuildVoice, parent: category.id, permissionOverwrites: overwrites });
      channels[key] = channel.id;
    }
    data[i.guildId] = channels;
    save(data);
    await i.editReply("Done: the “📊 Server stats” category is at the very top. The numbers refresh every 10 minutes.");
  } catch (error) {
    console.error(error);
    await i.editReply("I'm missing permissions: I need View Channels, Manage Channels and Connect.");
  }
});

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

client.login(process.env.DISCORD_TOKEN);