Discord Music Bot: Make Your Own in Python or JavaScript

discord.py[voice]>=2.7
python-dotenv

DISCORD_TOKEN=paste-your-token-here

import os
from pathlib import Path

import discord
from discord import app_commands
from dotenv import load_dotenv

load_dotenv()  # reads the token from the .env file

FOLDER = Path("music").resolve()  # your songs, uploaded in “Files”
FORMATS = {".mp3", ".ogg", ".opus", ".flac", ".wav", ".m4a"}

intents = discord.Intents.default()  # already includes voice states
client = discord.Client(intents=intents)
tree = app_commands.CommandTree(client)
queues: dict[int, list[Path]] = {}  # one queue per Discord server


def songs():
    return sorted(p for p in FOLDER.iterdir() if p.suffix.lower() in FORMATS)


def play_next(vc: discord.VoiceClient, server: int):
    """Plays the first one in the queue; it calls itself again when each song ends."""
    queue = queues.get(server)
    if not queue or not vc.is_connected():
        return
    path = queue.pop(0)
    audio = discord.PCMVolumeTransformer(discord.FFmpegPCMAudio(str(path)), volume=0.5)
    vc.play(audio, after=lambda error: play_next(vc, server))


async def autocomplete(interaction: discord.Interaction, current: str):
    return [
        app_commands.Choice(name=p.stem[:100], value=p.name)
        for p in songs()
        if current.lower() in p.stem.lower()
    ][:25]


@tree.command(name="play", description="Plays a song from the music folder (or adds it to the queue)")
@app_commands.describe(song="Start typing and pick one")
@app_commands.autocomplete(song=autocomplete)
@app_commands.guild_only()
async def play(interaction: discord.Interaction, song: str):
    path = (FOLDER / song).resolve()
    if path.parent != FOLDER or not path.is_file():  # only what's in music/
        await interaction.response.send_message("I can't find that song.", ephemeral=True)
        return
    voice = interaction.user.voice
    if voice is None or voice.channel is None:
        await interaction.response.send_message("Join a voice channel first.", ephemeral=True)
        return
    await interaction.response.defer()  # connecting to voice can take more than 3 s
    vc = interaction.guild.voice_client
    if vc is None:
        vc = await voice.channel.connect()
    elif vc.channel != voice.channel:
        await vc.move_to(voice.channel)
    queues.setdefault(interaction.guild.id, []).append(path)
    if vc.is_playing():
        await interaction.followup.send(f"➕ Queued: **{path.stem}**")
    else:
        play_next(vc, interaction.guild.id)
        await interaction.followup.send(f"▶️ Now playing: **{path.stem}**")


@tree.command(name="skip", description="Skips to the next song in the queue")
@app_commands.guild_only()
async def skip(interaction: discord.Interaction):
    vc = interaction.guild.voice_client
    if vc and vc.is_playing():
        vc.stop()  # stopping it makes play_next() play the next one
    await interaction.response.send_message("⏭️ Next")


@tree.command(name="stop", description="Stops the music, clears the queue and leaves the channel")
@app_commands.guild_only()
async def stop(interaction: discord.Interaction):
    queues.pop(interaction.guild.id, None)
    vc = interaction.guild.voice_client
    if vc:
        await vc.disconnect()
    await interaction.response.send_message("⏹️ Music stopped")


@tree.command(name="list", description="The songs in the music folder")
async def song_list(interaction: discord.Interaction):
    names = [p.stem for p in songs()] or ["(the music folder is empty)"]
    await interaction.response.send_message("\n".join(names)[:2000], ephemeral=True)


@client.event
async def on_ready():
    await tree.sync()  # publishes /play, /skip, /stop and /list
    print(f"Logged in as {client.user}")


client.run(os.environ["DISCORD_TOKEN"])

{
  "name": "my-music-bot",
  "version": "1.0.0",
  "main": "index.js",
  "dependencies": {
    "@discordjs/opus": "^0.10.0",
    "@discordjs/voice": "^0.19.2",
    "discord.js": "^14.27.0",
    "dotenv": "^16.4.0"
  }
}

DISCORD_TOKEN=paste-your-token-here

require("dotenv").config(); // reads the token from the .env file
const fs = require("node:fs");
const path = require("node:path");
const { Client, Events, GatewayIntentBits, MessageFlags, SlashCommandBuilder, InteractionContextType } = require("discord.js");
const { AudioPlayerStatus, createAudioPlayer, createAudioResource, getVoiceConnection, joinVoiceChannel } = require("@discordjs/voice");

const FOLDER = path.resolve("music"); // your songs, uploaded in “Files”
const FORMATS = [".mp3", ".ogg", ".opus", ".flac", ".wav", ".m4a"];

// Without GuildVoiceStates the bot doesn't know which voice channel you're in and can't join it
const client = new Client({ intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildVoiceStates] });
const players = new Map(); // one player and one queue per Discord server

const songs = () => fs.readdirSync(FOLDER).filter((f) => FORMATS.includes(path.extname(f).toLowerCase())).sort();

function playerFor(server) {
  if (!players.has(server)) {
    const p = { player: createAudioPlayer(), queue: [] };
    // When a song ends, the next one in the queue
    p.player.on(AudioPlayerStatus.Idle, () => playNext(p));
    p.player.on("error", (e) => console.error("Playback error:", e.message));
    players.set(server, p);
  }
  return players.get(server);
}

function playNext(p) {
  const file = p.queue.shift();
  if (!file) return;
  const audio = createAudioResource(file, { inlineVolume: true });
  audio.volume.setVolume(0.5);
  p.player.play(audio);
}

const commands = [
  new SlashCommandBuilder()
    .setName("play")
    .setDescription("Plays a song from the music folder (or adds it to the queue)")
    .setContexts(InteractionContextType.Guild)
    .addStringOption((o) => o.setName("song").setDescription("Start typing and pick one").setRequired(true).setAutocomplete(true)),
  new SlashCommandBuilder().setName("skip").setDescription("Skips to the next song in the queue").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("stop").setDescription("Stops the music, clears the queue and leaves the channel").setContexts(InteractionContextType.Guild),
  new SlashCommandBuilder().setName("list").setDescription("The songs in the music folder"),
];

client.once(Events.ClientReady, async (c) => {
  await c.application.commands.set(commands.map((x) => x.toJSON())); // publishes /play, /skip, /stop and /list
  console.log(`Logged in as ${c.user.tag}`);
});

client.on(Events.InteractionCreate, async (i) => {
  if (i.isAutocomplete()) {
    const typed = i.options.getFocused().toLowerCase();
    const options = songs()
      .filter((f) => f.toLowerCase().includes(typed))
      .slice(0, 25)
      .map((f) => ({ name: path.parse(f).name.slice(0, 100), value: f }));
    return i.respond(options);
  }
  if (!i.isChatInputCommand()) return;

  if (i.commandName === "play") {
    const file = path.resolve(FOLDER, i.options.getString("song"));
    if (path.dirname(file) !== FOLDER || !fs.existsSync(file)) {
      return i.reply({ content: "I can't find that song.", flags: MessageFlags.Ephemeral }); // only what's in music/
    }
    const channel = i.member.voice.channel;
    if (!channel) return i.reply({ content: "Join a voice channel first.", flags: MessageFlags.Ephemeral });
    // Joins your channel (or moves to it if it was already in another one)
    const connection = joinVoiceChannel({ channelId: channel.id, guildId: i.guildId, adapterCreator: i.guild.voiceAdapterCreator });
    const p = playerFor(i.guildId);
    connection.subscribe(p.player);
    p.queue.push(file);
    const name = path.parse(file).name;
    if (p.player.state.status === AudioPlayerStatus.Idle) {
      playNext(p);
      return i.reply(`▶️ Now playing: **${name}**`);
    }
    return i.reply(`➕ Queued: **${name}**`);
  }

  if (i.commandName === "skip") {
    players.get(i.guildId)?.player.stop(); // stopping it goes to Idle and the next one plays
    return i.reply("⏭️ Next");
  }

  if (i.commandName === "stop") {
    const p = players.get(i.guildId);
    if (p) {
      p.queue = [];
      p.player.stop();
    }
    getVoiceConnection(i.guildId)?.destroy();
    return i.reply("⏹️ Music stopped");
  }

  if (i.commandName === "list") {
    const names = songs().map((f) => path.parse(f).name);
    return i.reply({ content: (names.join("\n") || "(the music folder is empty)").slice(0, 2000), flags: MessageFlags.Ephemeral });
  }
});

client.login(process.env.DISCORD_TOKEN);