Comment créer un bot Discord en 2026 avec Node.js

Un bot Discord peut modérer un serveur, automatiser le support, publier des alertes ou relier une communauté à une API. Mais un bot moderne n'est plus un simple script qui lit les messages commençant par !. Aujourd'hui, la base saine consiste à utiliser les commandes slash, à demander le minimum d'intents et de permissions, à isoler le token et à séparer l'enregistrement des commandes du démarrage du bot.

Ce tutoriel construit un vrai projet Node.js avec :

/ping, pour vérifier la disponibilité et la latence ;
/serveur, pour afficher quelques informations sur le serveur ;
/dire, réservée aux membres autorisés à gérer les messages ;
un token stocké hors du code ;
une protection contre les mentions injectées dans /dire ;
des réponses d'erreur propres et un arrêt contrôlé du processus ;
un déploiement de test par serveur, puis un déploiement global en production.

Le code suit discord.js 14.27.0, publiée en juillet 2026, et Node.js 24 LTS. Node.js recommande les branches Active LTS ou Maintenance LTS pour la production, et la branche 20 ne reçoit plus de nouvelle version. Consultez toujours les versions Node.js maintenues et les versions publiées de discord.js avant une nouvelle installation.

Ce qu'est réellement un bot Discord

Une application Discord peut utiliser deux voies complémentaires :

le Gateway, une connexion WebSocket persistante qui transmet les événements en temps réel, par exemple une interaction ou l'arrivée d'un membre ;
l'API HTTP, utilisée pour enregistrer une commande, envoyer un message ou modifier une ressource.

discord.js fournit une abstraction JavaScript autour de ces API. Le Client maintient la connexion au Gateway ; l'objet REST effectue les appels HTTP. L'introduction officielle aux bots Discord décrit cette architecture.

Une précision importante : automatisez uniquement un compte bot créé dans le Developer Portal. Discord interdit les « self-bots », c'est-à-dire l'automatisation d'un compte utilisateur normal, et indique que cette pratique peut entraîner la fermeture du compte. Voir la politique officielle sur les self-bots.

Prérequis

Il vous faut un compte Discord, un serveur Discord de test sur lequel vous pouvez gérer les applications, Node.js 24 LTS, un éditeur comme Visual Studio Code, un terminal, et des bases en JavaScript : variables, fonctions et async/await.

Vérifiez votre environnement :

node --version
npm --version

discord.js 14.27.0 déclare officiellement Node.js 18 ou supérieur comme prérequis. Nous choisissons néanmoins Node.js 24 LTS dans ce guide, pour une raison simple : la branche 20 ne reçoit plus de nouvelle version, et faire tourner un bot exposé à Internet sur une branche qui ne reçoit plus de correctifs de sécurité n'est pas raisonnable. Toute version 24 récente convient.

1. Créer l'application dans le Discord Developer Portal

Ouvrez le Discord Developer Portal, puis :

cliquez sur New Application ;
donnez un nom à l'application ;
acceptez les conditions et validez ;
dans General Information, copiez l'Application ID ;
dans Bot, personnalisez le nom et l'avatar si nécessaire ;
dans Bot, utilisez Reset Token pour générer le token et copiez-le une seule fois.

Discord crée aujourd'hui un utilisateur bot avec chaque nouvelle application. Le parcours officiel est détaillé dans Building your first Discord Bot.

Le token n'est pas un identifiant public

Le token permet de se connecter comme le bot. Une personne qui l'obtient peut utiliser ses droits sur tous les serveurs où il est installé.

Ne placez jamais ce token dans index.js, dans une capture d'écran, dans un ticket ou un message Discord, dans Git même sur un dépôt privé, ni dans un exemple publié sur un blog.

En cas de fuite, retournez immédiatement dans Bot > Reset Token, puis remplacez la valeur sur l'hébergement. Supprimer un ancien commit ne suffit pas : le secret doit être révoqué.

2. Configurer l'installation et les permissions

Dans la page Installation du Developer Portal :

activez Guild Install ;
utilisez de préférence le Discord Provided Link ;
ajoutez les scopes applications.commands et bot ;
accordez seulement View Channels et Send Messages pour ce projet ;
ouvrez le lien, sélectionnez votre serveur de test et autorisez l'application.

N'accordez pas Administrator « pour que cela fonctionne » : cette permission contourne les restrictions de salons et donne beaucoup plus de pouvoir que nécessaire.

La permission d'utiliser /dire sera contrôlée au niveau de la commande par ManageMessages. Le bot, lui, a seulement besoin de voir le salon et d'y envoyer un message. Cette distinction applique le principe du moindre privilège.

Permissions Discord et hiérarchie des rôles

Les permissions du bot ne suffisent pas toujours. Pour gérer un rôle, expulser un membre ou modifier un pseudonyme, le rôle le plus élevé du bot doit aussi être placé au-dessus de la cible dans la hiérarchie. Discord détaille ce mécanisme dans sa référence officielle des permissions.

3. Comprendre les intents avant de coder

Les Gateway Intents déterminent les catégories d'événements que Discord envoie au bot. Ils réduisent les données reçues et l'accès aux informations sensibles.

Ce tutoriel n'utilise que GatewayIntentBits.Guilds. Cet intent non privilégié suffit pour recevoir les interactions des commandes slash installées sur les serveurs. Nous n'avons besoin ni de lire tous les messages ni de télécharger la liste complète des membres.

Trois intents sont privilégiés : GuildPresences, GuildMembers et MessageContent. Ils doivent être activés dans le Developer Portal et déclarés dans le code. Discord peut fermer la connexion avec le code 4014 lorsqu'un bot demande un intent privilégié non autorisé.

Depuis le 10 juin 2026, l'examen des intents privilégiés ne repose plus sur le nombre de serveurs mais sur le nombre d'utilisateurs uniques pouvant voir votre application, tous serveurs confondus. Au-delà de 10 000, une demande d'accès devient nécessaire. Un bot présent sur cinquante gros serveurs peut donc atteindre ce seuil. Les règles à jour figurent dans la documentation Gateway et le guide d'examen des intents privilégiés.

Pour un nouveau bot, les commandes slash évitent généralement MessageContent. Discord les recommande comme alternative aux anciennes commandes textuelles à préfixe.

4. Initialiser le projet Node.js

Créez le dossier du projet :

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

Nous fixons ici la version de discord.js pour obtenir une installation reproductible. Conservez le fichier package-lock.json : sur le serveur, npm ci pourra installer exactement les versions validées.

La structure finale sera la suivante :

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

package.json

Remplacez son contenu par :

{
  "name": "mon-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"
  }
}

Le champ engines est ici notre propre choix, pas une contrainte de discord.js : il documente la branche Node sur laquelle le projet est censé tourner et fait échouer une installation sur une version plus ancienne.

"type": "module" active la syntaxe moderne import. Node.js sait charger nativement .env avec --env-file, ce qui évite une dépendance supplémentaire. La syntaxe et l'ordre de priorité des variables sont documentés dans la référence de la ligne de commande Node.js.

.gitignore

node_modules/
.env
npm-debug.log*

.env.example

Ce fichier décrit les variables nécessaires sans contenir de secret :

DISCORD_TOKEN=
DISCORD_CLIENT_ID=
DISCORD_GUILD_ID=

.env

Créez ensuite votre copie locale :

DISCORD_TOKEN=collez_le_token_du_bot_ici
DISCORD_CLIENT_ID=collez_application_id_ici
DISCORD_GUILD_ID=collez_id_du_serveur_de_test_ici

Pour copier l'identifiant du serveur, activez Paramètres utilisateur > Avancés > Mode développeur, puis faites un clic droit sur l'icône du serveur et choisissez Copier l'identifiant du serveur.

Ne publiez jamais le vrai .env. Exécutez git status avant le premier commit : le fichier .env ne doit pas apparaître dans les fichiers suivis.

5. Définir les slash commands

Créez src/commands.js :

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

export const commands = [
  new SlashCommandBuilder()
    .setName('ping')
    .setDescription('Mesure la latence du bot'),

  new SlashCommandBuilder()
    .setName('serveur')
    .setDescription('Affiche les informations du serveur'),

  new SlashCommandBuilder()
    .setName('dire')
    .setDescription('Publie un message via le bot')
    .addStringOption((option) =>
      option
        .setName('texte')
        .setDescription('Message à publier')
        .setRequired(true)
        .setMaxLength(1000),
    )
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageMessages),
];

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

SlashCommandBuilder fabrique un objet JSON compatible avec l'API. La restriction de /dire n'est donc pas un simple contrôle visuel dans notre code : Discord définit aussi ManageMessages comme permission par défaut de la commande. Voir les règles des application commands.

6. Enregistrer les commandes auprès de Discord

Le code du bot et la liste des commandes sont deux ressources différentes. Modifier commands.js ne met pas automatiquement à jour l'interface Discord : il faut envoyer la nouvelle définition à l'API.

Créez 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(
    'Variables requises : DISCORD_TOKEN, DISCORD_CLIENT_ID' +
      (deployGlobally ? '' : ' et DISCORD_GUILD_ID'),
  );
}

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

try {
  console.log(
    `Enregistrement de ${commandsJSON.length} commande(s) ` +
      (deployGlobally ? 'globales' : `sur le serveur ${guildId}`),
  );

  const result = await rest.put(route, { body: commandsJSON });
  console.log(`${result.length} commande(s) enregistrée(s).`);
} catch (error) {
  console.error("Échec de l'enregistrement des commandes :", error);
  process.exitCode = 1;
}

Pendant le développement, enregistrez les commandes uniquement sur votre serveur de test :

npm run deploy:guild

La requête PUT remplace l'ensemble des commandes sur cette route. Ne placez pas ce déploiement dans index.js : il est inutile de réécrire les commandes à chaque redémarrage et cela mélange deux opérations distinctes.

Quand le bot est validé et prêt à être installé sur plusieurs serveurs :

npm run deploy:global

Après toute modification de nom, description, option ou permission, relancez la commande de déploiement correspondante.

7. Programmer le client et traiter les interactions

Créez src/index.js :

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

const token = process.env.DISCORD_TOKEN;

if (!token) {
  throw new Error('La variable DISCORD_TOKEN est absente.');
}

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

client.once(Events.ClientReady, (readyClient) => {
  console.log(
    `Connecté comme ${readyClient.user.tag} ` +
      `sur ${readyClient.guilds.cache.size} serveur(s).`,
  );
});

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 · ` +
            `interaction : ${interactionLatency} ms`,
          flags: MessageFlags.Ephemeral,
        });
        break;
      }

      case 'serveur': {
        if (!interaction.inGuild()) {
          await interaction.reply({
            content: 'Cette commande fonctionne uniquement dans un serveur.',
            flags: MessageFlags.Ephemeral,
          });
          break;
        }

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

      case 'dire': {
        if (!interaction.inGuild() || !interaction.channel?.isTextBased()) {
          await interaction.reply({
            content: 'Aucun salon textuel utilisable.',
            flags: MessageFlags.Ephemeral,
          });
          break;
        }

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

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

        await interaction.reply({
          content: 'Message publié.',
          flags: MessageFlags.Ephemeral,
        });
        break;
      }

      default:
        await interaction.reply({
          content: 'Commande inconnue.',
          flags: MessageFlags.Ephemeral,
        });
    }
  } catch (error) {
    console.error(
      `Erreur pendant /${interaction.commandName} ` +
        `(interaction ${interaction.id}) :`,
      error,
    );

    const response = {
      content: 'Une erreur interne est survenue. Réessayez plus tard.',
      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('Erreur du client Discord :', error);
});

async function shutdown(signal) {
  console.log(`${signal} reçu : arrêt du bot.`);
  await client.destroy();
  process.exit(0);
}

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

await client.login(token);

Pourquoi ces choix techniques ?

GatewayIntentBits.Guilds est le seul intent nécessaire à ces commandes.
interaction.isChatInputCommand() ignore proprement les autres types d'interactions.
getString('texte', true) indique que l'option est obligatoire et renvoie une chaîne.
allowedMentions: { parse: [] } empêche un utilisateur d'injecter une mention interprétée telle que @everyone, un rôle ou un utilisateur via /dire.
MessageFlags.Ephemeral rend les confirmations et erreurs visibles uniquement par la personne qui a lancé la commande.
SIGINT et SIGTERM permettent au terminal ou à l'hébergeur de fermer la connexion proprement.
le message destiné à l'utilisateur reste générique ; les détails de l'erreur sont écrits dans les journaux sans exposer la pile technique sur Discord.

8. Respecter la limite de trois secondes des interactions

Discord invalide l'interaction si le bot n'envoie pas de réponse initiale dans les trois secondes. Le token d'interaction reste ensuite utilisable pendant quinze minutes pour modifier la réponse ou envoyer des messages de suivi. Ces délais sont précisés dans Receiving and Responding to Interactions.

Pour une base de données ou une API qui peut prendre plus de trois secondes, accusez réception immédiatement :

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

const result = await operationLente();

await interaction.editReply({
  content: `Résultat : ${result}`,
});

N'utilisez pas reply() après deferReply() : terminez avec editReply() ou followUp().

9. Lancer et tester le bot localement

Enregistrez d'abord les commandes, puis démarrez le processus :

npm run deploy:guild
npm start

La console doit afficher un message semblable à :

Connecté comme MonBot#0000 sur 1 serveur(s).

Dans Discord, testez :

/ping : la réponse est privée ;
/serveur : le nom, le nombre de membres et l'identifiant apparaissent ;
/dire texte:Bonjour avec un compte autorisé ;
/dire avec un compte sans ManageMessages : la commande doit être indisponible par défaut ;
/dire texte:@everyone test : le texte peut apparaître, mais aucune mention ne doit être déclenchée.

Testez sur un serveur séparé avant la production. Contrôlez aussi les permissions salon par salon : un rôle peut autoriser Send Messages globalement tout en étant refusé dans un salon précis.

10. Ajouter un message de bienvenue, seulement si nécessaire

L'arrivée d'un membre n'est pas couverte par l'intent Guilds. Pour écouter guildMemberAdd, il faut activer Server Members Intent dans Bot > Privileged Gateway Intents, ajouter GatewayIntentBits.GuildMembers dans le client, stocker l'identifiant du salon dans WELCOME_CHANNEL_ID, et vérifier que le bot peut voir le salon et y écrire.

Modification du client :

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

Ajoutez ensuite l'événement :

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: `Bienvenue ${member} sur **${member.guild.name}** !`,
    allowedMentions: { users: [member.id] },
  });
});

Un identifiant de salon est plus fiable qu'une recherche par nom : plusieurs salons peuvent porter un nom similaire, et un renommage ne casse pas la configuration.

N'activez pas MessageContent, GuildMembers ou GuildPresences « au cas où ». Chaque intent augmente les données reçues et la portée d'une éventuelle compromission.

11. Héberger le bot en continu sur OuiPanel

Un bot lancé sur votre ordinateur s'arrête avec le terminal, la mise en veille ou la connexion Internet. Pour un service continu, utilisez un environnement Node.js supervisé.

La page hébergement bot Discord OuiHeberg annonce notamment Node.js, le redémarrage automatique, des sauvegardes, la planification de tâches et le changement de version depuis le panel. La documentation OuiPanel consacrée à discord.js détaille l'upload par gestionnaire de fichiers ou SFTP, le choix du fichier de démarrage et l'installation des dépendances au premier lancement.

Préparer l'archive

Envoyez src/, package.json, package-lock.json et éventuellement .env.example sans aucune valeur réelle.

N'envoyez pas node_modules/, qui sera recréé pour le système du serveur, ni le dossier .git/, ni votre .env local si vous préférez le créer directement dans le panel.

Configuration recommandée

sélectionnez Node.js 24 LTS ;
uploadez les fichiers par le gestionnaire ou SFTP ;
créez .env directement sur le serveur avec les trois variables ;
définissez src/index.js comme fichier principal si le panel demande un « Main File » ;
laissez l'installation npm s'effectuer au premier démarrage ;
démarrez le serveur et contrôlez les journaux ;
activez une sauvegarde après validation de la configuration.

Le script start de ce projet charge .env. Les commandes slash n'ont besoin d'être déployées qu'après une modification de leur schéma : exécutez npm run deploy:guild pendant les tests ou npm run deploy:global pour la publication.

Pour les tarifs et les caractéristiques à jour, consultez la page des offres Node.js.

12. Sécurité et exploitation en production

Réduire les privilèges

n'accordez jamais Administrator par défaut ;
activez uniquement les intents utilisés par le code ;
limitez les commandes sensibles avec setDefaultMemberPermissions() ;
contrôlez aussi les permissions côté serveur pour les opérations critiques ;
évitez de journaliser des tokens, des en-têtes HTTP ou des données personnelles inutiles.

Gérer les dépendances

Conservez package-lock.json et installez en production avec :

npm ci --omit=dev

Avant une mise à jour :

npm outdated
npm audit

npm audit est un signal utile, pas une garantie absolue. Lisez les changements de version, testez sur un serveur Discord séparé, puis déployez. Une sauvegarde ne remplace pas un dépôt Git propre.

Respecter les rate limits

Discord applique des limites par route et une limite HTTP globale. Une réponse 429 indique qu'il faut attendre la durée annoncée par Retry-After ou retry_after. discord.js gère la mise en file des appels courants ; ne contournez pas ce mécanisme avec des boucles de requêtes parallèles. Discord précise une limite globale de 50 requêtes HTTP par seconde par bot dans sa documentation des rate limits.

Journaliser ce qui aide vraiment

Pour chaque erreur de commande, journalisez au minimum l'heure, le nom de la commande, l'identifiant de l'interaction, le type d'erreur et une pile technique côté serveur.

Évitez de conserver le contenu des messages si ce n'est pas nécessaire. Définissez une durée de rétention des journaux et restreignez leur accès.

Surveiller le processus

Un bot « en ligne » n'est pas forcément fonctionnel. Vérifiez que le processus redémarre après un crash contrôlé, que /ping répond, que la latence ne dérive pas durablement, que les erreurs et déconnexions sont visibles dans les journaux, et que les sauvegardes peuvent réellement être restaurées.

13. Dépannage : erreurs fréquentes

Symptôme ou erreur	Cause probable	Correction
`An invalid token was provided`	token absent, ancien ou mal copié	vérifiez `.env` ; si nécessaire, réinitialisez le token dans le Developer Portal
`Used disallowed intents` ou fermeture `4014`	intent privilégié demandé mais non activé ou non autorisé	retirez l'intent inutile ou activez-le dans Bot, puis vérifiez son éligibilité
`Cannot find package 'discord.js'`	dépendances non installées	exécutez `npm ci` ou redémarrez l'installation depuis le panel
Les commandes n'apparaissent pas	mauvaise Application ID, mauvaise Guild ID ou commandes non déployées	vérifiez `.env`, puis relancez `npm run deploy:guild`
`Interaction failed`	aucune réponse initiale sous trois secondes	utilisez `deferReply()`, puis `editReply()`
`Missing Permissions` ou code API `50013`	permission bot ou permission du salon manquante	contrôlez le rôle, les permissions du salon et la hiérarchie
`/dire` n'est pas visible pour un membre	le membre ne possède pas `ManageMessages`	c'est le comportement attendu ; ajustez la permission de commande si nécessaire
Le bot est hors ligne sur l'hébergement	processus arrêté, mauvaise version Node ou mauvais fichier principal	choisissez Node.js 24, `src/index.js`, puis lisez la première erreur des journaux
Anciennes commandes encore visibles	schéma non redéployé sur la bonne route	relancez le déploiement guild ou global correspondant
Les réponses sont envoyées deux fois	plusieurs processus utilisent le même token	arrêtez les instances en double et gardez un seul processus par bot, sauf architecture de sharding maîtrisée

Commencez toujours par la première erreur de la console. Les messages qui suivent sont souvent des conséquences du même échec initial.

14. Faire évoluer le projet sans le rendre fragile

Le routeur switch est volontairement lisible pour trois commandes. Quand le projet grandit :

placez chaque commande dans son propre module avec data et execute ;
chargez les modules au démarrage dans une Collection ;
validez toutes les entrées avant un appel à une API ou une base de données ;
utilisez des requêtes paramétrées pour SQL ;
ajoutez des tests unitaires sur la logique métier ;
séparez les environnements de développement et de production ;
prévoyez les migrations de base de données et leur retour arrière ;
envisagez le sharding seulement lorsque la taille du bot le justifie.

Une bonne architecture ne consiste pas à multiplier les dossiers dès le premier jour. Elle consiste à isoler les responsabilités au moment où elles deviennent difficiles à tester ou à maintenir.

Questions fréquentes

Peut-on créer un bot Discord gratuitement ?

Oui. Le Developer Portal, l'API Discord, Node.js et discord.js peuvent être utilisés gratuitement. L'exécution locale ne coûte rien, mais elle dépend de votre ordinateur. Un hébergement permanent devient utile lorsque le bot doit rester disponible sans votre machine.

Faut-il savoir programmer ?

Il faut comprendre les bases de JavaScript et de l'asynchronisme pour maintenir un bot de façon fiable. Copier un token dans un exemple peut suffire à afficher « en ligne », mais pas à sécuriser, diagnostiquer ou faire évoluer le service.

Pourquoi utiliser des slash commands plutôt qu'un préfixe ?

Elles sont natives dans l'interface Discord, valident les options, affichent l'aide automatiquement et évitent souvent l'intent privilégié MessageContent. Elles disposent aussi de permissions configurables par commande.

Pourquoi le bot est-il en ligne mais ne répond pas ?

La connexion Gateway peut fonctionner alors que les commandes n'ont pas été enregistrées, que le bot n'a pas accès au salon ou que le gestionnaire d'interactions lève une erreur. Consultez la console, testez /ping, puis vérifiez la route de déploiement et les permissions du salon.

Dois-je redéployer les commandes à chaque démarrage ?

Non. Redéployez-les uniquement lorsque leur nom, description, options ou permissions changent. Le processus principal doit seulement se connecter et traiter les interactions.

Ai-je besoin de l'intent Message Content ?

Pas pour les slash commands de ce guide. Il devient pertinent seulement si une fonctionnalité doit réellement lire le contenu de messages ordinaires et respecte les conditions de Discord.

Quel hébergement choisir pour commencer ?

Un environnement Node.js géré convient à un premier bot : installation des dépendances, version Node sélectionnable, console et redémarrage sont centralisés. Un VPS donne davantage de contrôle, mais demande d'administrer le système, les mises à jour, les services et la sécurité.

Conclusion

Vous disposez maintenant d'un bot Discord moderne : commandes slash enregistrées séparément, un seul intent non privilégié, permissions minimales, token hors du code, erreurs gérées et arrêt propre. Cette base est assez simple pour être comprise et assez rigoureuse pour accueillir une base de données, une API externe, un système de tickets ou des fonctions de modération.

Avant la mise en production, refaites trois contrôles : le .env n'est pas suivi par Git, le bot n'a aucune permission inutile et les commandes ont été testées avec un compte non administrateur. Déployez ensuite sur un environnement Node.js supervisé et surveillez réellement les journaux.