npm install --save discord-backup

/**
 * @param {Guild} [Guild] - The discord server you want to backup
 * @param {object} [options] - The backup options
 */

const backup = require("discord-backup");
backup.create(Guild, options).then((backupData) => {
    console.log(backupData.id); // NSJH2
});

/**
 * @param {string} [backupID] - The ID of the backup that you want to load
 * @param {Guild} [Guild] - The discord server on which you want to load the backup
 */

const backup = require("discord-backup");
backup.load(backupID, Guild).then(() => {
    backup.remove(backupID); // When the backup is loaded, it's recommended to delete it
});

/**
 * @param {string} [backupID] - The ID of the backup to fetch
 */

const backup = require("discord-backup");
backup.fetch(backupID).then((backupInfos) => {
    console.log(backupInfos);
    /*
    {
        id: "BC5qo",
        size: 0.05
        data: {BackupData}
    }
    */
});

/**
 * @param {string} [backupID] - The ID of the backup to remove
 */

const backup = require("discord-backup");
backup.remove(backupID);

const backup = require("discord-backup");
backup.list().then((backups) => {
    console.log(backups); // Expected Output [ "BC5qo", "Jdo91", ...]
});

const backup = require("discord-backup");
backup.setStorageFolder(__dirname+"/backups/");
await backup.create(guild); // Backup created in ./backups/
backup.setStorageFolder(__dirname+"/my-backups/");
await backup.create(guild); // Backup created in ./my-backups/

const backup = require("discord-backup");
backup.create(guild, {
    maxMessagesPerChannel: 10,
    jsonSave: false,
    jsonBeautify: true,
    includeName: true,
    doNotBackup: [ "roles",  "channels", "emojis", "bans" ],
    saveImages: "base64"
});

const backup = require("discord-backup");
backup.load(backupData, guild, {
    clearGuildBeforeRestore: true,
    mode: 'slow', // 'fast', 'auto', 750,
});

// Load modules
const {
    Client,
    GatewayIntentBits,
    MessageEmbed,
    PermissionsBitField
  } = require("discord.js"),
  backup = require("discord-backup"),
  client = new Client({
    intents: [
      GatewayIntentBits.Guilds,
      GatewayIntentBits.GuildMessages,
      GatewayIntentBits.MessageContent
    ]
  }),
  config = require("./config.json"),
  settings = {
    prefix: config.PREFIX,
    token: config.TOKEN
  };
backup.setStorageFolder(__dirname + "/backups/");

client.on("ready", () => {
  console.log(
    "I'm ready! Invite me to your server by clicking this link:",
    `https://discord.com/api/oauth2/authorize?client_id=${client.application.id}&permissions=8&scope=bot`
  );
});

client.on("messageCreate", async message => {
  // This reads the first part of your message behind your prefix to see which command you want to use.
  let command = message.content
    .toLowerCase()
    .slice(settings.prefix.length)
    .split(" ")[0];

  // These are the arguments behind the commands.
  let args = message.content.split(" ").slice(1);

  // If the message does not start with your prefix return.
  // If the user that types a message is a bot account return.
  // If the command comes from DM return.
  if (
    !message.content.startsWith(settings.prefix) ||
    message.author.bot ||
    !message.guild
  ) {
    return;
  }

  if (command === "create") {
    // Check member permissions
    if (
      !message.member.permissions.has(PermissionsBitField.Flags.Administrator)
    ) {
      return message.channel.send(
        ":x: | You must be an administrator of this server to request a backup!"
      );
    }
    // Create the backup
    backup
      .create(message.guild, {
        jsonBeautify: true,
        includeName: config.create.includeName
      })
      .then(backupData => {
        // And send informations to the backup owner
        message.author.send(
          "The backup has been created! To load it, type this command on the server of your choice: `" +
            settings.prefix +
            "load " +
            backupData.id +
            "`!"
        );
        message.channel.send(
          ":white_check_mark: Backup successfully created. The backup ID was sent in dm!"
        );
      });
  }

  if (command === "load") {
    // Check member permissions
    if (
      !message.member.permissions.has(PermissionsBitField.Flags.Administrator)
    ) {
      return message.channel.send(
        ":x: | You must be an administrator of this server to load a backup!"
      );
    }
    let backupID = args[0];
    if (!backupID) {
      return message.channel.send(":x: | You must specify a valid backup ID!");
    }
    // Fetching the backup to know if it exists
    backup
      .fetch(backupID)
      .then(async () => {
        // Do not clear before restore
        const clearGuildBeforeRestore = false;
        // If the backup exists, request for confirmation
        if (clearGuildBeforeRestore) {
          message.channel.send(
            ":warning: | When the backup is loaded, all the channels, roles, etc. will be replaced! Type `-confirm` to confirm!"
          );
          await message.channel
            .awaitMessages(
              m =>
                m.author.id === message.author.id && m.content === "-confirm",
              {
                max: 1,
                time: 20000,
                errors: ["time"]
              }
            )
            .catch(err => {
              // if the author of the commands does not confirm the backup loading
              return message.channel.send(
                ":x: | Time's up! Cancelled backup loading!"
              );
            });
          // When the author of the command has confirmed that he wants to load the backup on his server
        }
        message.author.send(":white_check_mark: | Start loading the backup!");
        // Load the backup
        backup
          .load(backupID, message.guild, {
            clearGuildBeforeRestore,
            maxMessagesPerChannel: config.load.maxMessagesPerChannel,
            mode: 2000 // 2 seconds per event
          })
          .then(() => {
            // When the backup is loaded, delete them from the server
            if (config.load.removeLoadedBackup) {
              backup.remove(backupID);
            }
          })
          .catch(err => {
            // If an error occurred
            return message.author.send(
              ":x: | Sorry, an error occurred... Please check that I have administrator permissions!"
            );
          });
      })
      .catch(err => {
        console.log(err);
        // if the backup wasn't found
        return message.channel.send(
          ":x: | No backup found for `" + backupID + "`!"
        );
      });
  }

  if (command === "infos") {
    let backupID = args[0];
    if (!backupID) {
      return message.channel.send(":x: | You must specify a valid backup ID!");
    }
    // Fetch the backup
    backup
      .fetch(backupID)
      .then(backupInfos => {
        const date = new Date(backupInfos.data.createdTimestamp);
        const yyyy = date.getFullYear().toString(),
          mm = (date.getMonth() + 1).toString(),
          dd = date.getDate().toString();
        const formatedDate = `${yyyy}/${mm[1] ? mm : "0" + mm[0]}/${
          dd[1] ? dd : "0" + dd[0]
        }`;
        let embed = new MessageEmbed()
          .setAuthor("Backup Informations")
          // Display the backup ID
          .addField("Backup ID", backupInfos.id, false)
          // Displays the server from which this backup comes
          .addField("Server ID", backupInfos.data.guildID, false)
          // Display the size (in mb) of the backup
          .addField("Size", `${backupInfos.size} kb`, false)
          // Display when the backup was created
          .addField("Created at", formatedDate, false)
          .setColor("#FF0000");
        message.channel.send(embed);
      })
      .catch(err => {
        // if the backup wasn't found
        return message.channel.send(
          ":x: | No backup found for `" + backupID + "`!"
        );
      });
  }
});

//Your secret token to log the bot in. (never share this to anyone!)
client.login(settings.token);