NUEVO 📢 Black Friday: la oferta de lanzamiento termina el 30 de nov. ¡Hasta un 70% de descuento en tu primer mes!Ver planes
Black FridayHasta un 70% de descuento en tu primer mes, termina el 30 de nov.Termina en 9 d 02 h 49 minBlack FridayHasta un 70% de descuento en tu primer mes, termina el 30 de nov.Termina en 9 d 02 h 49 minBlack FridayHasta un 70% de descuento en tu primer mes, termina el 30 de nov.Termina en 9 d 02 h 49 min

Cómo alojar un bot de Discord4J 24/7

Hosting de bots de DiscordActualizado 6 nov 202614 min de lectura

Para alojar un bot de Discord4J 24/7 tienes que ejecutarlo en una máquina que siempre esté encendida: un VPS Linux con un servicio systemd que lo vuelva a arrancar cuando se detenga, o un plan de bots en el alojamiento de bots de Discord de PlayNHost (desde US$1.99 al mes), donde subes un jar ejecutable, pegas el token y pulsas Iniciar. En nuestra prueba, un bot de Discord4J 3.3.3 usó unos 126 MB de memoria con Java 21 y recibió la respuesta de Discord 2.6 segundos después de lanzarse. Discord4J es una biblioteca, no un programa, así que primero compilas tu bot en un jar en tu propio ordenador. Los pasos en PlayNHost:

  1. En la página de alojamiento de bots de Discord, haz clic en Crear servidor en un plan. En la ventana del pedido, responde ¿Para qué plataforma es tu bot? con Discord y elige Java.
  2. En tu ordenador, compila el bot con el pom.xml de más abajo: mvn package escribe target/bot.jar, con Discord4J dentro.
  3. Abre tu servidor en el panel. La tarjeta Configura tu bot en Resumen se abre en Conectar con Discord. Su primer paso, Qué se ejecuta, debería decir Este bot ejecuta Java Bot.; haz clic en ese paso para comprobarlo y luego en Continuar.
  4. En Conectar con Discord, pega tu token en Pega el token de tu bot, haz clic en Conexión y luego en Sí, continuar.
  5. En Permisos, marca Mi código lo usa solo para los intents privilegiados que pida tu código (el bot de abajo no necesita ninguno), haz clic en Añadir a un servidor de Discord y luego en Continuar.
  6. En Tu código, haz clic en Subir archivos y sube bot.jar a la carpeta principal.
  7. En la página Bot, panel Código, comprueba que el Archivo de entrada es bot.jar y el Entorno de ejecución es Java 21 (recommended), o Java 17 o 25. Si cambias el Archivo de entrada, haz clic en Guardar a su lado; un nuevo Entorno de ejecución se guarda en cuanto lo eliges.
  8. Haz clic en Iniciar bot y mira la Console. Cuando tu bot imprima Logged in as ..., la tarjeta dice Tu bot está en línea en Discord.

Cómo crear el bot y su token se explica en Cómo crear un bot de Discord y obtener su token, y el tipo de bot Java en general en Cómo alojar un bot de Discord en Java. Esta página trata de Discord4J en sí: qué usa en un servidor y qué conviene saber antes de alojarlo.

Lo que medimos

BibliotecaVersiónMemoria tras arrancarDel lanzamiento a la respuesta de DiscordTamaño del jar
Discord4J3.3.3126 MB2.6 s37 MB
JDA6.7.091 MB1.5 s19 MB
Java 21 solo, sin biblioteca21.0.12.138 MBninguna0.0 MB

Cómo: en nuestro propio nodo, en un contenedor desechable configurado como un plan de bots de 1 GB (la imagen de Java 21 y el comando java exacto de nuestro tipo de bot Java), cada bot inició sesión con un token falso, que Discord rechazó; la memoria es la memoria residente 15 segundos después de esa respuesta, el tiempo de arranque va del lanzamiento a la respuesta y cada cifra es la mediana de las ejecuciones 2 a 4.

Son valores mínimos: sin servidores, sin miembros en caché, aún sin sesión de gateway abierta. Tu propio código y el número de servidores en los que está tu bot se suman a ellos, y el script de inicio deja que el heap de Java crezca hasta el 80 por ciento del plan (ver más abajo). Compara las cifras con los planes de alojamiento de bots de Discord y elige según lo que haga tu bot.

Un bot mínimo de Discord4J

Registra un comando slash /ping, lo responde con Pong!, lee el token de DISCORD_TOKEN (el nombre que le da el panel) e imprime una línea de listo. No necesita ningún intent privilegiado. Dos archivos:

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>bot</artifactId>
  <version>1.0</version>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>
  <dependencies>
    <dependency>
      <groupId>com.discord4j</groupId>
      <artifactId>discord4j-core</artifactId>
      <version>3.3.3</version>
    </dependency>
  </dependencies>
  <build>
    <finalName>bot</finalName>
    <plugins>
      <plugin>
        <artifactId>maven-assembly-plugin</artifactId>
        <version>3.7.1</version>
        <configuration>
          <descriptorRefs>
            <descriptorRef>jar-with-dependencies</descriptorRef>
          </descriptorRefs>
          <appendAssemblyId>false</appendAssemblyId>
          <archive>
            <manifest>
              <mainClass>Bot</mainClass>
            </manifest>
          </archive>
        </configuration>
        <executions>
          <execution>
            <phase>package</phase>
            <goals>
              <goal>single</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
    </plugins>
  </build>
</project>

src/main/java/Bot.java

import discord4j.core.DiscordClient;
import discord4j.core.event.domain.interaction.ChatInputInteractionEvent;
import discord4j.core.event.domain.lifecycle.ReadyEvent;
import discord4j.discordjson.json.ApplicationCommandRequest;
import discord4j.rest.http.client.ClientException;
import reactor.core.publisher.Mono;

public class Bot {
    public static void main(String[] args) {
        String token = System.getenv("DISCORD_TOKEN");
        if (token == null || token.isBlank()) {
            System.out.println("No DISCORD_TOKEN found. Paste your bot token on the Bot page, then restart.");
            System.exit(1);
        }

        ApplicationCommandRequest ping = ApplicationCommandRequest.builder()
                .name("ping")
                .description("Replies with Pong!")
                .build();

        try {
            DiscordClient.create(token).withGateway(gateway -> {
                // Creating a command that already exists updates it, so this is safe on every start.
                Mono<Void> register = gateway.getRestClient().getApplicationId()
                        .flatMap(appId -> gateway.getRestClient().getApplicationService()
                                .createGlobalApplicationCommand(appId, ping))
                        .then();

                Mono<Void> ready = gateway.on(ReadyEvent.class, event -> Mono.fromRunnable(() ->
                        System.out.println("Logged in as " + event.getSelf().getUsername())))
                        .then();

                Mono<Void> commands = gateway.on(ChatInputInteractionEvent.class, event -> {
                    if (event.getCommandName().equals("ping")) {
                        return event.reply("Pong!");
                    }
                    return Mono.empty();
                }).then();

                return register.and(ready).and(commands);
            }).block();
        } catch (RuntimeException e) {
            if (ClientException.isStatusCode(401).test(e)) {
                System.out.println("Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart.");
            } else {
                e.printStackTrace();
            }
            System.exit(1);
        }
    }
}

Compílalo con Maven 3.9 y un JDK 17 o más reciente:

mvn package
java -jar target/bot.jar

La segunda línea es una prueba en tu ordenador: sin token imprime No DISCORD_TOKEN found. y se detiene, lo que demuestra que el jar arranca y encuentra su clase principal. Sube target/bot.jar. El jar-with-dependencies del maven-assembly-plugin mete Discord4J y todo lo que necesita en ese único jar; en Gradle se consigue lo mismo con el plugin Shadow. maven.compiler.release 17 genera un jar que funciona en las tres versiones de Java que ofrece el panel.

La línea Logged in as ... es la que pone el indicador de Resumen en En línea en Discord. Invita al bot con Añadir a un servidor de Discord antes de probar /ping: Cómo invitar a tu bot de Discord a un servidor.

Si el token es incorrecto

En nuestra prueba, con un token falso, el inicio de sesión de Discord4J falló con este error:

ClientException: GET /gateway/bot returned 401 Unauthorized with response {code=0, message=401: Unauthorized}

El bot de arriba captura un token rechazado (HTTP 401) e imprime Discord did not accept the bot token. Copy it again (Developer Portal, Bot, Reset Token), paste it on the Bot page, then restart. en lugar de un stack trace, y luego se detiene con el código de salida 1. Cuando lo ejecutamos con un token falso, salieron primero tres líneas de aviso SLF4J:, la primera empieza por SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".; hablan del registro, no del token (ver Logs más abajo). Para arreglarlo, abre el Discord Developer Portal, tu aplicación, Bot, y haz clic en Reset Token; Discord muestra el token nuevo una sola vez. En nuestra página Bot, panel Discord, haz clic en Reemplazar token, pégalo, haz clic en Guardar token y luego en Reiniciar ahora. Cuando Discord rechaza la comprobación del token guardado, el panel muestra Discord no lo aceptó.

Qué saber de Discord4J en un servidor

  • Versiones: Discord4J 3.3.3 salió el 19 de agosto de 2026. La rama 3.3 es la actual y la 3.2 solo recibe mantenimiento. Discord4J 3.3.3 está compilado para Java 8, así que cualquier Entorno de ejecución que ofrece el panel (Java 17, 21 o 25) lo ejecuta; compila con un release no más nuevo que el entorno que elijas.
  • Un jar, nada instalado en el servidor. El tipo de bot Java no tiene origen Git ni campo Paquetes: ejecuta java -jar sobre tu Archivo de entrada, así que todo lo que use tu bot debe ir dentro del jar. Para actualizar el bot, sube un jar nuevo.
  • Límite de memoria: el script de inicio ejecuta Java con -XX:MaxRAMPercentage=80.0 y el recolector de basura G1, de modo que el heap puede usar hasta el 80 por ciento de la memoria de tu plan y al resto del proceso le queda espacio. Si el heap se llena, Java imprime java.lang.OutOfMemoryError y el panel muestra Tu bot se quedó sin memoria.
  • Intents: Discord4J se conecta con todos los intents no privilegiados salvo que elijas otros. El ejemplo !ping del README de Discord4J lee el texto de los mensajes, lo que requiere el intent privilegiado Message Content: actívalo en el Developer Portal, pídelo en el código con DiscordClient.create(token).gateway().setEnabledIntents(IntentSet.nonPrivileged().or(IntentSet.of(Intent.MESSAGE_CONTENT))) y marca Mi código lo usa para él en nuestro paso Permisos. Sin él, Discord envía al bot el texto del mensaje vacío, salvo en mensajes directos y en mensajes que mencionan al bot. Un comando slash, como el de arriba, no necesita nada de esto. Consulta Arregla "Used disallowed intents" en tu bot de Discord.
  • Logs: Discord4J registra a través de Reactor, que usa SLF4J cuando SLF4J está en el jar, y Discord4J trae SLF4J consigo. Sin ninguna biblioteca de logging detrás, como en el pom.xml de arriba, SLF4J imprime tres líneas de aviso al arrancar, la última SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details., y luego descarta las líneas de log del propio Discord4J, errores incluidos. Tus líneas con System.out siguen apareciendo en la Console. Para ver las líneas de Discord4J, añade una biblioteca de logging; la documentación de Discord4J recomienda Logback.
  • Haz que main() espere. Discord4J es reactivo: su inicio de sesión es un Mono que se conecta cuando algo se suscribe a él. Los ejemplos de su README terminan main() con gateway.onDisconnect().block() o con block() sobre withGateway(...), que esperan mientras el bot está conectado. El bot de arriba usa withGateway(...).block().
  • Registrar comandos en cada inicio no es problema. Discord trata la creación de un comando con un nombre que tu aplicación ya usa como una actualización de ese comando, así que el bot de arriba no acumula copias de /ping.
  • Caídas: cuando el bot termina, como hace el de arriba con un token rechazado, el panel lo arranca de nuevo enseguida. Si se detiene otra vez en el plazo de un minuto, se queda detenido y la Console explica por qué.

Alójalo tú mismo en un VPS Linux

Un VPS solo necesita un runtime de Java, porque el jar lo compilas en tu propio ordenador. En Debian 13 o Ubuntu 24.04 instala Java 21; Debian 12 trae Java 17, que también ejecuta el jar de arriba:

sudo apt update
sudo apt install openjdk-21-jre-headless
java -version

Crea un usuario para el bot y copia el jar al servidor (por ejemplo con scp), y luego a su carpeta:

sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp bot.jar /opt/mybot/
sudo chown -R mybot: /opt/mybot

Mantén el token fuera de tu código, en un archivo que solo root pueda leer:

sudo sh -c 'echo "DISCORD_TOKEN=your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env

Crea /etc/systemd/system/mybot.service:

[Unit]
Description=Discord4J bot
Wants=network-online.target
After=network-online.target

[Service]
User=mybot
WorkingDirectory=/opt/mybot
EnvironmentFile=/etc/mybot.env
ExecStart=/usr/bin/java -XX:MaxRAMPercentage=80.0 -jar /opt/mybot/bot.jar
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Inícialo ahora y en cada arranque, y sigue su salida:

sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f

Restart=always vuelve a arrancar el bot 5 segundos después de que termine o se caiga, pero no después de que lo detengas con systemctl stop. En un VPS, -XX:MaxRAMPercentage es una parte de la memoria de toda la máquina, así que redúcelo si allí corren otros programas. Para actualizar, copia el jar nuevo sobre el antiguo y ejecuta sudo systemctl restart mybot.

Autoalojamiento o plan de bots

En un VPS que gestionas tú:

  • Las actualizaciones y la seguridad del sistema operativo, y las actualizaciones de Java.
  • Copiar cada jar nuevo, el archivo del servicio, el archivo del token y sus permisos.
  • Leer journalctl para saber por qué se detuvo el bot.
  • Copias de seguridad de lo que guarde tu bot.

A cambio, un VPS ejecuta cualquier cosa que instales en él.

En un plan de bots de PlayNHost el panel lo hace por ti:

  • Java 17, 21 o 25 desde un selector, con el límite del heap y el recolector de basura ya configurados.
  • El token, comprobado con Discord antes de guardarlo, almacenado cifrado y entregado a tu código como DISCORD_TOKEN.
  • Un enlace de invitación con los permisos que elijas y una tarjeta Intents privilegiados que comprueba cuáles están activados en tu Developer Portal.
  • Arrancar el bot de nuevo tras una caída y un aviso sobre la Console cuando se queda sin memoria.
  • Subida desde el navegador y copias de seguridad desde el panel.

Preguntas frecuentes

Mi bot de Discord4J está en línea pero !ping no hace nada. ¿Por qué?

Porque el texto del mensaje llega vacío. Discord4J solo pide intents no privilegiados por defecto, y leer el texto de los mensajes en servidores requiere Message Content, un intent privilegiado. Actívalo en el Developer Portal y pídelo con setEnabledIntents como se muestra arriba, o usa un comando slash como /ping en el bot de esta página, que no necesita ningún intent privilegiado.

¿Discord4J o JDA en PlayNHost?

Ambos funcionan con el mismo tipo de bot Java, desde el mismo tipo de jar. La tabla de arriba tiene la memoria que medimos para cada uno. La diferencia real es el estilo: Discord4J se basa en Reactor, así que encadenas Mono y Flux, mientras que JDA usa listeners y callbacks. Elige aquel cuyo código te resulte más fácil de leer. Pasos para JDA: Cómo alojar un bot de Discord en Java.

¿Qué versión de Java debo elegir para Discord4J?

Java 21, la recomendada, salvo que tu propio código necesite 25. Discord4J en sí funciona desde Java 8, así que el límite es el release con el que compilas: un jar compilado para un Java más nuevo que el del servidor se detiene con UnsupportedClassVersionError. Elige un Entorno de ejecución más nuevo, o compila con un release más bajo.

¿Por qué es tan grande mi jar de Discord4J?

Porque lo contiene todo: Discord4J trae Reactor, Netty, Jackson y sus propios módulos de voz, y la compilación con jar-with-dependencies los empaqueta todos. El jar de nuestra prueba pesaba 37 MB. Eso es espacio en disco de tu plan; la memoria que usó el bot en ejecución está en la tabla de arriba.

¿Listo para ejecutar tu bot de Discord4J sin parar? Mira los planes en alojamiento de bots de Discord.

¿Ya tienes tu bot en otro proveedor? Tráelo con nosotros

NUESTROS ÚLTIMOS BLOGS