Para hospedar um bot Discord4J 24/7, você o executa em uma máquina que fica sempre ligada: uma VPS Linux com um serviço systemd que o inicia de novo quando ele para, ou um plano de bots na hospedagem de bots Discord da PlayNHost (a partir de US$1,99 por mês), onde você envia um jar executável, cola o token e clica em Iniciar. No nosso teste, um bot Discord4J 3.3.3 usou cerca de 126 MB de memória no Java 21 e recebeu a resposta do Discord 2,6 segundos depois de ser iniciado. O Discord4J é uma biblioteca, não um programa, então você primeiro compila seu bot em um jar no seu próprio computador. Os passos na PlayNHost:
- Na página Hospedagem de bots Discord, clique em Criar servidor em um plano. Na janela do pedido, responda Para qual plataforma é o seu bot? com Discord e escolha Java.
- No seu computador, compile o bot com o
pom.xmlabaixo:mvn packagegravatarget/bot.jar, com o Discord4J dentro. - Abra seu servidor no painel. O cartão Configurar seu bot na Visão geral abre em Conectar ao Discord. O primeiro passo, O que roda, deve dizer Este bot roda Java Bot.; clique nesse passo para conferir e depois em Continuar.
- Em Conectar ao Discord, cole seu token em Cole o token do seu bot, clique em Conectar e depois em Sim, continuar.
- Em Permissões, marque Meu código usa isto só para os intents privilegiados que seu código pede (o bot abaixo não precisa de nenhum), clique em Adicionar a um servidor do Discord e depois em Continuar.
- Em Seu código, clique em Enviar arquivos e envie
bot.jarpara a pasta principal. - Na página Bot, painel Código, confira se o Arquivo de entrada é
bot.jare se o Runtime é Java 21 (recommended), ou Java 17 ou 25. Se você mudar o Arquivo de entrada, clique em Salvar ao lado dele; um novo Runtime é salvo assim que você o escolhe. - Clique em Iniciar bot e acompanhe o Console. Quando seu bot imprimir
Logged in as ..., o cartão mostra Seu bot está online no Discord.
Como criar o bot e o token dele está em Como criar um bot do Discord e obter o token, e o tipo de bot Java em geral em Como hospedar um bot do Discord em Java. Esta página trata do próprio Discord4J: o que ele usa em um servidor e o que saber antes de hospedá-lo.
O que medimos
| Biblioteca | Versão | Memória após iniciar | Do início à resposta do Discord | Tamanho do jar |
|---|---|---|---|---|
| Discord4J | 3.3.3 | 126 MB | 2,6 s | 37 MB |
| JDA | 6.7.0 | 91 MB | 1,5 s | 19 MB |
| Só o Java 21, sem biblioteca | 21.0.12.1 | 38 MB | nenhuma | 0,0 MB |
Como: no nosso próprio nó, em um contêiner descartável configurado como um plano de bots de 1 GB (a imagem do Java 21 e o comando java exato do nosso tipo de bot Java), cada bot fez login com um token falso, que o Discord recusou; a memória é a memória residente 15 segundos depois dessa resposta, o tempo de início vai do lançamento até a resposta e cada valor é a mediana das execuções 2 a 4.
Esses são valores mínimos: sem servidores, sem membros em cache, ainda sem sessão de gateway aberta. Seu próprio código e o número de servidores em que seu bot está se somam a eles, e o script de início deixa o heap do Java crescer até 80 por cento do plano (veja abaixo). Compare os números com os planos da hospedagem de bots Discord e escolha pelo que seu bot faz.
Um bot Discord4J mínimo
Ele registra um comando slash /ping, responde com Pong!, lê o token de DISCORD_TOKEN (o nome que o painel dá a ele) e imprime uma linha de pronto. Não precisa de nenhum intent privilegiado. Dois arquivos:
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);
}
}
}
Compile com o Maven 3.9 e um JDK 17 ou mais novo:
mvn package
java -jar target/bot.jar
A segunda linha é um teste no seu computador: sem token, ela imprime No DISCORD_TOKEN found. e para, o que prova que o jar inicia e encontra a classe principal. Envie target/bot.jar. O jar-with-dependencies do maven-assembly-plugin coloca o Discord4J e tudo de que ele precisa nesse único jar; no Gradle, o plugin Shadow faz o mesmo. maven.compiler.release 17 gera um jar que roda nas três versões do Java que o painel oferece.
A linha Logged in as ... é a que muda o indicador em Visão geral para Online no Discord. Convide o bot com Adicionar a um servidor do Discord antes de testar /ping: Como convidar seu bot do Discord para um servidor.
Se o token estiver errado
No nosso teste, com um token falso, o login do Discord4J falhou com este erro:
ClientException: GET /gateway/bot returned 401 Unauthorized with response {code=0, message=401: Unauthorized}
O bot acima captura um token recusado (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. em vez de um stack trace, e então para com o código de saída 1. Quando o executamos com um token falso, três linhas de aviso SLF4J: vieram primeiro, a primeira começando com SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".; elas são sobre logging, não sobre o token (veja Logs abaixo). Para corrigir, abra o Discord Developer Portal, sua aplicação, Bot, e clique em Reset Token; o Discord mostra o novo token uma única vez. Na nossa página Bot, painel Discord, clique em Substituir token, cole-o, clique em Salvar token e depois em Reiniciar agora. Quando o Discord recusa a verificação do token salvo, o painel mostra O Discord não aceitou.
O que saber sobre o Discord4J em um servidor
- Versões: o Discord4J 3.3.3 saiu em 19 de agosto de 2026. A linha 3.3 é a atual e a 3.2 recebe só manutenção. O Discord4J 3.3.3 é compilado para o Java 8, então qualquer Runtime que o painel oferece (Java 17, 21 ou 25) o executa; compile com um
releasenão mais novo que o runtime escolhido. - Um jar, nada instalado no servidor. O tipo de bot Java não tem origem Git nem campo Pacotes: ele inicia
java -jarno seu Arquivo de entrada, então tudo que seu bot usa precisa estar dentro do jar. Para atualizar o bot, envie um jar novo. - Limite de memória: o script de início executa o Java com
-XX:MaxRAMPercentage=80.0e o coletor de lixo G1, então o heap pode usar até 80 por cento da memória do seu plano e o resto do processo tem espaço. Se o heap encher, o Java imprimejava.lang.OutOfMemoryErrore o painel mostra Seu bot ficou sem memória. - Intents: o Discord4J conecta com todos os intents não privilegiados, a menos que você escolha outros. O exemplo
!pingdo README do Discord4J lê o texto das mensagens, o que exige o intent privilegiado Message Content: ative-o no Developer Portal, peça-o no código comDiscordClient.create(token).gateway().setEnabledIntents(IntentSet.nonPrivileged().or(IntentSet.of(Intent.MESSAGE_CONTENT)))e marque Meu código usa isto para ele na nossa etapa Permissões. Sem ele, o Discord envia ao bot o texto da mensagem vazio, exceto em mensagens diretas e em mensagens que mencionam o bot. Um comando slash, como acima, não precisa de nada disso. Veja Corrigir "Used disallowed intents" no seu bot do Discord. - Logs: o Discord4J registra logs pelo Reactor, que usa o SLF4J quando o SLF4J está no jar, e o Discord4J traz o SLF4J junto. Sem uma biblioteca de logging por trás, como no
pom.xmlacima, o SLF4J imprime três linhas de aviso ao iniciar, a últimaSLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details., e depois descarta as linhas de log do próprio Discord4J, erros incluídos. Suas linhasSystem.outcontinuam aparecendo no Console. Para ver as linhas do Discord4J, adicione uma biblioteca de logging; a documentação do Discord4J recomenda o Logback. - Faça o
main()esperar. O Discord4J é reativo: o login dele é umMonoque só conecta quando algo se inscreve nele. Os exemplos do README terminam omain()comgateway.onDisconnect().block()ou comblock()emwithGateway(...), que esperam enquanto o bot está conectado. O bot acima usawithGateway(...).block(). - Registrar comandos a cada início não tem problema. O Discord trata a criação de um comando com um nome que sua aplicação já usa como uma atualização desse comando, então o bot acima não acumula cópias de
/ping. - Falhas: quando o bot encerra, como o bot acima faz com um token recusado, o painel o inicia de novo na hora. Se ele parar outra vez dentro de um minuto, fica parado e o Console diz o motivo.
Hospede você mesmo em uma VPS Linux
Uma VPS precisa só de um runtime Java, porque você compila o jar no seu próprio computador. No Debian 13 ou Ubuntu 24.04, instale o Java 21; o Debian 12 traz o Java 17, que também executa o jar acima:
sudo apt update
sudo apt install openjdk-21-jre-headless
java -version
Crie um usuário para o bot e copie o jar para o servidor (por exemplo com scp), depois para a pasta dele:
sudo useradd --system --create-home --home-dir /opt/mybot mybot
sudo cp bot.jar /opt/mybot/
sudo chown -R mybot: /opt/mybot
Mantenha o token fora do seu código, em um arquivo que só o root consegue ler:
sudo sh -c 'echo "DISCORD_TOKEN=your-token" > /etc/mybot.env'
sudo chmod 600 /etc/mybot.env
Crie /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
Inicie-o agora e a cada boot, depois acompanhe a saída:
sudo systemctl daemon-reload
sudo systemctl enable --now mybot
sudo journalctl -u mybot -f
Restart=always inicia o bot de novo 5 segundos depois que ele encerra ou cai, mas não depois que você o para com systemctl stop. Em uma VPS, -XX:MaxRAMPercentage é uma fração da memória da máquina inteira, então reduza-o se outros programas rodarem lá. Para atualizar, copie o jar novo sobre o antigo e execute sudo systemctl restart mybot.
Hospedar por conta própria ou usar um plano de bots
Em uma VPS que você mesmo gerencia, cabe a você cuidar de:
- Atualizações e segurança do sistema operacional, e atualizações do Java.
- Copiar cada jar novo, o arquivo de serviço, o arquivo do token e as permissões dele.
- Ler o
journalctlpara descobrir por que o bot parou. - Backups de tudo que seu bot guarda.
Em troca, uma VPS executa qualquer coisa que você instalar nela.
Em um plano de bots da PlayNHost, o painel faz isso por você:
- Java 17, 21 ou 25 em um seletor, com o limite do heap e o coletor de lixo já definidos.
- O token, verificado no Discord antes de ser salvo, guardado criptografado e entregue ao seu código como
DISCORD_TOKEN. - Um link de convite com as permissões que você escolher e um cartão Intents privilegiados que confere quais estão ativados no seu Developer Portal.
- Iniciar o bot de novo após uma falha e um aviso acima do Console quando a memória acaba.
- Envio pelo navegador e backups pelo painel.
Perguntas frequentes
Meu bot Discord4J está online, mas !ping não faz nada. Por quê?
Porque o texto da mensagem está vazio. O Discord4J pede só intents não privilegiados por padrão, e ler o texto das mensagens em servidores exige Message Content, um intent privilegiado. Ative-o no Developer Portal e peça-o com setEnabledIntents como mostrado acima, ou use um comando slash como /ping no bot desta página, que não precisa de intent privilegiado.
Discord4J ou JDA na PlayNHost?
Os dois rodam no mesmo tipo de bot Java, a partir do mesmo tipo de jar. A tabela acima traz a memória que medimos para cada um. A diferença real é o estilo: o Discord4J é baseado no Reactor, então você encadeia Mono e Flux, enquanto o JDA usa listeners e callbacks. Escolha aquele cujo código você acha mais fácil de ler. Passos para o JDA: Como hospedar um bot do Discord em Java.
Qual versão do Java devo escolher para o Discord4J?
Java 21, a recomendada, a menos que seu próprio código precise do 25. O Discord4J em si funciona a partir do Java 8, então o limite é o release com que você compila: um jar compilado para um Java mais novo que o do servidor para com UnsupportedClassVersionError. Escolha um Runtime mais novo ou compile com um release menor.
Por que meu jar do Discord4J é tão grande?
Porque ele contém tudo: o Discord4J traz o Reactor, o Netty, o Jackson e os próprios módulos de voz, e a compilação com jar-with-dependencies empacota todos. O jar do nosso teste tinha 37 MB. Isso é espaço em disco do seu plano; a memória que o bot em execução usou está na tabela acima.
Pronto para manter seu bot Discord4J no ar o tempo todo? Veja os planos da hospedagem de bots Discord.



