diff --git a/Cargo.lock b/Cargo.lock
index e96ad1e..9ed83d6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1347,7 +1347,7 @@ dependencies = [
 
 [[package]]
 name = "revanced-discord-bot"
-version = "2.5.0"
+version = "2.5.1"
 dependencies = [
  "base64 0.21.2",
  "bson",
diff --git a/Cargo.toml b/Cargo.toml
index 53f3644..74a4914 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -5,7 +5,7 @@ homepage = "https://revanced.app"
 license = "GPL-3.0"
 name = "revanced-discord-bot"
 repository = "https://github.com/revanced/revanced-discord-bot"
-version = "2.5.0"
+version = "2.5.1"
 edition = "2021"
 
 [profile.release]
diff --git a/src/utils/moderation.rs b/src/utils/moderation.rs
index 4bff8f2..1d0a488 100644
--- a/src/utils/moderation.rs
+++ b/src/utils/moderation.rs
@@ -1,5 +1,5 @@
 use std::cmp;
-use std::sync::Arc;
+use std::sync::{Arc, RwLock};
 
 use mongodb::options::FindOptions;
 use poise::serenity_prelude::{ChannelId, GuildChannel, GuildId, Mentionable, User, UserId};
@@ -123,6 +123,8 @@ pub async fn respond_moderation<'a>(
 ) -> Result<(), Error> {
     let current_user = ctx.serenity_context().http.get_current_user().await?;
 
+    let send_ephemeral = RwLock::new(false);
+
     let create_embed = |f: &mut serenity::CreateEmbed| {
         let mut moderated_user: Option<&User> = None;
 
@@ -131,18 +133,21 @@ pub async fn respond_moderation<'a>(
                 moderated_user = Some(user);
 
                 let embed = match error {
-                    Some(err) => f
-                        .title(format!("Failed to mute {}", user.tag()))
-                        .field("Exception", err.to_string(), false)
-                        .field(
-                            "Action",
-                            format!(
-                                "{} was muted by {} but failed",
-                                user.mention(),
-                                author.mention()
-                            ),
-                            false,
-                        ),
+                    Some(err) => {
+                        *send_ephemeral.write().unwrap() = true;
+
+                        f.title(format!("Failed to mute {}", user.tag()))
+                            .field("Exception", err.to_string(), false)
+                            .field(
+                                "Action",
+                                format!(
+                                    "{} was muted by {} but failed",
+                                    user.mention(),
+                                    author.mention()
+                                ),
+                                false,
+                            )
+                    },
                     None => f.title(format!("Muted {}", user.tag())).field(
                         "Action",
                         format!("{} was muted by {}", user.mention(), author.mention()),
@@ -160,18 +165,21 @@ pub async fn respond_moderation<'a>(
             ModerationKind::Unmute(user, author, error) => {
                 moderated_user = Some(user);
                 match error {
-                    Some(err) => f
-                        .title(format!("Failed to unmute {}", user.tag()))
-                        .field("Exception", err.to_string(), false)
-                        .field(
-                            "Action",
-                            format!(
-                                "{} was unmuted by {} but failed",
-                                user.mention(),
-                                author.mention()
-                            ),
-                            false,
-                        ),
+                    Some(err) => {
+                        *send_ephemeral.write().unwrap() = true;
+
+                        f.title(format!("Failed to unmute {}", user.tag()))
+                            .field("Exception", err.to_string(), false)
+                            .field(
+                                "Action",
+                                format!(
+                                    "{} was unmuted by {} but failed",
+                                    user.mention(),
+                                    author.mention()
+                                ),
+                                false,
+                            )
+                    },
                     None => f.title(format!("Unmuted {}", user.tag())).field(
                         "Action",
                         format!("{} was unmuted by {}", user.mention(), author.mention()),
@@ -182,18 +190,21 @@ pub async fn respond_moderation<'a>(
             ModerationKind::Ban(user, author, reason, error) => {
                 moderated_user = Some(user);
                 let f = match error {
-                    Some(err) => f
-                        .title(format!("Failed to ban {}", user.tag()))
-                        .field("Exception", err.to_string(), false)
-                        .field(
-                            "Action",
-                            format!(
-                                "{} was banned by {} but failed",
-                                user.mention(),
-                                author.mention()
-                            ),
-                            false,
-                        ),
+                    Some(err) => {
+                        *send_ephemeral.write().unwrap() = true;
+
+                        f.title(format!("Failed to ban {}", user.tag()))
+                            .field("Exception", err.to_string(), false)
+                            .field(
+                                "Action",
+                                format!(
+                                    "{} was banned by {} but failed",
+                                    user.mention(),
+                                    author.mention()
+                                ),
+                                false,
+                            )
+                    },
                     None => f.title(format!("Banned {}", user.tag())).field(
                         "Action",
                         format!("{} was banned by {}", user.mention(), author.mention()),
@@ -209,18 +220,21 @@ pub async fn respond_moderation<'a>(
             ModerationKind::Unban(user, author, error) => {
                 moderated_user = Some(user);
                 match error {
-                    Some(err) => f
-                        .title(format!("Failed to unban {}", user.tag()))
-                        .field("Exception", err.to_string(), false)
-                        .field(
-                            "Action",
-                            format!(
-                                "{} was unbanned by {} but failed",
-                                user.mention(),
-                                author.mention()
-                            ),
-                            false,
-                        ),
+                    Some(err) => {
+                        *send_ephemeral.write().unwrap() = true;
+
+                        f.title(format!("Failed to unban {}", user.tag()))
+                            .field("Exception", err.to_string(), false)
+                            .field(
+                                "Action",
+                                format!(
+                                    "{} was unbanned by {} but failed",
+                                    user.mention(),
+                                    author.mention()
+                                ),
+                                false,
+                            )
+                    },
                     None => f.title(format!("Unbanned {}", user.tag())).field(
                         "Action",
                         format!("{} was unbanned by {}", user.mention(), author.mention()),
@@ -229,18 +243,21 @@ pub async fn respond_moderation<'a>(
                 }
             },
             ModerationKind::Lock(channel, author, error) => match error {
-                Some(err) => f
-                    .title(format!("Failed to lock {} ", channel.name()))
-                    .field("Exception", err.to_string(), false)
-                    .field(
-                        "Action",
-                        format!(
-                            "{} was locked by {} but failed",
-                            channel.mention(),
-                            author.mention()
-                        ),
-                        false,
-                    ),
+                Some(err) => {
+                    *send_ephemeral.write().unwrap() = true;
+
+                    f.title(format!("Failed to lock {} ", channel.name()))
+                        .field("Exception", err.to_string(), false)
+                        .field(
+                            "Action",
+                            format!(
+                                "{} was locked by {} but failed",
+                                channel.mention(),
+                                author.mention()
+                            ),
+                            false,
+                        )
+                },
                 None => f
                     .title(format!("Locked {}", channel.name()))
                     .description(
@@ -253,18 +270,21 @@ pub async fn respond_moderation<'a>(
                     ),
             },
             ModerationKind::Unlock(channel, author, error) => match error {
-                Some(err) => f
-                    .title(format!("Failed to unlock {}", channel.name()))
-                    .field("Exception", err.to_string(), false)
-                    .field(
-                        "Action",
-                        format!(
-                            "{} was unlocked by {} but failed",
-                            channel.mention(),
-                            author.mention()
-                        ),
-                        false,
-                    ),
+                Some(err) => {
+                    *send_ephemeral.write().unwrap() = true;
+
+                    f.title(format!("Failed to unlock {}", channel.name()))
+                        .field("Exception", err.to_string(), false)
+                        .field(
+                            "Action",
+                            format!(
+                                "{} was unlocked by {} but failed",
+                                channel.mention(),
+                                author.mention()
+                            ),
+                            false,
+                        )
+                },
                 None => f
                     .title(format!("Unlocked {}", channel.name()))
                     .description("Restored original permission overwrites.")
@@ -291,10 +311,12 @@ pub async fn respond_moderation<'a>(
 
     let reply = ctx
         .send(|reply| {
-            reply.embed(|embed| {
-                create_embed(embed);
-                embed
-            })
+            reply
+                .embed(|embed| {
+                    create_embed(embed);
+                    embed
+                })
+                .ephemeral(*send_ephemeral.read().unwrap())
         })
         .await?;