diff --git a/Cargo.toml b/Cargo.toml
index 1506a08..d4c3339 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,6 @@ edition = "2021"
 [dependencies]
 serde = { version = "1.0.147", features = ["derive"] }
 serde_json = "1.0.87"
-thiserror = "1.0.37"
 time = { version = "0.3.15", features = ["serde"] }
 tokio = { version = "1.21.2", features = ["time", "sync", "macros", "rt"] }
 
diff --git a/src/api/types.rs b/src/api/types.rs
index b0bdb83..c24b4c9 100644
--- a/src/api/types.rs
+++ b/src/api/types.rs
@@ -6,9 +6,9 @@
 // so I'm turning it off for the entire module.
 #![allow(clippy::use_self)]
 
-use std::fmt;
 use std::num::ParseIntError;
 use std::str::FromStr;
+use std::{error, fmt};
 
 use serde::{de, ser, Deserialize, Serialize};
 use serde_json::Value;
@@ -324,12 +324,36 @@ impl fmt::Display for Snowflake {
     }
 }
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 pub enum ParseSnowflakeError {
-    #[error("invalid length: expected 13 bytes, got {0}")]
     InvalidLength(usize),
-    #[error("{0}")]
-    ParseIntError(#[from] ParseIntError),
+    ParseIntError(ParseIntError),
+}
+
+impl fmt::Display for ParseSnowflakeError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidLength(l) => {
+                write!(f, "invalid length: expected 13 bytes, got {l}")
+            }
+            Self::ParseIntError(from) => write!(f, "{from}"),
+        }
+    }
+}
+
+impl error::Error for ParseSnowflakeError {
+    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
+        match self {
+            Self::InvalidLength(_) => None,
+            Self::ParseIntError(from) => Some(from),
+        }
+    }
+}
+
+impl From<ParseIntError> for ParseSnowflakeError {
+    fn from(err: ParseIntError) -> Self {
+        Self::ParseIntError(err)
+    }
 }
 
 impl FromStr for Snowflake {
diff --git a/src/conn.rs b/src/conn.rs
index b2b4a12..09a993d 100644
--- a/src/conn.rs
+++ b/src/conn.rs
@@ -4,9 +4,9 @@
 
 use std::collections::HashMap;
 use std::convert::Infallible;
-use std::error;
 use std::future::Future;
 use std::time::Duration;
+use std::{error, fmt};
 
 use futures::channel::oneshot;
 use futures::stream::{SplitSink, SplitStream};
@@ -25,18 +25,27 @@ use crate::replies::{self, PendingReply, Replies};
 
 pub type WsStream = WebSocketStream<MaybeTlsStream<TcpStream>>;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 pub enum Error {
-    #[error("connection closed")]
     ConnectionClosed,
-    #[error("packet timed out")]
     TimedOut,
-    #[error("incorrect reply type")]
     IncorrectReplyType,
-    #[error("{0}")]
     Euph(String),
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::ConnectionClosed => write!(f, "connection closed"),
+            Self::TimedOut => write!(f, "packet timed out"),
+            Self::IncorrectReplyType => write!(f, "incorrect reply type"),
+            Self::Euph(error_msg) => write!(f, "{error_msg}"),
+        }
+    }
+}
+
+impl error::Error for Error {}
+
 type InternalResult<T> = Result<T, Box<dyn error::Error>>;
 
 #[derive(Debug)]
diff --git a/src/replies.rs b/src/replies.rs
index 07f4a60..75290c1 100644
--- a/src/replies.rs
+++ b/src/replies.rs
@@ -1,19 +1,29 @@
 use std::collections::HashMap;
+use std::fmt;
 use std::hash::Hash;
-use std::result;
 use std::time::Duration;
+use std::{error, result};
 
 use tokio::sync::oneshot::{self, Receiver, Sender};
 use tokio::time;
 
-#[derive(Debug, thiserror::Error)]
+#[derive(Debug)]
 pub enum Error {
-    #[error("timed out")]
     TimedOut,
-    #[error("canceled")]
     Canceled,
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::TimedOut => write!(f, "timed out"),
+            Self::Canceled => write!(f, "canceled"),
+        }
+    }
+}
+
+impl error::Error for Error {}
+
 pub type Result<T> = result::Result<T, Error>;
 
 #[derive(Debug)]