Come creare un bot Discord nel 2026 con Node.js

Un bot Discord può moderare un server, automatizzare il supporto, pubblicare avvisi o collegare una community a un'API. Ma un bot moderno non è più un semplice script che legge i messaggi che iniziano con !. Oggi la base solida consiste nell'usare i comandi slash, richiedere il minimo di intent e permessi, tenere il token fuori dal codice e separare la registrazione dei comandi dall'avvio del bot.

Questo tutorial costruisce un vero progetto Node.js con:

• /ping, per verificare disponibilità e latenza;
• /server, per mostrare alcune informazioni sul server;
• /dire, riservato ai membri autorizzati a gestire i messaggi;
• un token conservato fuori dal codice;
• una protezione contro le menzioni iniettate tramite /dire;
• risposte di errore pulite e un arresto controllato del processo;
• un rilascio di prova per server e poi un rilascio globale in produzione.

Il codice segue discord.js 14.27.0, pubblicata a luglio 2026, e Node.js 24 LTS. Node.js raccomanda i rami Active LTS o Maintenance LTS per la produzione, e il ramo 20 non riceve più nuove versioni. Consultate sempre le versioni di Node.js mantenute e le versioni pubblicate di discord.js prima di una nuova installazione.

Che cos'è davvero un bot Discord

Un'applicazione Discord può usare due vie complementari:

1. il Gateway, una connessione WebSocket persistente che trasmette gli eventi in tempo reale, per esempio un'interazione o l'arrivo di un membro;
2. l'API HTTP, usata per registrare un comando, inviare un messaggio o modificare una risorsa.

discord.js fornisce un'astrazione JavaScript su queste API. Il Client mantiene la connessione al Gateway; l'oggetto REST esegue le chiamate HTTP. L'introduzione ufficiale ai bot Discord descrive questa architettura.

Una precisazione importante: automatizzate soltanto un account bot creato nel Developer Portal. Discord vieta i «self-bot», ossia l'automazione di un normale account utente, e indica che questa pratica può portare alla chiusura dell'account. Vedere la politica ufficiale sui self-bot.

Prerequisiti

Vi servono un account Discord, un server Discord di test su cui potete gestire le applicazioni, Node.js 24 LTS, un editor come Visual Studio Code, un terminale e le basi di JavaScript: variabili, funzioni e async/await.

Verificate il vostro ambiente:

node --version
npm --version

discord.js 14.27.0 dichiara ufficialmente Node.js 18 o superiore come prerequisito. In questa guida scegliamo comunque Node.js 24 LTS, per un motivo semplice: il ramo 20 non riceve più nuove versioni, e far girare un bot esposto a Internet su un ramo che non riceve più correzioni di sicurezza non è ragionevole. Va bene qualsiasi versione 24 recente.

1. Creare l'applicazione nel Discord Developer Portal

Aprite il Discord Developer Portal, poi:

1. fate clic su New Application;
2. date un nome all'applicazione;
3. accettate le condizioni e confermate;
4. in General Information, copiate l'Application ID;
5. in Bot, personalizzate nome e avatar se necessario;
6. in Bot, usate Reset Token per generare il token e copiatelo una sola volta.

Discord crea oggi un utente bot con ogni nuova applicazione. Il percorso ufficiale è descritto in Building your first Discord Bot.

Il token non è un identificativo pubblico

Il token permette di connettersi come il bot. Chi lo ottiene può usarne i diritti su tutti i server dove è installato.

Non mettete mai questo token in index.js, in uno screenshot, in un ticket o in un messaggio Discord, in Git nemmeno in un repository privato, né in un esempio pubblicato su un blog.

In caso di fuga, tornate subito in Bot > Reset Token e sostituite il valore sull'hosting. Cancellare un vecchio commit non basta: il segreto va revocato.

2. Configurare installazione e permessi

Nella pagina Installation del Developer Portal:

1. attivate Guild Install;
2. usate preferibilmente il Discord Provided Link;
3. aggiungete gli scope applications.commands e bot;
4. concedete solo View Channels e Send Messages per questo progetto;
5. aprite il link, selezionate il vostro server di test e autorizzate l'applicazione.

Non concedete Administrator «perché così funziona»: quel permesso aggira le restrizioni dei canali e dà molto più potere del necessario.

Il permesso di usare /dire sarà controllato a livello di comando tramite ManageMessages. Il bot, dal canto suo, deve solo vedere il canale e inviarvi un messaggio. Questa distinzione applica il principio del privilegio minimo.

Permessi Discord e gerarchia dei ruoli

I permessi del bot non bastano sempre. Per gestire un ruolo, espellere un membro o modificare un soprannome, il ruolo più alto del bot deve inoltre trovarsi al di sopra del bersaglio nella gerarchia. Discord descrive questo meccanismo nella sua documentazione ufficiale sui permessi.

3. Capire gli intent prima di scrivere codice

I Gateway Intent determinano quali categorie di eventi Discord invia al bot. Riducono i dati ricevuti e l'accesso alle informazioni sensibili.

Questo tutorial usa solo GatewayIntentBits.Guilds. Questo intent non privilegiato basta per ricevere le interazioni dei comandi slash installati sui server. Non abbiamo bisogno né di leggere tutti i messaggi né di scaricare l'elenco completo dei membri.

Tre intent sono privilegiati: GuildPresences, GuildMembers e MessageContent. Vanno attivati nel Developer Portal e dichiarati nel codice. Discord può chiudere la connessione con il codice 4014 quando un bot richiede un intent privilegiato non autorizzato.

Dal 10 giugno 2026, la revisione degli intent privilegiati non si basa più sul numero di server ma sul numero di utenti unici che possono vedere la vostra applicazione, su tutti i server. Oltre 10 000 diventa necessaria una richiesta di accesso. Un bot presente su cinquanta server grandi può quindi raggiungere questa soglia. Le regole aggiornate sono nella documentazione Gateway e nella guida alla revisione degli intent privilegiati.

Per un bot nuovo, i comandi slash evitano in genere MessageContent. Discord li raccomanda come alternativa ai vecchi comandi testuali con prefisso.

4. Inizializzare il progetto Node.js

Create la cartella del progetto:

mkdir mio-bot-discord
cd mio-bot-discord
npm init -y
npm install [email protected]
mkdir src

Fissiamo qui la versione di discord.js per ottenere un'installazione riproducibile. Conservate il file package-lock.json: sul server, npm ci potrà installare esattamente le versioni convalidate.

La struttura finale sarà la seguente:

mio-bot-discord/
├── src/
│   ├── commands.js
│   ├── deploy-commands.js
│   └── index.js
├── .env
├── .env.example
├── .gitignore
├── package-lock.json
└── package.json

package.json

Sostituite il contenuto con:

{
  "name": "mio-bot-discord",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "engines": {
    "node": ">=24.0.0"
  },
  "scripts": {
    "deploy:guild": "node --env-file=.env src/deploy-commands.js",
    "deploy:global": "node --env-file=.env src/deploy-commands.js --global",
    "start": "node --env-file=.env src/index.js"
  },
  "dependencies": {
    "discord.js": "14.27.0"
  }
}

Il campo engines è qui una nostra scelta, non un vincolo di discord.js: documenta il ramo di Node su cui il progetto deve girare e fa fallire l'installazione su una versione più vecchia.

"type": "module" attiva la sintassi moderna import. Node.js sa caricare .env in modo nativo con --env-file, evitando una dipendenza in più. Sintassi e ordine di priorità delle variabili sono documentati nella documentazione della riga di comando di Node.js.

.gitignore

node_modules/
.env
npm-debug.log*

.env.example

Questo file descrive le variabili necessarie senza contenere alcun segreto:

DISCORD_TOKEN=
DISCORD_CLIENT_ID=
DISCORD_GUILD_ID=

.env

Create poi la vostra copia locale:

DISCORD_TOKEN=incollate_qui_il_token_del_bot
DISCORD_CLIENT_ID=incollate_qui_application_id
DISCORD_GUILD_ID=incollate_qui_id_del_server_di_test

Per copiare l'identificativo del server, attivate Impostazioni utente > Avanzate > Modalità sviluppatore, poi fate clic destro sull'icona del server e scegliete Copia ID server.

Non pubblicate mai il vero .env. Eseguite git status prima del primo commit: il file .env non deve comparire tra i file tracciati.

5. Definire i comandi slash

Create src/commands.js:

import {
  PermissionFlagsBits,
  SlashCommandBuilder,
} from 'discord.js';

export const commands = [
  new SlashCommandBuilder()
    .setName('ping')
    .setDescription('Misura la latenza del bot'),

  new SlashCommandBuilder()
    .setName('server')
    .setDescription('Mostra le informazioni del server'),

  new SlashCommandBuilder()
    .setName('dire')
    .setDescription('Pubblica un messaggio tramite il bot')
    .addStringOption((option) =>
      option
        .setName('testo')
        .setDescription('Messaggio da pubblicare')
        .setRequired(true)
        .setMaxLength(1000),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageMessages),
];

export const commandsJSON = commands.map((command) => command.toJSON());

SlashCommandBuilder costruisce un oggetto JSON compatibile con l'API. La restrizione di /dire non è quindi un semplice controllo visivo nel nostro codice: Discord imposta anche ManageMessages come permesso predefinito del comando. Vedere le regole degli application command.

6. Registrare i comandi presso Discord

Il codice del bot e l'elenco dei comandi sono due risorse distinte. Modificare commands.js non aggiorna automaticamente l'interfaccia Discord: bisogna inviare la nuova definizione all'API.

Create src/deploy-commands.js:

import { REST, Routes } from 'discord.js';
import { commandsJSON } from './commands.js';

const token = process.env.DISCORD_TOKEN;
const clientId = process.env.DISCORD_CLIENT_ID;
const guildId = process.env.DISCORD_GUILD_ID;
const deployGlobally = process.argv.includes('--global');

if (!token || !clientId || (!deployGlobally && !guildId)) {
  throw new Error(
    'Variabili richieste: DISCORD_TOKEN, DISCORD_CLIENT_ID' +
      (deployGlobally ? '' : ' e DISCORD_GUILD_ID'),
  );
}

const rest = new REST({ version: '10' }).setToken(token);
const route = deployGlobally
  ? Routes.applicationCommands(clientId)
  : Routes.applicationGuildCommands(clientId, guildId);

try {
  console.log(
    `Registrazione di ${commandsJSON.length} comando/i ` +
      (deployGlobally ? 'globali' : `sul server ${guildId}`),
  );

  const result = await rest.put(route, { body: commandsJSON });
  console.log(`${result.length} comando/i registrato/i.`);
} catch (error) {
  console.error('Registrazione dei comandi non riuscita:', error);
  process.exitCode = 1;
}

Durante lo sviluppo, registrate i comandi solo sul vostro server di test:

npm run deploy:guild

La richiesta PUT sostituisce tutti i comandi su quella rotta. Non inserite questo rilascio in index.js: riscrivere i comandi a ogni riavvio è inutile e mescola due operazioni distinte.

Quando il bot è convalidato e pronto per essere installato su più server:

npm run deploy:global

Dopo ogni modifica di nome, descrizione, opzione o permesso, rilanciate il comando di rilascio corrispondente.

7. Programmare il client e gestire le interazioni

Create src/index.js:

import {
  Client,
  Events,
  GatewayIntentBits,
  MessageFlags,
} from 'discord.js';

const token = process.env.DISCORD_TOKEN;

if (!token) {
  throw new Error('La variabile DISCORD_TOKEN è assente.');
}

const client = new Client({
  intents: [GatewayIntentBits.Guilds],
});

client.once(Events.ClientReady, (readyClient) => {
  console.log(
    `Connesso come ${readyClient.user.tag} ` +
      `su ${readyClient.guilds.cache.size} server.`,
  );
});

client.on(Events.InteractionCreate, async (interaction) => {
  if (!interaction.isChatInputCommand()) return;

  try {
    switch (interaction.commandName) {
      case 'ping': {
        const gatewayLatency = Math.round(client.ws.ping);
        const interactionLatency = Date.now() - interaction.createdTimestamp;

        await interaction.reply({
          content:
            `Pong! Gateway: ${gatewayLatency} ms · ` +
            `interazione: ${interactionLatency} ms`,
          flags: MessageFlags.Ephemeral,
        });
        break;
      }

      case 'server': {
        if (!interaction.inGuild()) {
          await interaction.reply({
            content: 'Questo comando funziona solo dentro un server.',
            flags: MessageFlags.Ephemeral,
          });
          break;
        }

        await interaction.reply({
          content:
            `Server: **${interaction.guild.name}**\n` +
            `Membri: **${interaction.guild.memberCount}**\n` +
            `Identificativo: \`${interaction.guild.id}\``,
          flags: MessageFlags.Ephemeral,
        });
        break;
      }

      case 'dire': {
        if (!interaction.inGuild() || !interaction.channel?.isTextBased()) {
          await interaction.reply({
            content: 'Nessun canale testuale utilizzabile.',
            flags: MessageFlags.Ephemeral,
          });
          break;
        }

        const text = interaction.options.getString('testo', true);

        await interaction.channel.send({
          content: text,
          allowedMentions: { parse: [] },
        });

        await interaction.reply({
          content: 'Messaggio pubblicato.',
          flags: MessageFlags.Ephemeral,
        });
        break;
      }

      default:
        await interaction.reply({
          content: 'Comando sconosciuto.',
          flags: MessageFlags.Ephemeral,
        });
    }
  } catch (error) {
    console.error(
      `Errore durante /${interaction.commandName} ` +
        `(interazione ${interaction.id}):`,
      error,
    );

    const response = {
      content: 'Si è verificato un errore interno. Riprovate più tardi.',
      flags: MessageFlags.Ephemeral,
    };

    if (interaction.replied || interaction.deferred) {
      await interaction.followUp(response).catch(console.error);
    } else {
      await interaction.reply(response).catch(console.error);
    }
  }
});

client.on(Events.Error, (error) => {
  console.error('Errore del client Discord:', error);
});

async function shutdown(signal) {
  console.log(`${signal} ricevuto: arresto del bot.`);
  await client.destroy();
  process.exit(0);
}

process.once('SIGINT', () => void shutdown('SIGINT'));
process.once('SIGTERM', () => void shutdown('SIGTERM'));

await client.login(token);

Perché queste scelte tecniche?

• GatewayIntentBits.Guilds è l'unico intent necessario a questi comandi.
• interaction.isChatInputCommand() ignora in modo pulito gli altri tipi di interazione.
• getString('testo', true) indica che l'opzione è obbligatoria e restituisce una stringa.
• allowedMentions: { parse: [] } impedisce a un utente di iniettare tramite /dire una menzione interpretata come @everyone, un ruolo o un utente.
• MessageFlags.Ephemeral rende conferme ed errori visibili solo a chi ha lanciato il comando.
• SIGINT e SIGTERM permettono al terminale o al provider di chiudere la connessione in modo pulito.
• il messaggio destinato all'utente resta generico; i dettagli dell'errore finiscono nei log senza esporre lo stack tecnico su Discord.

8. Rispettare il limite di tre secondi delle interazioni

Discord invalida l'interazione se il bot non invia una risposta iniziale entro tre secondi. Il token dell'interazione resta poi utilizzabile per quindici minuti per modificare la risposta o inviare messaggi di follow-up. Questi tempi sono indicati in Receiving and Responding to Interactions.

Per un database o un'API che possono richiedere più di tre secondi, confermate subito la ricezione:

await interaction.deferReply({
  flags: MessageFlags.Ephemeral,
});

const result = await operazioneLenta();

await interaction.editReply({
  content: `Risultato: ${result}`,
});

Non usate reply() dopo deferReply(): concludete con editReply() o followUp().

9. Avviare e testare il bot in locale

Registrate prima i comandi, poi avviate il processo:

npm run deploy:guild
npm start

La console dovrebbe mostrare un messaggio simile a:

Connesso come MioBot#0000 su 1 server.

In Discord, provate:

1. /ping: la risposta è privata;
2. /server: compaiono nome, numero di membri e identificativo;
3. /dire testo:Ciao con un account autorizzato;
4. /dire con un account senza ManageMessages: il comando deve risultare non disponibile per impostazione predefinita;
5. /dire testo:@everyone test: il testo può comparire, ma non deve essere attivata alcuna menzione.

Provate su un server separato prima della produzione. Controllate anche i permessi canale per canale: un ruolo può consentire Send Messages a livello globale ed essere negato in un canale preciso.

10. Aggiungere un messaggio di benvenuto, solo se serve

L'arrivo di un membro non è coperto dall'intent Guilds. Per ascoltare guildMemberAdd occorre attivare Server Members Intent in Bot > Privileged Gateway Intents, aggiungere GatewayIntentBits.GuildMembers nel client, memorizzare l'identificativo del canale in WELCOME_CHANNEL_ID e verificare che il bot possa vedere il canale e scrivervi.

Modifica del client:

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMembers,
  ],
});

Aggiungete poi l'evento:

client.on(Events.GuildMemberAdd, async (member) => {
  const channelId = process.env.WELCOME_CHANNEL_ID;
  if (!channelId) return;

  const channel = await member.guild.channels
    .fetch(channelId)
    .catch(() => null);

  if (!channel?.isTextBased()) return;

  await channel.send({
    content: `Benvenuto ${member} su **${member.guild.name}**!`,
    allowedMentions: { users: [member.id] },
  });
});

Un identificativo di canale è più affidabile di una ricerca per nome: più canali possono avere nomi simili, e una rinomina non rompe la configurazione.

Non attivate MessageContent, GuildMembers o GuildPresences «per sicurezza». Ogni intent aumenta i dati ricevuti e la portata di un'eventuale compromissione.

11. Ospitare il bot in modo continuo su OuiPanel

Un bot avviato sul vostro computer si ferma con il terminale, la sospensione o la connessione a Internet. Per un servizio continuo, usate un ambiente Node.js supervisionato.

La pagina hosting bot Discord di OuiHeberg annuncia tra l'altro Node.js, il riavvio automatico, i backup, la pianificazione di attività e il cambio di versione dal pannello. La documentazione OuiPanel dedicata a discord.js descrive l'upload tramite gestore file o SFTP, la scelta del file di avvio e l'installazione delle dipendenze al primo lancio.

Preparare l'upload

Caricate src/, package.json, package-lock.json ed eventualmente .env.example senza alcun valore reale.

Non caricate node_modules/, che sarà ricreato per il sistema del server, né la cartella .git/, né il vostro .env locale se preferite crearlo direttamente nel pannello.

Configurazione consigliata

1. selezionate Node.js 24 LTS;
2. caricate i file dal gestore o via SFTP;
3. create .env direttamente sul server con le tre variabili;
4. impostate src/index.js come file principale se il pannello chiede un «Main File»;
5. lasciate che l'installazione npm avvenga al primo avvio;
6. avviate il server e controllate i log;
7. attivate un backup dopo aver convalidato la configurazione.

Lo script start di questo progetto carica .env. I comandi slash vanno rilasciati solo dopo una modifica del loro schema: eseguite npm run deploy:guild durante i test o npm run deploy:global per la pubblicazione.

Per i prezzi e le caratteristiche aggiornate, consultate la pagina delle offerte Node.js.

12. Sicurezza e gestione in produzione

Ridurre i privilegi

• non concedete mai Administrator per impostazione predefinita;
• attivate solo gli intent usati dal codice;
• limitate i comandi sensibili con setDefaultMemberPermissions();
• controllate anche i permessi lato server per le operazioni critiche;
• evitate di registrare nei log token, intestazioni HTTP o dati personali non necessari.

Gestire le dipendenze

Conservate package-lock.json e installate in produzione con:

npm ci --omit=dev

Prima di un aggiornamento:

npm outdated
npm audit

npm audit è un segnale utile, non una garanzia assoluta. Leggete le note di versione, provate su un server Discord separato, poi rilasciate. Un backup non sostituisce un repository Git pulito.

Rispettare i rate limit

Discord applica limiti per rotta e un limite HTTP globale. Una risposta 429 indica che occorre attendere la durata indicata da Retry-After o retry_after. discord.js gestisce la coda delle chiamate più comuni; non aggirate questo meccanismo con cicli di richieste parallele. Discord indica un limite globale di 50 richieste HTTP al secondo per bot nella sua documentazione sui rate limit.

Registrare ciò che serve davvero

Per ogni errore di comando, registrate almeno l'ora, il nome del comando, l'identificativo dell'interazione, il tipo di errore e uno stack tecnico lato server.

Evitate di conservare il contenuto dei messaggi se non è necessario. Definite una durata di conservazione dei log e limitatene l'accesso.

Monitorare il processo

Un bot «online» non è necessariamente funzionante. Verificate che il processo riparta dopo un crash controllato, che /ping risponda, che la latenza non derivi nel tempo, che errori e disconnessioni siano visibili nei log e che i backup possano essere davvero ripristinati.

13. Risoluzione dei problemi: errori frequenti

Sintomo o errore	Causa probabile	Correzione
An invalid token was provided	token assente, vecchio o copiato male	verificate .env; se serve, reimpostate il token nel Developer Portal
Used disallowed intents o chiusura 4014	intent privilegiato richiesto ma non attivato o non autorizzato	togliete l'intent inutile o attivatelo in Bot, poi verificatene l'idoneità
Cannot find package 'discord.js'	dipendenze non installate	eseguite npm ci o riavviate l'installazione dal pannello
I comandi non compaiono	Application ID errato, Guild ID errato o comandi non rilasciati	verificate .env, poi rilanciate npm run deploy:guild
Interaction failed	nessuna risposta iniziale entro tre secondi	usate deferReply(), poi editReply()
Missing Permissions o codice API 50013	permesso del bot o del canale mancante	controllate ruolo, permessi del canale e gerarchia
/dire non è visibile a un membro	il membro non ha ManageMessages	è il comportamento previsto; regolate il permesso del comando se necessario
Il bot è offline sull'hosting	processo fermo, versione di Node errata o file principale sbagliato	scegliete Node.js 24 e src/index.js, poi leggete il primo errore nei log
Vecchi comandi ancora visibili	schema non ridistribuito sulla rotta giusta	rilanciate il rilascio guild o global corrispondente
Le risposte vengono inviate due volte	più processi usano lo stesso token	fermate le istanze doppie e tenete un processo per bot, salvo un'architettura di sharding voluta

Partite sempre dal primo errore della console. I messaggi successivi sono spesso conseguenze dello stesso guasto iniziale.

14. Far crescere il progetto senza renderlo fragile

Il router switch è volutamente leggibile per tre comandi. Quando il progetto cresce:

• mettete ogni comando in un proprio modulo con data ed execute;
• caricate i moduli all'avvio in una Collection;
• validate tutti gli input prima di una chiamata a un'API o a un database;
• usate query parametrizzate per SQL;
• aggiungete test unitari sulla logica applicativa;
• separate gli ambienti di sviluppo e di produzione;
• prevedete le migrazioni del database e il loro rollback;
• valutate lo sharding solo quando la dimensione del bot lo giustifica.

Una buona architettura non consiste nel moltiplicare le cartelle il primo giorno. Consiste nell'isolare le responsabilità nel momento in cui diventano difficili da testare o mantenere.

Domande frequenti

Si può creare un bot Discord gratuitamente?

Sì. Il Developer Portal, l'API Discord, Node.js e discord.js si possono usare gratuitamente. L'esecuzione locale non costa nulla, ma dipende dal vostro computer. Un hosting permanente diventa utile quando il bot deve restare disponibile senza la vostra macchina.

Bisogna saper programmare?

Occorre capire le basi di JavaScript e dell'asincronia per mantenere un bot in modo affidabile. Copiare un token in un esempio può bastare a mostrare «online», ma non a mettere in sicurezza, diagnosticare o far evolvere il servizio.

Perché usare i comandi slash invece di un prefisso?

Sono nativi nell'interfaccia Discord, validano le opzioni, mostrano l'aiuto in automatico ed evitano spesso l'intent privilegiato MessageContent. Dispongono inoltre di permessi configurabili per comando.

Perché il bot è online ma non risponde?

La connessione al Gateway può funzionare mentre i comandi non sono stati registrati, il bot non ha accesso al canale o il gestore delle interazioni solleva un errore. Consultate la console, provate /ping, poi verificate la rotta di rilascio e i permessi del canale.

Devo ridistribuire i comandi a ogni avvio?

No. Ridistribuiteli solo quando cambiano nome, descrizione, opzioni o permessi. Il processo principale deve solo connettersi e gestire le interazioni.

Mi serve l'intent Message Content?

Non per i comandi slash di questa guida. Diventa pertinente solo se una funzionalità deve davvero leggere il contenuto di messaggi ordinari e rispetta le condizioni di Discord.

Quale hosting scegliere per iniziare?

Un ambiente Node.js gestito è adatto a un primo bot: installazione delle dipendenze, versione di Node selezionabile, console e riavvio sono centralizzati. Un VPS dà più controllo, ma richiede di amministrare sistema, aggiornamenti, servizi e sicurezza.

Conclusione

Ora disponete di un bot Discord moderno: comandi slash registrati separatamente, un solo intent non privilegiato, permessi minimi, token fuori dal codice, errori gestiti e arresto pulito. Questa base è abbastanza semplice da capire e abbastanza rigorosa da accogliere un database, un'API esterna, un sistema di ticket o funzioni di moderazione.

Prima della messa in produzione, rifate tre controlli: il .env non è tracciato da Git, il bot non ha alcun permesso inutile e i comandi sono stati provati con un account non amministratore. Rilasciate poi su un ambiente Node.js supervisionato e monitorate davvero i log.

Fonti e documentazione di riferimento

• Discord: Building your first Discord Bot
• Discord: Bots and apps overview
• Discord: Application Commands
• Discord: Receiving and Responding to Interactions
• Discord: Gateway e intent
• Discord: Getting Started with Privileged Intent Review
• Discord: Permissions
• Discord: Rate Limits
• Discord Support: self-bot
• discord.js: documentazione 14.27.0
• discord.js: versioni pubblicate
• Node.js: calendario delle versioni
• Node.js: opzione --env-file
• OuiHeberg: hosting bot Discord
• OuiPanel: ospitare un bot discord.js