Cómo crear un bot de moderación para Discord

Empieza por AutoMod de Discord

AutoMod viene integrado en Discord y se ejecuta en la infraestructura de Discord, así que funciona aunque no haya ningún bot conectado. Abre Server Settings → AutoMod; necesitas el permiso Manage Server. Ofrece:

• Filtros de palabras personalizados con tus propias palabras clave, comodines y expresiones regulares.
• Palabras marcadas con frecuencia: listas ya preparadas de lenguaje soez, contenido sexual e insultos.
• Spam de menciones: actúa cuando un mensaje menciona a demasiadas personas a la vez, hasta el límite que tú fijes.
• Contenido de spam: la detección propia de Discord de posible spam.
• Filtros de perfil de miembro: palabras clave que se comprueban en los nombres de usuario y los perfiles.

Para cada regla eliges qué pasa: bloquear el mensaje, enviar una alerta a un canal de moderadores o aislar temporalmente al miembro. Puedes excluir roles y canales. A los miembros con Manage Server o Administrator nunca se les filtra.

Si tu problema es el spam, los insultos y las menciones masivas, configura primero AutoMod y comprueba si basta. Un bot propio compensa cuando quieres comandos que puedan usar tus moderadores, tus propias reglas y un registro como es debido.

Qué aporta un bot de moderación propio

• Comandos de barra para moderadores: /timeout, /purge, /slowmode, expulsar y banear, con un motivo registrado cada vez.
• Un canal de registro de moderación con entradas, salidas, mensajes borrados y cada acción que tomen tus moderadores.
• Tus propias reglas: advertencias que se acumulan hasta un aislamiento, cuentas nuevas en espera, enlaces permitidos solo en algunos canales.
• Todo en un solo sitio, ajustado a tu comunidad en lugar de a los valores por defecto de un bot público.

Si nunca has creado un bot, sigue primero cómo crear un bot de Discord para crear la aplicación, obtener el token y ejecutar un primer comando /ping. El código de abajo parte de ahí.

Permisos, orden de roles e intents

Invita al bot solo con los permisos que usan sus comandos:

El orden de los roles importa. Un bot solo puede actuar sobre miembros cuyo rol más alto esté por debajo del rol más alto del bot. En Server Settings → Roles, arrastra el rol del bot por encima de los roles que deba moderar. Nadie puede aislar al propietario del servidor ni a un Administrator.

Intents. Los comandos de barra no necesitan ningún intent privilegiado. Dos son útiles para moderar: Server Members para registrar entradas y salidas, y Message Content si el bot lee los mensajes para filtrarlos por su cuenta. Actívalos en Bot → Privileged Gateway Intents del Developer Portal. Desde junio de 2026, Discord solo los revisa en las aplicaciones que superan los 10.000 usuarios; por debajo de esa cifra, basta con activar el interruptor.

Comandos de moderación en Python (discord.py)

Con discord.py 2.7 instalado (pip install discord.py), este bot.py añade /timeout, /purge y /slowmode:

import os
from datetime import timedelta
from typing import Optional

import discord
from discord import app_commands

class Bot(discord.Client):
    def __init__(self):
        super().__init__(intents=discord.Intents.default())
        self.tree = app_commands.CommandTree(self)

    async def setup_hook(self):
        await self.tree.sync()

bot = Bot()

@bot.tree.command(description="Time out a member")
@app_commands.guild_only()
@app_commands.default_permissions(moderate_members=True)
async def timeout(interaction: discord.Interaction, member: discord.Member,
                  minutes: app_commands.Range[int, 1, 40320], reason: Optional[str] = None):
    await member.timeout(timedelta(minutes=minutes), reason=reason)
    await interaction.response.send_message(f"{member.mention} is timed out for {minutes} min.", ephemeral=True)

@bot.tree.command(description="Delete recent messages in this channel")
@app_commands.guild_only()
@app_commands.default_permissions(manage_messages=True)
async def purge(interaction: discord.Interaction, count: app_commands.Range[int, 1, 100]):
    await interaction.response.defer(ephemeral=True)
    deleted = await interaction.channel.purge(limit=count)
    await interaction.followup.send(f"Deleted {len(deleted)} messages.", ephemeral=True)

@bot.tree.command(description="Set slow mode in this channel")
@app_commands.guild_only()
@app_commands.default_permissions(manage_channels=True)
async def slowmode(interaction: discord.Interaction, seconds: app_commands.Range[int, 0, 21600]):
    await interaction.channel.edit(slowmode_delay=seconds)
    await interaction.response.send_message(f"Slow mode is now {seconds} s.", ephemeral=True)

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

default_permissions oculta cada comando a los miembros que no tienen ese permiso. Los administradores del servidor pueden cambiar quién lo ve en Server Settings → Integrations. Los límites del código son los de Discord: 40.320 minutos son 28 días, y el modo lento llega hasta 6 horas.

Un comando de aislamiento en JavaScript (discord.js)

Con discord.js 14 (npm install discord.js), el mismo /timeout queda así. moderatable comprueba el orden de los roles y el permiso del bot antes de intentarlo:

const { Client, Events, GatewayIntentBits, InteractionContextType, MessageFlags,
  PermissionFlagsBits, REST, Routes, SlashCommandBuilder } = require('discord.js');

const commands = [
  new SlashCommandBuilder()
    .setName('timeout').setDescription('Time out a member')
    .addUserOption((o) => o.setName('member').setDescription('Member').setRequired(true))
    .addIntegerOption((o) => o.setName('minutes').setDescription('Minutes').setMinValue(1).setMaxValue(40320).setRequired(true))
    .addStringOption((o) => o.setName('reason').setDescription('Reason'))
    .setDefaultMemberPermissions(PermissionFlagsBits.ModerateMembers)
    .setContexts(InteractionContextType.Guild)
    .toJSON(),
];
const client = new Client({ intents: [GatewayIntentBits.Guilds] });

client.once(Events.ClientReady, async (c) => {
  await new REST().setToken(process.env.DISCORD_TOKEN).put(Routes.applicationCommands(c.user.id), { body: commands });
});

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isChatInputCommand() || interaction.commandName !== 'timeout') return;
  const member = interaction.options.getMember('member');
  const minutes = interaction.options.getInteger('minutes');
  if (!member?.moderatable) {
    return interaction.reply({ content: 'I cannot time out that member.', flags: MessageFlags.Ephemeral });
  }
  await member.timeout(minutes * 60_000, interaction.options.getString('reason') ?? undefined);
  await interaction.reply({ content: `${member} is timed out for ${minutes} min.`, flags: MessageFlags.Ephemeral });
});

client.login(process.env.DISCORD_TOKEN);

Expulsar y banear siguen el mismo patrón con member.kick(reason) y member.ban({ reason, deleteMessageSeconds }). Un baneo también puede borrar hasta 7 días de mensajes del miembro.

Registrar lo que pasa

• Indica siempre un motivo. Las librerías lo envían al registro de auditoría de Discord (Server Settings → Audit Log), que conserva las entradas durante 45 días.
• Publica además cada acción en un canal privado de registro de moderación: quién actuó, sobre quién, por qué y durante cuánto tiempo. A diferencia del registro de auditoría, guarda el historial todo el tiempo que quieras.
• Las entradas y salidas necesitan el intent Server Members; registra la fecha de creación de la cuenta para detectar cuentas desechables recién creadas.
• Los mensajes borrados y editados solo se pueden registrar con su texto si el bot tiene el intent Message Content.

Ten en cuenta el límite del borrado masivo: Discord borra hasta 100 mensajes por llamada y rechaza los mensajes de más de dos semanas, así que /purge sirve para el spam reciente, no para vaciar un canal antiguo.

Mantén el bot en línea

AutoMod sigue funcionando sin ti, pero tus comandos y registros se detienen en cuanto se detiene el proceso del bot. Un bot de moderación que corre en un PC de casa está desconectado justo cuando el PC entra en reposo, y las raids rara vez esperan al horario de oficina.

En el hosting de bots de Discord de HytHost subes el proyecto, eliges el runtime (Node.js, Python, Java, Go, C#, Bun o Lavalink) y guardas el token en una variable de arranque en lugar de en el código. El panel inicia el bot y lo reinicia tras un fallo. La configuración completa está en cómo alojar un bot de Discord 24/7.