Aller au contenu
+90 850 303 07 52 [email protected]
Assistance Espace client
Sur une sélection d'offres d'hébergement annuelles et de VDS sur 3 mois, nom de domaine .com / .com.tr offert la première année · Voir les offres

Guides

Des guides pas à pas pour installer et gérer votre propre serveur, serveur de jeu ou site web, rédigés par l'équipe qui exploite notre infrastructure à Istanbul.

Bot Discord

Comment créer un bot de support (tickets) avec Discord.js v14 ?

26 août 2026 17 min de lecture Mis à jour :
Partager cet article

Un bot de tickets de support permet aux membres d'ouvrir, d'un clic sur un bouton, un salon visible uniquement par eux et par l'équipe de support ; une fois la conversation terminée, le salon est fermé et les échanges sont déposés sous forme de fichier dans un salon de logs. Dans ce guide, vous allez créer avec discord.js v14 un panneau doté d'un bouton « Ouvrir un ticket », un salon de ticket aux permissions configurées, un blocage du second ticket, un bouton de fermeture et une transcription en texte brut (copie de la conversation) ; à la dernière étape, vous mettrez en place le même système avec des fils privés (private threads, c'est-à-dire des sous-discussions). Les autres guides consacrés aux bots se trouvent sur la page Guides bot Discord.

Avant de commencer

  • Un projet de bot fonctionnel : les exemples reprennent la structure du guide de création d'un bot à partir de zéro : commands/utility, index.js, deploy-commands.js, le fichier .env qui contient le token et les scripts npm start / npm run deploy. Le code a été écrit d'après la documentation de discord.js 14.27.0.
  • Bases des boutons : customId, la règle des 3 secondes et les panneaux permanents sont expliqués dans le guide des boutons et menus déroulants ; ils ne sont pas repris ici.
  • Droits d'administration : vous devez pouvoir créer des rôles, des catégories et des salons, et modifier les permissions du rôle du bot. Pour copier des identifiants (ID), activez le Mode développeur (Developer Mode).
  • Où faire tourner le bot en permanence : lorsque le bot est hors ligne, le panneau ne répond pas. Le code est identique sous Windows et sous Linux ; vous pouvez développer sur votre ordinateur et faire tourner le bot sur un VDS. Les offres VDS pour bot Discord de HanHosting sont fournies avec 4 CPU, 2–4 Go de RAM et 30–40 Go de disque NVMe.

1. Préparer le rôle de support, la catégorie et le salon de logs

  1. Rôle de support : le rôle de l'équipe qui répondra aux tickets (p. ex. « Équipe support »).
  2. Catégorie des tickets : la catégorie dans laquelle les nouveaux salons de ticket seront créés. Ne désactivez pas ici la permission « Voir le salon » du rôle du bot. Une catégorie peut contenir 50 salons au maximum.
  3. Salon de logs : le salon textuel dans lequel arriveront les transcriptions. Désactivez « Voir le salon » (View Channel) pour @everyone ; activez « Voir le salon », « Envoyer des messages » (Send Messages) et « Joindre des fichiers » (Attach Files) pour le rôle de support et pour le rôle du bot.

Copiez l'identifiant de ces trois éléments depuis le menu du clic droit et ajoutez-les au fichier .env, sous la ligne DISCORD_TOKEN existante :

ROLE_SUPPORT_ID=111111111111111111
CATEGORIE_TICKETS_ID=222222222222222222
SALON_LOGS_TICKETS_ID=333333333333333333

Ainsi, le même code fonctionne sur un autre serveur en ne modifiant que ce fichier. Le token, lui aussi, ne se trouve qu'ici ; le fichier doit rester dans la liste .gitignore.

2. Configurer les permissions et les intents du bot

Le rôle du bot doit disposer des permissions suivantes à l'échelle du serveur : ViewChannel, SendMessages, ReadMessageHistory, AttachFiles et ManageChannels (l'interface française de Discord les affiche sous d'autres noms). La requête de création de salon exige ManageChannels. En outre, dans les remplacements de permissions (permission overwrites), Discord ne permet au bot d'autoriser ou de refuser que les permissions qu'il possède lui-même ; pour pouvoir accorder AttachFiles au propriétaire du ticket, le bot doit lui aussi disposer de cette permission. N'accordez pas Administrator : en cas de fuite du token, les dégâts seraient bien plus importants. La liste complète figure dans la documentation des permissions de Discord.

Dans le code, l'intent GatewayIntentBits.Guilds (autorisation d'événements) suffit : les interactions de bouton ne demandent aucun intent supplémentaire, et les événements de salon ainsi que le cache des salons arrivent avec cet intent. Pour la transcription, activez l'interrupteur Message Content Intent sur la page Developer Portal → Bot ; tant qu'il est désactivé, le texte, les pièces jointes et les embeds écrits par les utilisateurs arrivent vides dans les messages que le bot récupère via REST. Discord précise que cette restriction HTTP est indépendante de la liste d'intents de votre code ; vous n'avez pas besoin d'ajouter l'intent MessageContent au code.

3. Écrire la commande du panneau

commands/utility/panneau-tickets.js envoie, dans le salon où la commande est utilisée, un message doté d'un bouton « Ouvrir un ticket ». Par défaut, setDefaultMemberPermissions n'affiche la commande qu'aux membres disposant de la permission « Gérer le serveur » (Manage Server) ; la définition des commandes est expliquée dans le guide des commandes slash.

const {
  ActionRowBuilder, ButtonBuilder, ButtonStyle, MessageFlags,
  PermissionFlagsBits, SlashCommandBuilder,
} = require('discord.js');

module.exports = {
  data: new SlashCommandBuilder()
    .setName('panneau-tickets')
    .setDescription('Envoie le panneau des tickets de support dans ce salon.')
    .setDefaultMemberPermissions(PermissionFlagsBits.ManageGuild),
  async execute(interaction) {
    const bouton = new ButtonBuilder()
      .setCustomId('ouvrir-ticket')
      .setLabel('Ouvrir un ticket')
      .setStyle(ButtonStyle.Primary);
    await interaction.channel.send({
      content: "Cliquez sur le bouton pour obtenir de l'aide ; un ticket visible uniquement par vous et par l'équipe de support sera ouvert.",
      components: [new ActionRowBuilder().addComponents(bouton)],
    });
    await interaction.reply({ content: 'Panneau envoyé.', flags: MessageFlags.Ephemeral });
  },
};

Comme le panneau part sous la forme d'un message distinct, le bot doit avoir la permission d'envoyer des messages dans le salon du panneau.

4. Écrire le code d'ouverture des tickets

Créez le fichier ticket.js à la racine du projet. La première partie contient les réglages communs et la fonction qui ouvre le salon du ticket :

// ticket.js - ouverture et fermeture des tickets de support, transcription
const {
  ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle,
  ChannelType, MessageFlags, PermissionFlagsBits, ThreadAutoArchiveDuration,
} = require('discord.js');

const { ROLE_SUPPORT_ID, CATEGORIE_TICKETS_ID, SALON_LOGS_TICKETS_ID } = process.env;
const PREFIXE = 'proprietaire-ticket:';
const PERMISSIONS = [
  PermissionFlagsBits.ViewChannel,
  PermissionFlagsBits.SendMessages,
  PermissionFlagsBits.ReadMessageHistory,
  PermissionFlagsBits.AttachFiles,
];
const enOuverture = new Set(); // utilisateurs dont le ticket est en cours de création
const enFermeture = new Set(); // salons en cours de fermeture

function ligneFermeture() {
  return new ActionRowBuilder().addComponents(
    new ButtonBuilder()
      .setCustomId('fermer-ticket')
      .setLabel('Fermer le ticket')
      .setStyle(ButtonStyle.Danger),
  );
}

async function ouvrirTicket(interaction) {
  const { guild, user } = interaction;
  await interaction.deferReply({ flags: MessageFlags.Ephemeral });

  const existant = guild.channels.cache.find((k) => k.topic === PREFIXE + user.id);
  if (existant) return interaction.editReply(`Vous avez déjà un ticket ouvert : ${existant}`);
  if (enOuverture.has(user.id)) return interaction.editReply('Votre ticket est en cours de préparation, veuillez patienter.');
  enOuverture.add(user.id);

  try {
    const nom = user.username.toLowerCase().replace(/[^a-z0-9_-]/g, '') || user.id;
    const salon = await guild.channels.create({
      name: `ticket-${nom}`,
      type: ChannelType.GuildText,
      parent: CATEGORIE_TICKETS_ID,
      topic: PREFIXE + user.id,
      reason: `Ticket de support : ${user.username}`,
      permissionOverwrites: [
        { id: guild.roles.everyone.id, deny: [PermissionFlagsBits.ViewChannel] },
        { id: user.id, allow: PERMISSIONS },
        { id: ROLE_SUPPORT_ID, allow: PERMISSIONS },
        { id: interaction.client.user.id, allow: PERMISSIONS },
      ],
    });
    await salon.send({
      content: `${user}, votre ticket est ouvert. Décrivez votre problème en détail ; l'équipe de support vous répondra dans ce salon.`,
      components: [ligneFermeture()],
    });
    await interaction.editReply(`Votre ticket est ouvert : ${salon}`);
  } catch (erreur) {
    console.error(erreur);
    await interaction.editReply("Impossible d'ouvrir le ticket ; veuillez prévenir les responsables du serveur.");
  } finally {
    enOuverture.delete(user.id);
  }
}
  • Accuser réception d'abord : deferReply accuse immédiatement réception de l'interaction ; même si la création du salon dépasse 3 secondes, l'interaction n'échoue pas.
  • Blocage du second ticket : l'identifiant du propriétaire est écrit dans le sujet du salon (topic), puis recherché dans le cache avant l'ouverture d'un nouveau ticket. Comme le cache se remplit de nouveau au démarrage du bot, le contrôle fonctionne aussi après un redémarrage ; l'ensemble enOuverture intercepte un second clic arrivé avant la création du salon. Ne modifiez pas le sujet du salon à la main.
  • Permissions : Discord calcule les permissions d'un salon en appliquant d'abord @everyone, puis les remplacements de rôle et en dernier ceux de membre. Une personne qui n'a pas « Voir le salon » ne peut pas non plus utiliser les autres permissions du salon ; c'est pourquoi la ligne propre au bot est indispensable.
  • Nom du salon : tous les caractères du nom d'utilisateur autres que les lettres minuscules, les chiffres, _ et - sont supprimés ; le contrôle se fait par l'identifiant, pas par le nom.

5. Ajouter le bouton de fermeture et la transcription

Ajoutez la partie consacrée à la fermeture à la fin du même fichier :

async function collecterMessages(salon, max = 1000) {
  const messages = [];
  let before;
  while (messages.length < max) {
    const lot = await salon.messages.fetch({ limit: 100, before, cache: false });
    messages.push(...lot.values());
    if (lot.size < 100) break;
    before = lot.last().id;
  }
  return messages.reverse(); // du plus ancien au plus récent
}

function ligne(m) {
  const piecesJointes = m.attachments.map((e) => e.url).join(' ');
  return `[${m.createdAt.toISOString()}] ${m.author.username}: ${m.content} ${piecesJointes}`.trimEnd();
}

function trouverProprietaire(salon) {
  if (salon.isThread()) return salon.name.startsWith('ticket-') ? salon.name.split('-').pop() : null;
  return salon.topic?.startsWith(PREFIXE) ? salon.topic.slice(PREFIXE.length) : null;
}

async function fermerTicket(interaction) {
  const salon = interaction.channel;
  const proprietaireId = trouverProprietaire(salon);
  const membreSupport = interaction.member.roles.cache.has(ROLE_SUPPORT_ID);
  if (!proprietaireId || (!membreSupport && interaction.user.id !== proprietaireId)) {
    return interaction.reply({
      content: "Seuls le propriétaire du ticket et l'équipe de support peuvent le fermer.",
      flags: MessageFlags.Ephemeral,
    });
  }
  if (enFermeture.has(salon.id)) {
    return interaction.reply({ content: 'Le ticket est déjà en cours de fermeture.', flags: MessageFlags.Ephemeral });
  }
  enFermeture.add(salon.id);

  try {
    await interaction.deferReply();
    const texte = (await collecterMessages(salon)).map(ligne).join('\n');
    const fichier = new AttachmentBuilder(Buffer.from(texte, 'utf8'), { name: `${salon.name}.txt` });
    const logs = await interaction.guild.channels.fetch(SALON_LOGS_TICKETS_ID);
    await logs.send({
      content: `${salon.name} fermé. Propriétaire : <@${proprietaireId}>, fermé par : <@${interaction.user.id}>`,
      files: [fichier],
      allowedMentions: { parse: [] },
    });
    await interaction.editReply('Transcription enregistrée, fermeture du ticket en cours.');
    if (salon.isThread()) {
      await salon.setLocked(true);
      await salon.setArchived(true);
      enFermeture.delete(salon.id);
    } else {
      setTimeout(() => {
        salon.delete(`Ticket fermé : ${interaction.user.username}`)
          .catch(console.error)
          .finally(() => enFermeture.delete(salon.id));
      }, 5_000);
    }
  } catch (erreur) {
    console.error(erreur);
    enFermeture.delete(salon.id);
    await interaction.editReply('Impossible de fermer le ticket ; vérifiez le salon de logs et les permissions du bot.');
  }
}

module.exports = { ouvrirTicket, fermerTicket };
  • Autorisation : seuls le propriétaire et les membres du rôle de support peuvent fermer le ticket ; toute autre personne reçoit un avertissement visible d'elle seule. L'ensemble enFermeture empêche les doubles clics ; comme deferReply se trouve lui aussi dans le bloc try, une erreur ne laisse pas le verrou en place.
  • Limites de récupération des messages : la requête de liste des messages renvoie au maximum 100 messages à la fois (50 par défaut). À chaque tour, la boucle remonte avec before à partir du message le plus ancien du lot et s'arrête à 1 000 messages (10 requêtes) ; reverse() trie les messages du plus ancien au plus récent. before, after et around ne peuvent pas être utilisés ensemble. Si le bot n'a pas ReadMessageHistory, Discord renvoie une liste vide.
  • Fichiers et suppression : les pièces jointes ne sont écrites que sous forme d'adresse ; Discord fournit ces adresses avec une signature à durée limitée, et elles ne s'ouvrent plus au bout d'un certain temps. Si vous devez conserver les pièces jointes, téléchargez-les avant la suppression du salon. allowedMentions:{ parse: [] } empêche les mentions du message de log d'envoyer des notifications. La suppression d'un salon est irréversible ; le code ne passe à la suppression qu'une fois la transcription arrivée dans le salon de logs.

6. Relier les boutons à index.js et tester

En haut du fichier index.js, importez le fichier ticket.js, puis placez le contrôle des boutons au début de l'écouteur d'événements qui traite les commandes slash :

const { ouvrirTicket, fermerTicket } = require('./ticket.js');

client.on(Events.InteractionCreate, async (interaction) => {
  if (interaction.isButton()) {
    try {
      if (interaction.customId === 'ouvrir-ticket') await ouvrirTicket(interaction);
      else if (interaction.customId === 'fermer-ticket') await fermerTicket(interaction);
    } catch (erreur) {
      console.error(erreur);
    }
    return;
  }

  if (!interaction.isChatInputCommand()) return;
  // ... le code existant qui gère les commandes slash reste inchangé
});

Sans try/catch, une erreur levée sur une interaction expirée reste un rejet de Promise non intercepté ; par défaut, Node.js le traite comme une exception non interceptée et le processus peut s'arrêter. Enregistrez la commande et démarrez le bot (identique dans Windows PowerShell et sous Linux) :

npm run deploy
npm start

Utilisez la commande /panneau-tickets dans un salon. Avec un second compte, cliquez deux fois de suite sur le bouton « Ouvrir un ticket » : un seul salon doit être créé. Vérifiez qu'un troisième compte ne voit pas le salon et que, à la fermeture, la transcription arrive dans le salon de logs. Si le bot tourne avec PM2 sur un VDS (guide pour garder un bot Discord en ligne 24 h/24, 7 j/7), exécutez pm2 restart discord-bot après la mise à jour.

7. Variante : ouvrir les tickets dans des fils privés

Un fil privé (private thread) est une sous-discussion ouverte sous un salon textuel, visible uniquement par les membres qui y ont été ajoutés et par ceux qui disposent de la permission « Gérer les fils » (Manage Threads). Si vous ouvrez les tickets sous forme de fils privés dans le salon du panneau, vous n'êtes pas soumis aux limites de salons et les tickets fermés restent dans les archives. Préparation :

  • Dans le salon du panneau, pour @everyone, activez « Voir le salon » et « Envoyer des messages dans les fils » (Send Messages in Threads) ; désactivez « Envoyer des messages », « Créer des fils publics » (Create Public Threads) et « Créer des fils privés » (Create Private Threads). Dans les fils, la permission SendMessages n'a aucun effet.
  • Accordez « Gérer les fils » au rôle de support dans ce salon ; le rôle voit alors tous les fils privés et peut rouvrir un fil verrouillé.
  • Ajoutez au rôle du bot les permissions CreatePrivateThreads, SendMessagesInThreads et ManageThreads.

Ajoutez la fonction ci-dessous au fichier ticket.js et remplacez la dernière ligne par module.exports = { ouvrirTicket, ouvrirTicketFil, fermerTicket }; ; dans index.js, ajoutez le nom ouvrirTicketFil à la ligne require et faites pointer le bouton ouvrir-ticket vers cette fonction :

async function ouvrirTicketFil(interaction) {
  const { channel, user } = interaction; // le salon textuel qui contient le panneau
  await interaction.deferReply({ flags: MessageFlags.Ephemeral });

  const existant = channel.threads.cache.find((k) => !k.archived && trouverProprietaire(k) === user.id);
  if (existant) return interaction.editReply(`Vous avez déjà un ticket ouvert : ${existant}`);
  if (enOuverture.has(user.id)) return interaction.editReply('Votre ticket est en cours de préparation, veuillez patienter.');
  enOuverture.add(user.id);

  try {
    const fil = await channel.threads.create({
      name: `ticket-${user.username}-${user.id}`,
      type: ChannelType.PrivateThread,
      invitable: false,
      autoArchiveDuration: ThreadAutoArchiveDuration.OneWeek,
      reason: `Ticket de support : ${user.username}`,
    });
    await fil.members.add(user.id);
    await fil.send({ content: `${user}, votre ticket est ouvert. Décrivez votre problème en détail.`, components: [ligneFermeture()] });
    await interaction.editReply(`Votre ticket est ouvert : ${fil}`);
  } catch (erreur) {
    console.error(erreur);
    await interaction.editReply("Impossible d'ouvrir le ticket ; veuillez prévenir les responsables du serveur.");
  } finally {
    enOuverture.delete(user.id);
  }
}

L'identifiant d'utilisateur placé à la fin du nom du fil permet à la fonction trouverProprietaire de retrouver le propriétaire du ticket ; le code de fermeture de l'étape 5 verrouille et archive le fil au lieu de le supprimer. invitable: false empêche les membres qui ne sont pas modérateurs d'ajouter d'autres membres au fil. Toutes les opérations sur les fils sont décrites dans le guide discord.js sur les threads.

CaractéristiqueSalon de ticketFil privé
Qui le voitLes membres et les rôles autorisésLes membres ajoutés et ceux qui ont la permission « Gérer les fils »
Limite de nombre50 salons par catégorie, 500 par serveurNe compte pas dans la limite de salons ; le nombre de fils actifs a sa propre limite (la documentation n'en donne pas la valeur)
Permissions supplémentaires du botManageChannelsCreatePrivateThreads, SendMessagesInThreads, ManageThreads
FermetureLe salon est supprimé, sans retour possibleLe fil est verrouillé et archivé, les échanges restent en place
En cas d'inactivitéReste ouvertArchivé à la fin de la durée choisie (1 heure – 7 jours) ; s'il n'est pas verrouillé, un nouveau message le rouvre

Récapitulatif des permissions et des réglages

Emplacement du réglageValeur
Rôle du bot (tout le serveur)ViewChannel, SendMessages, ReadMessageHistory, AttachFiles, ManageChannels ; avec la méthode des fils, également CreatePrivateThreads, SendMessagesInThreads, ManageThreads
Salon de ticket@everyone : ViewChannel désactivé. Propriétaire du ticket, rôle de support et bot : ViewChannel, SendMessages, ReadMessageHistory, AttachFiles activés
Salon de logs@everyone : « Voir le salon » désactivé. Rôle de support et bot : « Voir le salon », « Envoyer des messages », « Joindre des fichiers » activés
Developer Portal → BotMessage Content Intent activé (pour le texte des messages dans la transcription)
CodeGatewayIntentBits.Guilds suffit
.envDISCORD_TOKEN, ROLE_SUPPORT_ID, CATEGORIE_TICKETS_ID, SALON_LOGS_TICKETS_ID

Erreurs fréquentes

  • Le ticket ne s'ouvre pas, la console affiche DiscordAPIError[50013]: Missing Permissions : il manque au rôle du bot ManageChannels ou l'une des permissions distribuées dans les remplacements (p. ex. AttachFiles) ; ajoutez la permission manquante au rôle du bot.
  • Le salon est créé mais le message d'accueil n'arrive pas, la console affiche DiscordAPIError[50001]: Missing Access : le bot ne voit pas le salon qu'il a créé ; la ligne du bot a peut-être été supprimée de la liste des remplacements. Si l'erreur survient pendant l'envoi de la transcription, c'est le salon de logs que le bot ne voit pas.
  • Les salons sont créés en dehors de la catégorie, ou pas du tout : un identifiant du fichier .env manque ou est erroné. Les valeurs ne sont lues qu'au démarrage ; après avoir modifié le fichier, redémarrez le bot.
  • Maximum number of guild channels reached (500) (30013) ou catégorie pleine : le serveur a atteint 500 salons, ou la catégorie 50 salons. Fermez les anciens tickets restés ouverts, utilisez une seconde catégorie ou passez à la méthode des fils de l'étape 7.
  • Les messages des utilisateurs sont vides dans la transcription : Message Content Intent est désactivé ; comme cette restriction ne s'applique ni aux messages du bot lui-même ni aux messages qui le mentionnent, seuls ceux-ci apparaissent remplis dans le fichier.
  • La console affiche 40060 Interaction has already been acknowledged : un second processus utilisant le même token (p. ex. une copie sur votre ordinateur) est en cours d'exécution ; les deux processus reçoivent le même clic, mais un seul peut répondre. Arrêtez l'un des deux. Pour le message « This interaction failed » et l'erreur 10062, consultez le guide des boutons.
  • Avec la méthode des fils, 160005 Thread is locked : un message a été envoyé dans un ticket verrouillé ; seule une personne disposant de « Gérer les fils » peut le déverrouiller.

Questions fréquentes

Les tickets ouverts sont-ils perturbés si le bot redémarre ?

Non. Comme les boutons sont traités dans l'événement interactionCreate à l'aide du customId, les anciens panneaux et les boutons de fermeture continuent de fonctionner ; le cache des salons se remplissant de nouveau au démarrage, le contrôle du second ticket reste lui aussi fonctionnel. Les deux verrous courts conservés pendant une opération sont réinitialisés ; si le redémarrage survient pendant l'attente de 5 secondes de la fermeture, le salon n'est pas supprimé : fermez de nouveau le ticket.

Comment conserver un numéro de ticket et un historique ?

Le sujet du salon et le cache ne connaissent que les tickets ouverts. Pour les informations permanentes comme un numéro d'ordre (p. ex. ticket-0001), l'heure d'ouverture et de fermeture ou le membre de l'équipe qui a fermé le ticket, utilisez une base de données ; l'installation est décrite dans le guide Bases de données pour bots Discord : SQLite, PostgreSQL, MySQL, MongoDB.

Vais-je atteindre la limite de débit (rate limit) en récupérant une transcription ?

Pas en utilisation normale. Discord applique à tous les bots une limite globale de 50 requêtes par seconde, ainsi que des limites distinctes par endpoint ; une transcription de 1 000 messages représente 10 requêtes. Par défaut, la couche REST de discord.js attend puis renvoie la requête lorsqu'elle atteint la limite. Le vrai risque vient des requêtes invalides : si les requêtes qui reçoivent une réponse 401, 403 ou 429 dépassent 10 000 en 10 minutes, l'adresse IP est temporairement bloquée ; ne relancez pas en boucle une opération qui renvoie une erreur de permission. Détails dans la documentation de Discord sur les limites de débit.

Guides associés

Les offres de serveurs pour garder votre bot allumé en permanence se trouvent sur la page VDS pour bot Discord.

Commentaires0

Pas encore de commentaire

Soyez le premier à partager votre avis.

Rejoignez la discussion

Veuillez vous connecter ou vous inscrire pour laisser un commentaire.

Ne manquez aucun article

Recevez nos derniers tutoriels, guides et actualités produit dans votre boîte de réception.

Votre abonnement à notre newsletter est confirmé.