← Back to communication tools

Discord

CommunicationVoice ChatBot DevelopmentAPISlash CommandsGaming Community

Communication Tool

Discord

Overview

Discord is a voice and text chat platform that evolved from gaming and community focus. It features excellent voice and video capabilities, rich community management features, and bot functionality. With 196 million monthly active users, it's expanding adoption beyond gaming in developer communities, educational institutions, and open-source projects.

Details

Discord is a voice and text chat platform launched in 2015. Initially designed for gamers, it now serves 196 million monthly active users with rapidly expanding adoption beyond gaming. Usage is particularly increasing in developer communities, educational institutions, and open-source projects.

Discord's key strengths are its low-latency, high-quality voice chat functionality and developer-friendly API design. Using the Discord API and discord.js library, rich bot functionality can be easily built. In 2024, significant improvements were made including major enhancements to Slash Commands, the official release of discord.js v14, and Premium Apps support, greatly improving the developer experience.

Slash Commands, unlike traditional text-based commands, provide a first-class operation method integrated into the Discord client, offering advanced features like typed input validation, dynamic choices, ephemeral messages, and popup forms. It also supports modern development practices like serverless bot execution, webhook external integration, and rich embed displays.

Pros and Cons

Pros

  • Excellent Voice Quality: Low-latency, high-quality voice chat functionality
  • Slash Commands: Rich command interface integrated with Discord
  • Rich Bot API: Comprehensive libraries like discord.js and discord.py
  • Community Management: Role, permission, and moderation features
  • Free Usage: Basic features completely free to use
  • Developer-Friendly: Intuitive API design and comprehensive documentation
  • Active Community: Strong developer community and support system
  • Serverless Support: Lightweight bot execution on platforms like Cloudflare Workers

Cons

  • Gaming Image: Perception issues for business use
  • Learning Curve: Knowledge required for advanced bot development
  • API Limitations: Rate limits and daily limits
  • Privacy Concerns: Usage restrictions in some companies/organizations
  • UI Complexity: Too feature-rich, complex for beginners
  • Search Functionality: Limited message search features (free version)

Key Links

Code Examples

Hello World Bot (discord.js v14)

const { Client, Events, GatewayIntentBits } = require('discord.js');

// Create bot client
const client = new Client({ 
  intents: [
    GatewayIntentBits.Guilds, 
    GatewayIntentBits.GuildMessages, 
    GatewayIntentBits.MessageContent
  ] 
});

// Bot startup handler
client.once(Events.ClientReady, readyClient => {
  console.log(`Ready! Logged in as ${readyClient.user.tag}`);
});

// Message received handler
client.on(Events.MessageCreate, message => {
  if (message.author.bot) return;
  
  if (message.content === 'ping') {
    message.reply('pong!');
  }
});

// Bot login
client.login(process.env.DISCORD_TOKEN);

Slash Command Implementation

const { SlashCommandBuilder, REST, Routes } = require('discord.js');

// Command definitions
const commands = [
  new SlashCommandBuilder()
    .setName('ping')
    .setDescription('Replies with Pong!'),
    
  new SlashCommandBuilder()
    .setName('user')
    .setDescription('Provides information about the user.')
    .addUserOption(option =>
      option
        .setName('target')
        .setDescription('The user to get info about')
        .setRequired(false)),
        
  new SlashCommandBuilder()
    .setName('echo')
    .setDescription('Replies with your input!')
    .addStringOption(option =>
      option
        .setName('input')
        .setDescription('The input to echo back')
        .setRequired(true))
    .addBooleanOption(option =>
      option
        .setName('ephemeral')
        .setDescription('Whether the reply should be ephemeral'))
];

// Command registration
const rest = new REST().setToken(process.env.DISCORD_TOKEN);

(async () => {
  try {
    console.log('Started refreshing application (/) commands.');
    
    await rest.put(
      Routes.applicationGuildCommands(process.env.CLIENT_ID, process.env.GUILD_ID),
      { body: commands }
    );
    
    console.log('Successfully reloaded application (/) commands.');
  } catch (error) {
    console.error(error);
  }
})();

Slash Command Handler

const { Events, EmbedBuilder } = require('discord.js');

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

  const { commandName } = interaction;

  switch (commandName) {
    case 'ping':
      await interaction.reply('Pong!');
      break;
      
    case 'user':
      const user = interaction.options.getUser('target') || interaction.user;
      const member = interaction.guild.members.cache.get(user.id);
      
      const userEmbed = new EmbedBuilder()
        .setTitle(`User Info: ${user.username}`)
        .setThumbnail(user.displayAvatarURL())
        .addFields(
          { name: 'Username', value: user.username, inline: true },
          { name: 'User ID', value: user.id, inline: true },
          { name: 'Account Created', value: user.createdAt.toDateString(), inline: true }
        )
        .setColor('#0099ff');
        
      if (member) {
        userEmbed.addFields(
          { name: 'Joined Server', value: member.joinedAt.toDateString(), inline: true }
        );
      }
      
      await interaction.reply({ embeds: [userEmbed] });
      break;
      
    case 'echo':
      const input = interaction.options.getString('input');
      const isEphemeral = interaction.options.getBoolean('ephemeral') || false;
      
      await interaction.reply({ 
        content: `Echo: ${input}`,
        ephemeral: isEphemeral
      });
      break;
      
    default:
      await interaction.reply({ 
        content: 'Unknown command!', 
        ephemeral: true 
      });
  }
});

Advanced Slash Command (with Choices)

const { SlashCommandBuilder } = require('discord.js');

const data = new SlashCommandBuilder()
  .setName('weather')
  .setDescription('Get weather information!')
  .addStringOption(option =>
    option
      .setName('city')
      .setDescription('Select a city')
      .setRequired(true)
      .addChoices(
        { name: 'Tokyo', value: 'tokyo' },
        { name: 'New York', value: 'newyork' },
        { name: 'London', value: 'london' },
        { name: 'Paris', value: 'paris' }
      ))
  .addStringOption(option =>
    option
      .setName('unit')
      .setDescription('Temperature unit')
      .addChoices(
        { name: 'Celsius', value: 'celsius' },
        { name: 'Fahrenheit', value: 'fahrenheit' }
      ));

// Command execution
client.on(Events.InteractionCreate, async interaction => {
  if (!interaction.isChatInputCommand()) return;
  
  if (interaction.commandName === 'weather') {
    const city = interaction.options.getString('city');
    const unit = interaction.options.getString('unit') || 'celsius';
    
    // External API call example
    try {
      const weatherData = await getWeatherData(city, unit);
      
      const weatherEmbed = new EmbedBuilder()
        .setTitle(`Weather in ${weatherData.cityName}`)
        .setDescription(weatherData.description)
        .addFields(
          { name: 'Temperature', value: `${weatherData.temp}°${unit === 'celsius' ? 'C' : 'F'}`, inline: true },
          { name: 'Humidity', value: `${weatherData.humidity}%`, inline: true },
          { name: 'Wind Speed', value: `${weatherData.windSpeed} km/h`, inline: true }
        )
        .setColor('#87CEEB')
        .setTimestamp();
        
      await interaction.reply({ embeds: [weatherEmbed] });
    } catch (error) {
      await interaction.reply({ 
        content: 'Failed to fetch weather data!', 
        ephemeral: true 
      });
    }
  }
});

Autocomplete Feature

const { SlashCommandBuilder } = require('discord.js');

// Autocomplete-enabled command
const autocompleteCommand = new SlashCommandBuilder()
  .setName('search')
  .setDescription('Search for something!')
  .addStringOption(option =>
    option
      .setName('query')
      .setDescription('Search query')
      .setAutocomplete(true)
      .setRequired(true));

// Autocomplete response
client.on(Events.InteractionCreate, async interaction => {
  if (interaction.isAutocomplete()) {
    const command = interaction.commandName;
    
    if (command === 'search') {
      const focusedValue = interaction.options.getFocused();
      
      // Generate search suggestions
      const choices = [
        'JavaScript Tutorial',
        'Discord Bot Guide',
        'API Documentation',
        'Programming Tips',
        'Web Development'
      ];
      
      const filtered = choices.filter(choice => 
        choice.toLowerCase().includes(focusedValue.toLowerCase())
      ).slice(0, 25); // Discord limit: max 25
      
      await interaction.respond(
        filtered.map(choice => ({ name: choice, value: choice }))
      );
    }
  }
});

Modal (Popup Form)

const { 
  SlashCommandBuilder, 
  ModalBuilder, 
  TextInputBuilder, 
  TextInputStyle, 
  ActionRowBuilder 
} = require('discord.js');

// Modal display command
client.on(Events.InteractionCreate, async interaction => {
  if (!interaction.isChatInputCommand()) return;
  
  if (interaction.commandName === 'feedback') {
    const modal = new ModalBuilder()
      .setCustomId('feedbackModal')
      .setTitle('Feedback Form');
      
    const titleInput = new TextInputBuilder()
      .setCustomId('feedbackTitle')
      .setLabel('Title')
      .setStyle(TextInputStyle.Short)
      .setMaxLength(100)
      .setRequired(true);
      
    const bodyInput = new TextInputBuilder()
      .setCustomId('feedbackBody')
      .setLabel('Feedback')
      .setStyle(TextInputStyle.Paragraph)
      .setMaxLength(1000)
      .setRequired(true);
      
    const firstActionRow = new ActionRowBuilder().addComponents(titleInput);
    const secondActionRow = new ActionRowBuilder().addComponents(bodyInput);
    
    modal.addComponents(firstActionRow, secondActionRow);
    
    await interaction.showModal(modal);
  }
});

// Modal submission handler
client.on(Events.InteractionCreate, async interaction => {
  if (!interaction.isModalSubmit()) return;
  
  if (interaction.customId === 'feedbackModal') {
    const title = interaction.fields.getTextInputValue('feedbackTitle');
    const body = interaction.fields.getTextInputValue('feedbackBody');
    
    const feedbackEmbed = new EmbedBuilder()
      .setTitle('New Feedback Received')
      .addFields(
        { name: 'Title', value: title },
        { name: 'Feedback', value: body },
        { name: 'User', value: interaction.user.username }
      )
      .setColor('#00ff00')
      .setTimestamp();
      
    // Send to feedback channel
    const feedbackChannel = interaction.guild.channels.cache.get('FEEDBACK_CHANNEL_ID');
    if (feedbackChannel) {
      await feedbackChannel.send({ embeds: [feedbackEmbed] });
    }
    
    await interaction.reply({ 
      content: 'Thank you for your feedback!', 
      ephemeral: true 
    });
  }
});

Buttons and Select Menus

const { 
  ButtonBuilder, 
  ButtonStyle, 
  StringSelectMenuBuilder, 
  StringSelectMenuOptionBuilder,
  ActionRowBuilder 
} = require('discord.js');

// Message with buttons
client.on(Events.InteractionCreate, async interaction => {
  if (!interaction.isChatInputCommand()) return;
  
  if (interaction.commandName === 'menu') {
    const confirm = new ButtonBuilder()
      .setCustomId('confirm')
      .setLabel('Confirm')
      .setStyle(ButtonStyle.Success);
      
    const cancel = new ButtonBuilder()
      .setCustomId('cancel')
      .setLabel('Cancel')
      .setStyle(ButtonStyle.Danger);
      
    const info = new ButtonBuilder()
      .setCustomId('info')
      .setLabel('More Info')
      .setStyle(ButtonStyle.Secondary);
      
    const row = new ActionRowBuilder()
      .addComponents(confirm, cancel, info);
      
    await interaction.reply({
      content: 'Choose an action:',
      components: [row]
    });
  }
});

// Button click handler
client.on(Events.InteractionCreate, async interaction => {
  if (!interaction.isButton()) return;
  
  switch (interaction.customId) {
    case 'confirm':
      await interaction.update({ 
        content: '✅ Confirmed!', 
        components: [] 
      });
      break;
      
    case 'cancel':
      await interaction.update({ 
        content: '❌ Cancelled!', 
        components: [] 
      });
      break;
      
    case 'info':
      const select = new StringSelectMenuBuilder()
        .setCustomId('infoSelect')
        .setPlaceholder('Select information type')
        .addOptions(
          new StringSelectMenuOptionBuilder()
            .setLabel('General Info')
            .setDescription('Basic information')
            .setValue('general'),
          new StringSelectMenuOptionBuilder()
            .setLabel('Technical Details')
            .setDescription('Technical specifications')
            .setValue('technical'),
          new StringSelectMenuOptionBuilder()
            .setLabel('Help & Support')
            .setDescription('Get help and support')
            .setValue('support')
        );
        
      const selectRow = new ActionRowBuilder()
        .addComponents(select);
        
      await interaction.update({
        content: 'Select information type:',
        components: [selectRow]
      });
      break;
  }
});

Webhook Integration

const { WebhookClient, EmbedBuilder } = require('discord.js');

// Webhook setup
const webhook = new WebhookClient({ 
  url: 'WEBHOOK_URL_HERE' 
});

// GitHub webhook integration example
app.post('/github-webhook', async (req, res) => {
  const payload = req.body;
  
  if (payload.action === 'opened' && payload.pull_request) {
    const pr = payload.pull_request;
    
    const embed = new EmbedBuilder()
      .setTitle('New Pull Request')
      .setURL(pr.html_url)
      .setDescription(pr.title)
      .addFields(
        { name: 'Author', value: pr.user.login, inline: true },
        { name: 'Repository', value: payload.repository.full_name, inline: true },
        { name: 'Branch', value: `${pr.head.ref} → ${pr.base.ref}`, inline: true }
      )
      .setColor('#28a745')
      .setTimestamp();
      
    await webhook.send({
      content: '📝 New Pull Request opened!',
      embeds: [embed]
    });
  }
  
  res.status(200).send('OK');
});

// CI/CD notification example
async function sendBuildNotification(status, buildUrl, commit) {
  const color = status === 'success' ? '#28a745' : '#dc3545';
  const emoji = status === 'success' ? '✅' : '❌';
  
  const embed = new EmbedBuilder()
    .setTitle(`${emoji} Build ${status.toUpperCase()}`)
    .setURL(buildUrl)
    .setDescription(`Commit: ${commit.message}`)
    .addFields(
      { name: 'Author', value: commit.author, inline: true },
      { name: 'Branch', value: commit.branch, inline: true },
      { name: 'Duration', value: commit.duration, inline: true }
    )
    .setColor(color)
    .setTimestamp();
    
  await webhook.send({ embeds: [embed] });
}

Environment Variables Configuration

# .env file
DISCORD_TOKEN=your-bot-token
CLIENT_ID=your-client-id
GUILD_ID=your-guild-id

# Optional settings
WEBHOOK_URL=your-webhook-url
DATABASE_URL=your-database-url
REDIS_URL=your-redis-url

# API Keys (for external integrations)
WEATHER_API_KEY=your-weather-api-key
GITHUB_TOKEN=your-github-token

package.json Example

{
  "name": "discord-bot",
  "version": "1.0.0",
  "description": "Advanced Discord bot with slash commands",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js",
    "deploy-commands": "node deploy-commands.js"
  },
  "dependencies": {
    "discord.js": "^14.20.0",
    "dotenv": "^16.0.3"
  },
  "devDependencies": {
    "nodemon": "^3.0.0"
  },
  "engines": {
    "node": ">=16.9.0"
  }
}