diff --git a/guide/src/conversions/traits.md b/guide/src/conversions/traits.md
index 98bd2864809..be9d3f7e6fe 100644
--- a/guide/src/conversions/traits.md
+++ b/guide/src/conversions/traits.md
@@ -464,7 +464,7 @@ enum RustyEnum {
 ```
 
 If the input is neither a string nor an integer, the error message will be:
-`"'<INPUT_TYPE>' cannot be converted to 'str | int'"`.
+`"'<INPUT_TYPE>' cannot be cast as 'str | int'"`.
 
 #### `#[derive(FromPyObject)]` Container Attributes
 - `pyo3(transparent)`
diff --git a/guide/src/migration.md b/guide/src/migration.md
index c2c67039c47..099c06bbe29 100644
--- a/guide/src/migration.md
+++ b/guide/src/migration.md
@@ -133,6 +133,16 @@ This is very similar to `serde`s [`Deserialize`] and [`DeserializeOwned`] traits
 [`DeserializeOwned`]: https://docs.rs/serde/latest/serde/de/trait.DeserializeOwned.html
 </details>
 
+## `.downcast()` and `DowncastError` replaced with `.cast()` and `CastError`
+
+The `.downcast()` family of functions were only available on `Bound<PyAny>`. In corner cases (particularly related to `.downcast_into()`) this would require use of `.as_any().downcast()` or `.into_any().downcast_into()` chains. Additionally, `DowncastError` produced Python exception messages which are not very Pythonic due to use of Rust type names in the error messages.
+
+The `.cast()` family of functions are available on all `Bound` and `Borrowed` smart pointers, whatever the type, and have error messages derived from the actual type at runtime. This produces a nicer experience for both PyO3 module authors and consumers.
+
+To migrate, replace `.downcast()` with `.cast()` and `DowncastError` with `CastError` (and similar with `.downcast_into()` / `DowncastIntoError` etc).
+
+`CastError` requires a Python `type` object (or other "classinfo" object compatible with `isinstance()`) as the second object, so in the rare case where `DowncastError` was manually constructed, small adjustments to code may apply.
+
 ## `PyTypeCheck` is now an `unsafe trait`
 
 Because `PyTypeCheck` is the trait used to guard the `.cast()` functions to treat Python objects as specific concrete types, the trait is `unsafe` to implement.
diff --git a/newsfragments/5468.added.md b/newsfragments/5468.added.md
new file mode 100644
index 00000000000..73bb6cba80f
--- /dev/null
+++ b/newsfragments/5468.added.md
@@ -0,0 +1 @@
+Add `CastError` and `CastIntoError`.
diff --git a/newsfragments/5468.changed.md b/newsfragments/5468.changed.md
new file mode 100644
index 00000000000..5f7cca73682
--- /dev/null
+++ b/newsfragments/5468.changed.md
@@ -0,0 +1 @@
+Replace `DowncastError` and `DowncastIntoError` with `CastError` and `CastIntoError`.
diff --git a/pyo3-macros-backend/src/method.rs b/pyo3-macros-backend/src/method.rs
index 400538ce14d..8d6f7868524 100644
--- a/pyo3-macros-backend/src/method.rs
+++ b/pyo3-macros-backend/src/method.rs
@@ -316,7 +316,7 @@ impl FnType {
                     #[allow(clippy::useless_conversion)]
                     ::std::convert::Into::into(
                         #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(#py, &*(&#slf as *const _ as *const *mut _))
-                            .downcast_unchecked::<#pyo3_path::types::PyType>()
+                            .cast_unchecked::<#pyo3_path::types::PyType>()
                     )
                 };
                 Some(quote! { unsafe { #ret }, })
@@ -329,7 +329,7 @@ impl FnType {
                     #[allow(clippy::useless_conversion)]
                     ::std::convert::Into::into(
                         #pyo3_path::impl_::pymethods::BoundRef::ref_from_ptr(#py, &*(&#slf as *const _ as *const *mut _))
-                            .downcast_unchecked::<#pyo3_path::types::PyModule>()
+                            .cast_unchecked::<#pyo3_path::types::PyModule>()
                     )
                 };
                 Some(quote! { unsafe { #ret }, })
@@ -404,7 +404,7 @@ impl SelfType {
                 let pyo3_path = pyo3_path.to_tokens_spanned(*span);
                 error_mode.handle_error(
                     quote_spanned! { *span =>
-                        #bound_ref.downcast::<#cls>()
+                        #bound_ref.cast::<#cls>()
                             .map_err(::std::convert::Into::<#pyo3_path::PyErr>::into)
                             .and_then(
                                 #[allow(unknown_lints, clippy::unnecessary_fallible_conversions)]  // In case slf is Py<Self> (unknown_lints can be removed when MSRV is 1.75+)
diff --git a/src/conversions/bytes.rs b/src/conversions/bytes.rs
index 0aba7409578..fb656579a2d 100644
--- a/src/conversions/bytes.rs
+++ b/src/conversions/bytes.rs
@@ -68,10 +68,10 @@ use crate::conversion::IntoPyObject;
 use crate::instance::Bound;
 use crate::pybacked::PyBackedBytes;
 use crate::types::PyBytes;
-use crate::{Borrowed, DowncastError, FromPyObject, PyAny, PyErr, Python};
+use crate::{Borrowed, CastError, FromPyObject, PyAny, PyErr, Python};
 
 impl<'a, 'py> FromPyObject<'a, 'py> for Bytes {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         Ok(Bytes::from_owner(obj.extract::<PyBackedBytes>()?))
diff --git a/src/conversions/chrono.rs b/src/conversions/chrono.rs
index 0a2a56c3530..e9ca64d0ba7 100644
--- a/src/conversions/chrono.rs
+++ b/src/conversions/chrono.rs
@@ -692,11 +692,11 @@ mod tests {
             let none = py.None().into_bound(py);
             assert_eq!(
                 none.extract::<Duration>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'timedelta'"
+                "TypeError: 'NoneType' object cannot be cast as 'timedelta'"
             );
             assert_eq!(
                 none.extract::<FixedOffset>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'tzinfo'"
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
             );
             assert_eq!(
                 none.extract::<Utc>().unwrap_err().to_string(),
@@ -704,25 +704,25 @@ mod tests {
             );
             assert_eq!(
                 none.extract::<NaiveTime>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'time'"
+                "TypeError: 'NoneType' object cannot be cast as 'time'"
             );
             assert_eq!(
                 none.extract::<NaiveDate>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'date'"
+                "TypeError: 'NoneType' object cannot be cast as 'date'"
             );
             assert_eq!(
                 none.extract::<NaiveDateTime>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'datetime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
             assert_eq!(
                 none.extract::<DateTime<Utc>>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'datetime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
             assert_eq!(
                 none.extract::<DateTime<FixedOffset>>()
                     .unwrap_err()
                     .to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'datetime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
         });
     }
diff --git a/src/conversions/jiff.rs b/src/conversions/jiff.rs
index 817b50df79d..9cc9ffd3cee 100644
--- a/src/conversions/jiff.rs
+++ b/src/conversions/jiff.rs
@@ -581,31 +581,31 @@ mod tests {
             let none = py.None().into_bound(py);
             assert_eq!(
                 none.extract::<Span>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'timedelta'"
+                "TypeError: 'NoneType' object cannot be cast as 'timedelta'"
             );
             assert_eq!(
                 none.extract::<Offset>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'tzinfo'"
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
             );
             assert_eq!(
                 none.extract::<TimeZone>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'tzinfo'"
+                "TypeError: 'NoneType' object cannot be cast as 'tzinfo'"
             );
             assert_eq!(
                 none.extract::<Time>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'time'"
+                "TypeError: 'NoneType' object cannot be cast as 'time'"
             );
             assert_eq!(
                 none.extract::<Date>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'date'"
+                "TypeError: 'NoneType' object cannot be cast as 'date'"
             );
             assert_eq!(
                 none.extract::<DateTime>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'datetime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
             assert_eq!(
                 none.extract::<Zoned>().unwrap_err().to_string(),
-                "TypeError: 'NoneType' object cannot be converted to 'datetime'"
+                "TypeError: 'NoneType' object cannot be cast as 'datetime'"
             );
         });
     }
diff --git a/src/conversions/smallvec.rs b/src/conversions/smallvec.rs
index 02bfac51ad6..a1f2fed210e 100644
--- a/src/conversions/smallvec.rs
+++ b/src/conversions/smallvec.rs
@@ -22,8 +22,7 @@ use crate::inspect::types::TypeInfo;
 use crate::types::any::PyAnyMethods;
 use crate::types::{PySequence, PyString};
 use crate::{
-    err::DowncastError, ffi, Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, PyTypeInfo,
-    Python,
+    err::CastError, ffi, Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, PyTypeInfo, Python,
 };
 use smallvec::{Array, SmallVec};
 
@@ -103,11 +102,7 @@ where
         if ffi::PySequence_Check(obj.as_ptr()) != 0 {
             obj.cast_unchecked::<PySequence>()
         } else {
-            return Err(DowncastError::new_from_type(
-                obj,
-                PySequence::type_object(obj.py()).into_any(),
-            )
-            .into());
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
         }
     };
 
@@ -139,7 +134,7 @@ mod tests {
             let sv: PyResult<SmallVec<[u64; 8]>> = dict.extract();
             assert_eq!(
                 sv.unwrap_err().to_string(),
-                "TypeError: 'dict' object cannot be converted to 'Sequence'"
+                "TypeError: 'dict' object cannot be cast as 'Sequence'"
             );
         });
     }
diff --git a/src/conversions/std/array.rs b/src/conversions/std/array.rs
index f5e9cc5900a..b66968cf305 100644
--- a/src/conversions/std/array.rs
+++ b/src/conversions/std/array.rs
@@ -1,7 +1,7 @@
 use crate::conversion::{FromPyObjectOwned, IntoPyObject};
 use crate::types::any::PyAnyMethods;
 use crate::types::PySequence;
-use crate::{err::DowncastError, ffi, FromPyObject, PyAny, PyResult, PyTypeInfo, Python};
+use crate::{err::CastError, ffi, FromPyObject, PyAny, PyResult, PyTypeInfo, Python};
 use crate::{exceptions, Borrowed, Bound, PyErr};
 
 impl<'py, T, const N: usize> IntoPyObject<'py> for [T; N]
@@ -75,11 +75,7 @@ where
         if ffi::PySequence_Check(obj.as_ptr()) != 0 {
             obj.cast_unchecked::<PySequence>()
         } else {
-            return Err(DowncastError::new_from_type(
-                obj,
-                PySequence::type_object(obj.py()).into_any(),
-            )
-            .into());
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
         }
     };
     let seq_len = seq.len()?;
diff --git a/src/conversions/std/slice.rs b/src/conversions/std/slice.rs
index 00c072e588f..a2047deb15b 100644
--- a/src/conversions/std/slice.rs
+++ b/src/conversions/std/slice.rs
@@ -5,7 +5,7 @@ use crate::inspect::types::TypeInfo;
 use crate::{
     conversion::IntoPyObject,
     types::{PyByteArray, PyByteArrayMethods, PyBytes},
-    Bound, DowncastError, PyAny, PyErr, Python,
+    Bound, CastError, PyAny, PyErr, Python,
 };
 
 impl<'a, 'py, T> IntoPyObject<'py> for &'a [T]
@@ -36,7 +36,7 @@ where
 }
 
 impl<'a, 'py> crate::conversion::FromPyObject<'a, 'py> for &'a [u8] {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     fn extract(obj: crate::Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         Ok(obj.cast::<PyBytes>()?.as_bytes())
@@ -54,7 +54,7 @@ impl<'a, 'py> crate::conversion::FromPyObject<'a, 'py> for &'a [u8] {
 /// pointing into the source object, and no copying or heap allocations will happen.
 /// If it is a `bytearray`, its contents will be copied to an owned `Cow`.
 impl<'a, 'py> crate::conversion::FromPyObject<'a, 'py> for Cow<'a, [u8]> {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     fn extract(ob: crate::Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         if let Ok(bytes) = ob.cast::<PyBytes>() {
diff --git a/src/conversions/std/vec.rs b/src/conversions/std/vec.rs
index 74c796732ea..f17a512290e 100644
--- a/src/conversions/std/vec.rs
+++ b/src/conversions/std/vec.rs
@@ -5,7 +5,7 @@ use crate::{
     exceptions::PyTypeError,
     ffi,
     types::{PyAnyMethods, PySequence, PyString},
-    Borrowed, DowncastError, PyResult, PyTypeInfo,
+    Borrowed, CastError, PyResult, PyTypeInfo,
 };
 use crate::{Bound, PyAny, PyErr, Python};
 
@@ -91,11 +91,7 @@ where
         if ffi::PySequence_Check(obj.as_ptr()) != 0 {
             obj.cast_unchecked::<PySequence>()
         } else {
-            return Err(DowncastError::new_from_type(
-                obj,
-                PySequence::type_object(obj.py()).into_any(),
-            )
-            .into());
+            return Err(CastError::new(obj, PySequence::type_object(obj.py()).into_any()).into());
         }
     };
 
diff --git a/src/err/cast_error.rs b/src/err/cast_error.rs
new file mode 100644
index 00000000000..6407b251ce5
--- /dev/null
+++ b/src/err/cast_error.rs
@@ -0,0 +1,239 @@
+use std::borrow::Cow;
+
+use crate::{
+    exceptions,
+    types::{PyAnyMethods, PyStringMethods, PyTuple, PyTupleMethods, PyType, PyTypeMethods},
+    Borrowed, Bound, IntoPyObjectExt, Py, PyAny, PyErr, PyErrArguments, Python,
+};
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+pub struct CastError<'a, 'py> {
+    /// The original object that failed to convert.
+    from: Borrowed<'a, 'py, PyAny>,
+    /// The type we tried (and failed) to convert to.
+    /// (see `PyTypeCheck::classinfo_object`)
+    to: Bound<'py, PyAny>,
+}
+
+impl<'a, 'py> CastError<'a, 'py> {
+    /// Create a new `CastError` representing a failure to convert the object
+    /// `from` into the type `to`.
+    ///
+    /// As with [`PyTypeCheck::classinfo_object`][crate::PyTypeCheck::classinfo_object],
+    /// valid `to` values are those which can be used with `isinstance`, such as `type`
+    /// objects, tuples of `type` objects, or `typing.Union` instances.
+    #[inline]
+    pub fn new(from: Borrowed<'a, 'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
+        Self { from, to }
+    }
+}
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+pub struct CastIntoError<'py> {
+    from: Bound<'py, PyAny>,
+    to: Bound<'py, PyAny>,
+}
+
+impl<'py> CastIntoError<'py> {
+    /// Create a new `CastIntoError` representing a failure to convert the object
+    /// `from` into the type `to`.
+    ///
+    /// Equivalent to [`CastError::new`] for owned objects.
+    #[inline]
+    pub fn new(from: Bound<'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
+        Self { from, to }
+    }
+
+    /// Consumes this `CastIntoError` and returns the original object, allowing continued
+    /// use of it after a failed conversion.
+    ///
+    /// See [`cast_into`][Bound::cast_into] for an example.
+    pub fn into_inner(self) -> Bound<'py, PyAny> {
+        self.from
+    }
+}
+
+struct CastErrorArguments {
+    from: Py<PyType>,
+    to: Py<PyAny>,
+}
+
+impl PyErrArguments for CastErrorArguments {
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        format!(
+            "{}",
+            DisplayDowncastError {
+                from: &self.from.into_bound(py),
+                to: &self.to.into_bound(py),
+            }
+        )
+        .into_py_any(py)
+        .expect("failed to create Python string")
+    }
+}
+
+/// Convert `CastError` to Python `TypeError`.
+impl std::convert::From<CastError<'_, '_>> for PyErr {
+    fn from(err: CastError<'_, '_>) -> PyErr {
+        let args = CastErrorArguments {
+            from: err.from.get_type().unbind(),
+            to: err.to.unbind(),
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for CastError<'_, '_> {}
+
+impl std::fmt::Display for CastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        DisplayDowncastError {
+            from: &self.from.get_type(),
+            to: &self.to,
+        }
+        .fmt(f)
+    }
+}
+
+/// Convert `CastIntoError` to Python `TypeError`.
+impl std::convert::From<CastIntoError<'_>> for PyErr {
+    fn from(err: CastIntoError<'_>) -> PyErr {
+        let args = CastErrorArguments {
+            from: err.from.get_type().unbind(),
+            to: err.to.unbind(),
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for CastIntoError<'_> {}
+
+impl std::fmt::Display for CastIntoError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        DisplayDowncastError {
+            from: &self.from.get_type(),
+            to: &self.to,
+        }
+        .fmt(f)
+    }
+}
+
+struct DisplayDowncastError<'a, 'py> {
+    from: &'a Bound<'py, PyType>,
+    to: &'a Bound<'py, PyAny>,
+}
+
+impl std::fmt::Display for DisplayDowncastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let from = self.from.qualname();
+        let from = from
+            .as_ref()
+            .map(|name| name.to_string_lossy())
+            .unwrap_or(Cow::Borrowed("<failed to extract type name>"));
+        let to = DisplayClassInfo(self.to);
+        write!(f, "'{from}' object cannot be cast as '{to}'")
+    }
+}
+
+struct DisplayClassInfo<'a, 'py>(&'a Bound<'py, PyAny>);
+
+impl std::fmt::Display for DisplayClassInfo<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Ok(t) = self.0.cast::<PyType>() {
+            t.qualname()
+                .map_err(|_| std::fmt::Error)?
+                .to_string_lossy()
+                .fmt(f)
+        } else if let Ok(t) = self.0.cast::<PyTuple>() {
+            for (i, t) in t.iter().enumerate() {
+                if i > 0 {
+                    f.write_str(" | ")?;
+                }
+                write!(f, "{}", DisplayClassInfo(&t))?;
+            }
+            Ok(())
+        } else {
+            self.0.fmt(f)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::PyTypeInfo;
+
+    use super::*;
+
+    #[test]
+    fn test_display_cast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            assert_eq!(err.to_string(), "'NoneType' object cannot be cast as 'int'");
+        })
+    }
+
+    #[test]
+    fn test_display_cast_error_with_tuple() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = PyTuple::new(
+                py,
+                &[
+                    py.get_type::<crate::types::PyInt>().into_any(),
+                    crate::types::PyNone::type_object(py).into_any(),
+                ],
+            )
+            .unwrap()
+            .into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be cast as 'int | NoneType'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_display_cast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastIntoError::new(obj, to_type);
+            assert_eq!(err.to_string(), "'NoneType' object cannot be cast as 'int'");
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_cast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastError::new(obj.as_borrowed(), to_type);
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_cast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let to_type = py.get_type::<crate::types::PyInt>().into_any();
+            let err = CastIntoError::new(obj, to_type);
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be cast as 'int'"
+            );
+        })
+    }
+}
diff --git a/src/err/downcast_error.rs b/src/err/downcast_error.rs
new file mode 100644
index 00000000000..d5c054a0111
--- /dev/null
+++ b/src/err/downcast_error.rs
@@ -0,0 +1,183 @@
+#![allow(deprecated)]
+
+use std::borrow::Cow;
+
+use crate::{
+    exceptions,
+    types::{PyAnyMethods, PyStringMethods, PyType, PyTypeMethods},
+    Borrowed, Bound, IntoPyObject, Py, PyAny, PyErr, PyErrArguments, Python,
+};
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+#[deprecated(since = "0.27.0", note = "replaced with `CastError`")]
+pub struct DowncastError<'a, 'py> {
+    from: Borrowed<'a, 'py, PyAny>,
+    to: Cow<'static, str>,
+}
+
+impl<'a, 'py> DowncastError<'a, 'py> {
+    /// Create a new `DowncastError` representing a failure to convert the object
+    /// `from` into the type named in `to`.
+    pub fn new(from: &'a Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            from: from.as_borrowed(),
+            to: to.into(),
+        }
+    }
+}
+
+/// Error that indicates a failure to convert a PyAny to a more specific Python type.
+#[derive(Debug)]
+#[deprecated(since = "0.27.0", note = "replaced with `CastIntoError`")]
+pub struct DowncastIntoError<'py> {
+    from: Bound<'py, PyAny>,
+    to: Cow<'static, str>,
+}
+
+impl<'py> DowncastIntoError<'py> {
+    /// Create a new `DowncastIntoError` representing a failure to convert the object
+    /// `from` into the type named in `to`.
+    pub fn new(from: Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            from,
+            to: to.into(),
+        }
+    }
+
+    /// Consumes this `DowncastIntoError` and returns the original object, allowing continued
+    /// use of it after a failed conversion.
+    ///
+    /// See [`cast_into`][Bound::cast_into] for an example.
+    pub fn into_inner(self) -> Bound<'py, PyAny> {
+        self.from
+    }
+}
+
+struct DowncastErrorArguments {
+    from: Py<PyType>,
+    to: Cow<'static, str>,
+}
+
+impl PyErrArguments for DowncastErrorArguments {
+    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
+        let from = self.from.bind(py).qualname();
+        let from = from
+            .as_ref()
+            .map(|name| name.to_string_lossy())
+            .unwrap_or(Cow::Borrowed("<failed to extract type name>"));
+        format!("'{}' object cannot be converted to '{}'", from, self.to)
+            .into_pyobject(py)
+            .unwrap()
+            .into_any()
+            .unbind()
+    }
+}
+
+/// Convert `CastError` to Python `TypeError`.
+impl std::convert::From<DowncastError<'_, '_>> for PyErr {
+    fn from(err: DowncastError<'_, '_>) -> PyErr {
+        let args = DowncastErrorArguments {
+            from: err.from.get_type().into(),
+            to: err.to,
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for DowncastError<'_, '_> {}
+
+impl std::fmt::Display for DowncastError<'_, '_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        display_downcast_error(f, &self.from, &self.to)
+    }
+}
+
+/// Convert `DowncastIntoError` to Python `TypeError`.
+impl std::convert::From<DowncastIntoError<'_>> for PyErr {
+    fn from(err: DowncastIntoError<'_>) -> PyErr {
+        let args = DowncastErrorArguments {
+            from: err.from.get_type().into(),
+            to: err.to,
+        };
+
+        exceptions::PyTypeError::new_err(args)
+    }
+}
+
+impl std::error::Error for DowncastIntoError<'_> {}
+
+impl std::fmt::Display for DowncastIntoError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        display_downcast_error(f, &self.from, &self.to)
+    }
+}
+
+fn display_downcast_error(
+    f: &mut std::fmt::Formatter<'_>,
+    from: &Bound<'_, PyAny>,
+    to: &str,
+) -> std::fmt::Result {
+    write!(
+        f,
+        "'{}' object cannot be converted to '{}'",
+        from.get_type().qualname().map_err(|_| std::fmt::Error)?,
+        to
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_display_downcast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastError::new(&obj, "int");
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_display_downcast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastIntoError::new(obj, "int");
+            assert_eq!(
+                err.to_string(),
+                "'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_downcast_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastError::new(&obj, "int");
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+
+    #[test]
+    fn test_pyerr_from_downcast_into_error() {
+        Python::attach(|py| {
+            let obj = py.None().into_bound(py);
+            let err = DowncastIntoError::new(obj, "int");
+            let py_err: PyErr = err.into();
+            assert_eq!(
+                py_err.to_string(),
+                "TypeError: 'NoneType' object cannot be converted to 'int'"
+            );
+        })
+    }
+}
diff --git a/src/err/mod.rs b/src/err/mod.rs
index a560d651f66..680c759f69a 100644
--- a/src/err/mod.rs
+++ b/src/err/mod.rs
@@ -8,16 +8,14 @@ use crate::types::any::PyAnyMethods;
 use crate::types::PyString;
 use crate::types::{
     string::PyStringMethods, traceback::PyTracebackMethods, typeobject::PyTypeMethods, PyTraceback,
-    PyTuple, PyTupleMethods, PyType,
+    PyType,
 };
-use crate::{
-    exceptions::{self, PyBaseException},
-    ffi,
-};
-use crate::{Borrowed, BoundObject, Py, PyAny, Python};
-use std::borrow::Cow;
+use crate::{exceptions::PyBaseException, ffi};
+use crate::{BoundObject, Py, PyAny, Python};
 use std::ffi::CStr;
 
+mod cast_error;
+mod downcast_error;
 mod err_state;
 mod impls;
 
@@ -26,6 +24,10 @@ use err_state::{PyErrState, PyErrStateLazyFnOutput, PyErrStateNormalized};
 use std::convert::Infallible;
 use std::ptr;
 
+pub use cast_error::{CastError, CastIntoError};
+#[allow(deprecated)]
+pub use downcast_error::{DowncastError, DowncastIntoError};
+
 /// Represents a Python exception.
 ///
 /// To avoid needing access to [`Python`] in `Into` conversions to create `PyErr` (thus improving
@@ -46,70 +48,6 @@ unsafe impl crate::marker::Ungil for PyErr {}
 /// Represents the result of a Python call.
 pub type PyResult<T> = Result<T, PyErr>;
 
-/// Error that indicates a failure to convert a PyAny to a more specific Python type.
-#[derive(Debug)]
-pub struct DowncastError<'a, 'py> {
-    from: Borrowed<'a, 'py, PyAny>,
-    to: TypeNameOrValue<'py>,
-}
-
-impl<'a, 'py> DowncastError<'a, 'py> {
-    /// Create a new `PyDowncastError` representing a failure to convert the object
-    /// `from` into the type named in `to`.
-    pub fn new(from: &'a Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
-        Self {
-            from: from.as_borrowed(),
-            to: TypeNameOrValue::Name(to.into()),
-        }
-    }
-
-    pub(crate) fn new_from_type(from: Borrowed<'a, 'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
-        Self {
-            from,
-            to: TypeNameOrValue::Value(to),
-        }
-    }
-}
-
-/// Error that indicates a failure to convert a PyAny to a more specific Python type.
-#[derive(Debug)]
-pub struct DowncastIntoError<'py> {
-    from: Bound<'py, PyAny>,
-    to: TypeNameOrValue<'py>,
-}
-
-impl<'py> DowncastIntoError<'py> {
-    /// Create a new `DowncastIntoError` representing a failure to convert the object
-    /// `from` into the type named in `to`.
-    pub fn new(from: Bound<'py, PyAny>, to: impl Into<Cow<'static, str>>) -> Self {
-        Self {
-            from,
-            to: TypeNameOrValue::Name(to.into()),
-        }
-    }
-
-    pub(crate) fn new_from_type(from: Bound<'py, PyAny>, to: Bound<'py, PyAny>) -> Self {
-        Self {
-            from,
-            to: TypeNameOrValue::Value(to),
-        }
-    }
-
-    /// Consumes this `DowncastIntoError` and returns the original object, allowing continued
-    /// use of it after a failed conversion.
-    ///
-    /// See [`cast_into`][Bound::cast_into] for an example.
-    pub fn into_inner(self) -> Bound<'py, PyAny> {
-        self.from
-    }
-}
-
-// Helper to store either a concrete type or a type name
-#[derive(Debug)]
-enum TypeNameOrValue<'py> {
-    Name(Cow<'static, str>),
-    Value(Bound<'py, PyAny>),
-}
 /// Helper conversion trait that allows to use custom arguments for lazy exception construction.
 pub trait PyErrArguments: Send + Sync {
     /// Arguments for exception
@@ -387,7 +325,7 @@ impl PyErr {
             #[cfg(debug_assertions)]
             None => panic!("{}", FAILED_TO_FETCH),
             #[cfg(not(debug_assertions))]
-            None => exceptions::PySystemError::new_err(FAILED_TO_FETCH),
+            None => crate::exceptions::PySystemError::new_err(FAILED_TO_FETCH),
         }
     }
 
@@ -746,35 +684,6 @@ impl<'py> IntoPyObject<'py> for &PyErr {
     }
 }
 
-struct PyDowncastErrorArguments {
-    from: Py<PyType>,
-    to: OwnedTypeNameOrValue,
-}
-
-impl PyErrArguments for PyDowncastErrorArguments {
-    fn arguments(self, py: Python<'_>) -> Py<PyAny> {
-        let from = self.from.bind(py).qualname();
-        let from = from
-            .as_ref()
-            .map(|name| name.to_string_lossy())
-            .unwrap_or(Cow::Borrowed("<failed to extract type name>"));
-        let to = match self.to {
-            OwnedTypeNameOrValue::Name(name) => TypeNameOrValue::Name(name),
-            OwnedTypeNameOrValue::Value(t) => TypeNameOrValue::Value(t.into_bound(py)),
-        };
-        format!("'{}' object cannot be converted to '{}'", from, to)
-            .into_pyobject(py)
-            .unwrap()
-            .into_any()
-            .unbind()
-    }
-}
-
-enum OwnedTypeNameOrValue {
-    Name(Cow<'static, str>),
-    Value(Py<PyAny>),
-}
-
 /// Python exceptions that can be converted to [`PyErr`].
 ///
 /// This is used to implement [`From<Bound<'_, T>> for PyErr`].
@@ -793,91 +702,6 @@ where
     }
 }
 
-/// Convert `DowncastError` to Python `TypeError`.
-impl std::convert::From<DowncastError<'_, '_>> for PyErr {
-    fn from(err: DowncastError<'_, '_>) -> PyErr {
-        let args = PyDowncastErrorArguments {
-            from: err.from.get_type().into(),
-            to: match err.to {
-                TypeNameOrValue::Name(name) => OwnedTypeNameOrValue::Name(name),
-                TypeNameOrValue::Value(t) => OwnedTypeNameOrValue::Value(t.into()),
-            },
-        };
-
-        exceptions::PyTypeError::new_err(args)
-    }
-}
-
-impl std::error::Error for DowncastError<'_, '_> {}
-
-impl std::fmt::Display for DowncastError<'_, '_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        display_downcast_error(f, &self.from, &self.to)
-    }
-}
-
-/// Convert `DowncastIntoError` to Python `TypeError`.
-impl std::convert::From<DowncastIntoError<'_>> for PyErr {
-    fn from(err: DowncastIntoError<'_>) -> PyErr {
-        let args = PyDowncastErrorArguments {
-            from: err.from.get_type().into(),
-            to: match err.to {
-                TypeNameOrValue::Name(name) => OwnedTypeNameOrValue::Name(name),
-                TypeNameOrValue::Value(t) => OwnedTypeNameOrValue::Value(t.into()),
-            },
-        };
-
-        exceptions::PyTypeError::new_err(args)
-    }
-}
-
-impl std::error::Error for DowncastIntoError<'_> {}
-
-impl std::fmt::Display for DowncastIntoError<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        display_downcast_error(f, &self.from, &self.to)
-    }
-}
-
-fn display_downcast_error(
-    f: &mut std::fmt::Formatter<'_>,
-    from: &Bound<'_, PyAny>,
-    to: &TypeNameOrValue<'_>,
-) -> std::fmt::Result {
-    write!(
-        f,
-        "'{}' object cannot be converted to '{}'",
-        from.get_type().qualname().map_err(|_| std::fmt::Error)?,
-        to
-    )
-}
-
-impl std::fmt::Display for TypeNameOrValue<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Name(name) => name.fmt(f),
-            Self::Value(t) => {
-                if let Ok(t) = t.cast::<PyType>() {
-                    t.qualname()
-                        .map_err(|_| std::fmt::Error)?
-                        .to_string_lossy()
-                        .fmt(f)
-                } else if let Ok(t) = t.cast::<PyTuple>() {
-                    for (i, t) in t.iter().enumerate() {
-                        if i > 0 {
-                            f.write_str(" | ")?;
-                        }
-                        TypeNameOrValue::Value(t).fmt(f)?;
-                    }
-                    Ok(())
-                } else {
-                    t.fmt(f)
-                }
-            }
-        }
-    }
-}
-
 #[track_caller]
 pub fn panic_after_error(_py: Python<'_>) -> ! {
     unsafe {
diff --git a/src/impl_/extract_argument.rs b/src/impl_/extract_argument.rs
index 39023d021a2..daadc2c5235 100644
--- a/src/impl_/extract_argument.rs
+++ b/src/impl_/extract_argument.rs
@@ -3,8 +3,8 @@ use crate::{
     ffi,
     pyclass::boolean_struct::False,
     types::{any::PyAnyMethods, dict::PyDictMethods, tuple::PyTupleMethods, PyDict, PyTuple},
-    Borrowed, Bound, DowncastError, FromPyObject, PyAny, PyClass, PyClassGuard, PyClassGuardMut,
-    PyErr, PyResult, PyTypeCheck, Python,
+    Borrowed, Bound, CastError, FromPyObject, PyAny, PyClass, PyClassGuard, PyClassGuardMut, PyErr,
+    PyResult, PyTypeCheck, Python,
 };
 
 /// Helper type used to keep implementation more concise.
@@ -89,7 +89,7 @@ where
     T: PyTypeCheck,
 {
     type Holder = ();
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     #[cfg(feature = "experimental-inspect")]
     const INPUT_TYPE: &'static str = T::PYTHON_TYPE;
diff --git a/src/impl_/pymethods.rs b/src/impl_/pymethods.rs
index 37d54e92166..980619bb81d 100644
--- a/src/impl_/pymethods.rs
+++ b/src/impl_/pymethods.rs
@@ -9,9 +9,8 @@ use crate::pycell::{PyBorrowError, PyBorrowMutError};
 use crate::pyclass::boolean_struct::False;
 use crate::types::PyType;
 use crate::{
-    ffi, Bound, DowncastError, Py, PyAny, PyClass, PyClassGuard, PyClassGuardMut,
-    PyClassInitializer, PyErr, PyRef, PyRefMut, PyResult, PyTraverseError, PyTypeCheck, PyVisit,
-    Python,
+    ffi, Bound, CastError, Py, PyAny, PyClass, PyClassGuard, PyClassGuardMut, PyClassInitializer,
+    PyErr, PyRef, PyRefMut, PyResult, PyTraverseError, PyTypeCheck, PyVisit, Python,
 };
 use std::ffi::CStr;
 use std::ffi::{c_int, c_void};
@@ -637,11 +636,11 @@ impl<'a, 'py> BoundRef<'a, 'py, PyAny> {
         unsafe { Self(Bound::ref_from_non_null(py, ptr)) }
     }
 
-    pub fn downcast<T: PyTypeCheck>(self) -> Result<BoundRef<'a, 'py, T>, DowncastError<'a, 'py>> {
+    pub fn cast<T: PyTypeCheck>(self) -> Result<BoundRef<'a, 'py, T>, CastError<'a, 'py>> {
         self.0.cast::<T>().map(BoundRef)
     }
 
-    pub unsafe fn downcast_unchecked<T>(self) -> BoundRef<'a, 'py, T> {
+    pub unsafe fn cast_unchecked<T>(self) -> BoundRef<'a, 'py, T> {
         unsafe { BoundRef(self.0.cast_unchecked::<T>()) }
     }
 }
diff --git a/src/instance.rs b/src/instance.rs
index 37a05ccebc6..0105d1f6130 100644
--- a/src/instance.rs
+++ b/src/instance.rs
@@ -9,8 +9,10 @@ use crate::pycell::{PyBorrowError, PyBorrowMutError};
 use crate::pyclass::boolean_struct::{False, True};
 use crate::types::{any::PyAnyMethods, string::PyStringMethods, typeobject::PyTypeMethods};
 use crate::types::{DerefToPyAny, PyDict, PyString};
+#[allow(deprecated)]
+use crate::DowncastError;
 use crate::{
-    ffi, DowncastError, DowncastIntoError, FromPyObject, PyAny, PyClass, PyClassInitializer, PyRef,
+    ffi, CastError, CastIntoError, FromPyObject, PyAny, PyClass, PyClassInitializer, PyRef,
     PyRefMut, PyTypeInfo, Python,
 };
 use crate::{internal::state, PyTypeCheck};
@@ -154,14 +156,14 @@ impl<'py, T> Bound<'py, T> {
     /// # }
     /// ```
     #[inline]
-    pub fn cast<U>(&self) -> Result<&Bound<'py, U>, DowncastError<'_, 'py>>
+    pub fn cast<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
     where
         U: PyTypeCheck,
     {
         #[inline]
         fn inner<'a, 'py, U>(
             any: &'a Bound<'py, PyAny>,
-        ) -> Result<&'a Bound<'py, U>, DowncastError<'a, 'py>>
+        ) -> Result<&'a Bound<'py, U>, CastError<'a, 'py>>
         where
             U: PyTypeCheck,
         {
@@ -169,7 +171,7 @@ impl<'py, T> Bound<'py, T> {
                 // Safety: type_check is responsible for ensuring that the type is correct
                 Ok(unsafe { any.cast_unchecked() })
             } else {
-                Err(DowncastError::new_from_type(
+                Err(CastError::new(
                     any.as_borrowed(),
                     U::classinfo_object(any.py()),
                 ))
@@ -182,7 +184,7 @@ impl<'py, T> Bound<'py, T> {
     /// Like [`cast`](Self::cast) but takes ownership of `self`.
     ///
     /// In case of an error, it is possible to retrieve `self` again via
-    /// [`DowncastIntoError::into_inner`].
+    /// [`CastIntoError::into_inner`].
     ///
     /// # Example
     ///
@@ -203,12 +205,12 @@ impl<'py, T> Bound<'py, T> {
     /// })
     /// ```
     #[inline]
-    pub fn cast_into<U>(self) -> Result<Bound<'py, U>, DowncastIntoError<'py>>
+    pub fn cast_into<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>
     where
         U: PyTypeCheck,
     {
         #[inline]
-        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, DowncastIntoError<'_>>
+        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, CastIntoError<'_>>
         where
             U: PyTypeCheck,
         {
@@ -217,7 +219,7 @@ impl<'py, T> Bound<'py, T> {
                 Ok(unsafe { any.cast_into_unchecked() })
             } else {
                 let to = U::classinfo_object(any.py());
-                Err(DowncastIntoError::new_from_type(any, to))
+                Err(CastIntoError::new(any, to))
             }
         }
 
@@ -255,14 +257,14 @@ impl<'py, T> Bound<'py, T> {
     /// });
     /// ```
     #[inline]
-    pub fn cast_exact<U>(&self) -> Result<&Bound<'py, U>, DowncastError<'_, 'py>>
+    pub fn cast_exact<U>(&self) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
     where
         U: PyTypeInfo,
     {
         #[inline]
         fn inner<'a, 'py, U>(
             any: &'a Bound<'py, PyAny>,
-        ) -> Result<&'a Bound<'py, U>, DowncastError<'a, 'py>>
+        ) -> Result<&'a Bound<'py, U>, CastError<'a, 'py>>
         where
             U: PyTypeInfo,
         {
@@ -270,7 +272,7 @@ impl<'py, T> Bound<'py, T> {
                 // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
                 Ok(unsafe { any.cast_unchecked() })
             } else {
-                Err(DowncastError::new_from_type(
+                Err(CastError::new(
                     any.as_borrowed(),
                     U::type_object(any.py()).into_any(),
                 ))
@@ -282,12 +284,12 @@ impl<'py, T> Bound<'py, T> {
 
     /// Like [`cast_exact`](Self::cast_exact) but takes ownership of `self`.
     #[inline]
-    pub fn cast_into_exact<U>(self) -> Result<Bound<'py, U>, DowncastIntoError<'py>>
+    pub fn cast_into_exact<U>(self) -> Result<Bound<'py, U>, CastIntoError<'py>>
     where
         U: PyTypeInfo,
     {
         #[inline]
-        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, DowncastIntoError<'_>>
+        fn inner<U>(any: Bound<'_, PyAny>) -> Result<Bound<'_, U>, CastIntoError<'_>>
         where
             U: PyTypeInfo,
         {
@@ -296,7 +298,7 @@ impl<'py, T> Bound<'py, T> {
                 Ok(unsafe { any.cast_into_unchecked() })
             } else {
                 let to = U::type_object(any.py()).into_any();
-                Err(DowncastIntoError::new_from_type(any, to))
+                Err(CastIntoError::new(any, to))
             }
         }
 
@@ -984,13 +986,13 @@ impl<'a, 'py, T> Borrowed<'a, 'py, T> {
     /// This performs a runtime type check using the equivalent of Python's
     /// `isinstance(self, U)`.
     #[inline]
-    pub fn cast<U>(self) -> Result<Borrowed<'a, 'py, U>, DowncastError<'a, 'py>>
+    pub fn cast<U>(self) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
     where
         U: PyTypeCheck,
     {
         fn inner<'a, 'py, U>(
             any: Borrowed<'a, 'py, PyAny>,
-        ) -> Result<Borrowed<'a, 'py, U>, DowncastError<'a, 'py>>
+        ) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
         where
             U: PyTypeCheck,
         {
@@ -998,10 +1000,7 @@ impl<'a, 'py, T> Borrowed<'a, 'py, T> {
                 // Safety: type_check is responsible for ensuring that the type is correct
                 Ok(unsafe { any.cast_unchecked() })
             } else {
-                Err(DowncastError::new_from_type(
-                    any,
-                    U::classinfo_object(any.py()),
-                ))
+                Err(CastError::new(any, U::classinfo_object(any.py())))
             }
         }
         inner(self.to_any())
@@ -1016,13 +1015,13 @@ impl<'a, 'py, T> Borrowed<'a, 'py, T> {
     /// implementation of `cast_exact` uses the equivalent of the Python expression `type(self) is
     /// U`, whereas `cast` uses `isinstance(self, U)`.
     #[inline]
-    pub fn cast_exact<U>(self) -> Result<Borrowed<'a, 'py, U>, DowncastError<'a, 'py>>
+    pub fn cast_exact<U>(self) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
     where
         U: PyTypeInfo,
     {
         fn inner<'a, 'py, U>(
             any: Borrowed<'a, 'py, PyAny>,
-        ) -> Result<Borrowed<'a, 'py, U>, DowncastError<'a, 'py>>
+        ) -> Result<Borrowed<'a, 'py, U>, CastError<'a, 'py>>
         where
             U: PyTypeInfo,
         {
@@ -1030,10 +1029,7 @@ impl<'a, 'py, T> Borrowed<'a, 'py, T> {
                 // Safety: is_exact_instance_of is responsible for ensuring that the type is correct
                 Ok(unsafe { any.cast_unchecked() })
             } else {
-                Err(DowncastError::new_from_type(
-                    any,
-                    U::classinfo_object(any.py()),
-                ))
+                Err(CastError::new(any, U::classinfo_object(any.py())))
             }
         }
         inner(self.to_any())
@@ -2193,7 +2189,7 @@ impl<'a, 'py, T> FromPyObject<'a, 'py> for Py<T>
 where
     T: PyTypeCheck + 'a,
 {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     #[cfg(feature = "experimental-inspect")]
     const INPUT_TYPE: &'static str = T::PYTHON_TYPE;
@@ -2208,7 +2204,7 @@ impl<'a, 'py, T> FromPyObject<'a, 'py> for Bound<'py, T>
 where
     T: PyTypeCheck + 'a,
 {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     #[cfg(feature = "experimental-inspect")]
     const INPUT_TYPE: &'static str = T::PYTHON_TYPE;
@@ -2296,6 +2292,7 @@ impl Py<PyAny> {
     /// ```
     #[deprecated(since = "0.27.0", note = "use `Py::cast_bound` instead")]
     #[inline]
+    #[allow(deprecated)]
     pub fn downcast_bound<'py, T>(
         &self,
         py: Python<'py>,
@@ -2369,10 +2366,7 @@ impl<T> Py<T> {
     /// })
     /// # }
     /// ```
-    pub fn cast_bound<'py, U>(
-        &self,
-        py: Python<'py>,
-    ) -> Result<&Bound<'py, U>, DowncastError<'_, 'py>>
+    pub fn cast_bound<'py, U>(&self, py: Python<'py>) -> Result<&Bound<'py, U>, CastError<'_, 'py>>
     where
         U: PyTypeCheck,
     {
diff --git a/src/lib.rs b/src/lib.rs
index 9103bf38a54..1fa7b918be7 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -342,7 +342,9 @@
 //! [`Ungil`]: crate::marker::Ungil
 pub use crate::class::*;
 pub use crate::conversion::{FromPyObject, IntoPyObject, IntoPyObjectExt};
-pub use crate::err::{DowncastError, DowncastIntoError, PyErr, PyErrArguments, PyResult, ToPyErr};
+pub use crate::err::{CastError, CastIntoError, PyErr, PyErrArguments, PyResult, ToPyErr};
+#[allow(deprecated)]
+pub use crate::err::{DowncastError, DowncastIntoError};
 #[allow(deprecated)]
 pub use crate::instance::PyObject;
 pub use crate::instance::{Borrowed, Bound, BoundObject, Py};
diff --git a/src/pybacked.rs b/src/pybacked.rs
index aae737f5438..95f34620c6f 100644
--- a/src/pybacked.rs
+++ b/src/pybacked.rs
@@ -7,8 +7,7 @@ use crate::{
         bytearray::PyByteArrayMethods, bytes::PyBytesMethods, string::PyStringMethods, PyByteArray,
         PyBytes, PyString, PyTuple,
     },
-    Borrowed, Bound, DowncastError, FromPyObject, IntoPyObject, Py, PyAny, PyErr, PyTypeInfo,
-    Python,
+    Borrowed, Bound, CastError, FromPyObject, IntoPyObject, Py, PyAny, PyErr, PyTypeInfo, Python,
 };
 
 /// A wrapper around `str` where the storage is owned by a Python `bytes` or `str` object.
@@ -205,7 +204,7 @@ impl From<Bound<'_, PyByteArray>> for PyBackedBytes {
 }
 
 impl<'a, 'py> FromPyObject<'a, 'py> for PyBackedBytes {
-    type Error = DowncastError<'a, 'py>;
+    type Error = CastError<'a, 'py>;
 
     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         if let Ok(bytes) = obj.cast::<PyBytes>() {
@@ -213,7 +212,7 @@ impl<'a, 'py> FromPyObject<'a, 'py> for PyBackedBytes {
         } else if let Ok(bytearray) = obj.cast::<PyByteArray>() {
             Ok(Self::from(bytearray.to_owned()))
         } else {
-            Err(DowncastError::new_from_type(
+            Err(CastError::new(
                 obj,
                 PyTuple::new(
                     obj.py(),
diff --git a/src/pyclass/guard.rs b/src/pyclass/guard.rs
index cc2b949e42e..f2fd3d59b78 100644
--- a/src/pyclass/guard.rs
+++ b/src/pyclass/guard.rs
@@ -2,7 +2,7 @@ use crate::impl_::pycell::{PyClassObject, PyClassObjectLayout as _};
 use crate::pycell::PyBorrowMutError;
 use crate::pycell::{impl_::PyClassBorrowChecker, PyBorrowError};
 use crate::pyclass::boolean_struct::False;
-use crate::{ffi, Borrowed, DowncastError, FromPyObject, IntoPyObject, Py, PyClass, PyErr};
+use crate::{ffi, Borrowed, CastError, FromPyObject, IntoPyObject, Py, PyClass, PyErr};
 use std::convert::Infallible;
 use std::fmt;
 use std::marker::PhantomData;
@@ -334,7 +334,7 @@ unsafe impl<T: PyClass + Sync> Send for PyClassGuard<'_, T> {}
 unsafe impl<T: PyClass + Sync> Sync for PyClassGuard<'_, T> {}
 
 /// Custom error type for extracting a [PyClassGuard]
-pub struct PyClassGuardError<'a, 'py>(pub(crate) Option<DowncastError<'a, 'py>>);
+pub struct PyClassGuardError<'a, 'py>(pub(crate) Option<CastError<'a, 'py>>);
 
 impl fmt::Debug for PyClassGuardError<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -735,7 +735,7 @@ unsafe impl<T: PyClass<Frozen = False> + Send + Sync> Send for PyClassGuardMut<'
 unsafe impl<T: PyClass<Frozen = False> + Sync> Sync for PyClassGuardMut<'_, T> {}
 
 /// Custom error type for extracting a [PyClassGuardMut]
-pub struct PyClassGuardMutError<'a, 'py>(pub(crate) Option<DowncastError<'a, 'py>>);
+pub struct PyClassGuardMutError<'a, 'py>(pub(crate) Option<CastError<'a, 'py>>);
 
 impl fmt::Debug for PyClassGuardMutError<'_, '_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
diff --git a/src/types/any.rs b/src/types/any.rs
index a20f0bebb99..cf08f22a9cf 100644
--- a/src/types/any.rs
+++ b/src/types/any.rs
@@ -1,7 +1,7 @@
 use crate::call::PyCallArgs;
 use crate::class::basic::CompareOp;
 use crate::conversion::{FromPyObject, IntoPyObject};
-use crate::err::{DowncastError, DowncastIntoError, PyErr, PyResult};
+use crate::err::{PyErr, PyResult};
 use crate::exceptions::{PyAttributeError, PyTypeError};
 use crate::ffi_ptr_ext::FfiPtrExt;
 use crate::instance::Bound;
@@ -12,6 +12,8 @@ use crate::type_object::{PyTypeCheck, PyTypeInfo};
 use crate::types::PySuper;
 use crate::types::{PyDict, PyIterator, PyList, PyString, PyType};
 use crate::{err, ffi, Borrowed, BoundObject, IntoPyObjectExt, Py, Python};
+#[allow(deprecated)]
+use crate::{DowncastError, DowncastIntoError};
 use std::cell::UnsafeCell;
 use std::cmp::Ordering;
 use std::ffi::c_int;
@@ -773,6 +775,7 @@ pub trait PyAnyMethods<'py>: crate::sealed::Sealed {
     /// # }
     /// ```
     #[deprecated(since = "0.27.0", note = "use `Bound::cast` instead")]
+    #[allow(deprecated)]
     fn downcast<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeCheck;
@@ -801,6 +804,7 @@ pub trait PyAnyMethods<'py>: crate::sealed::Sealed {
     /// })
     /// ```
     #[deprecated(since = "0.27.0", note = "use `Bound::cast_into` instead")]
+    #[allow(deprecated)]
     fn downcast_into<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeCheck;
@@ -837,12 +841,14 @@ pub trait PyAnyMethods<'py>: crate::sealed::Sealed {
     /// });
     /// ```
     #[deprecated(since = "0.27.0", note = "use `Bound::cast_exact` instead")]
+    #[allow(deprecated)]
     fn downcast_exact<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeInfo;
 
     /// Like `downcast_exact` but takes ownership of `self`.
     #[deprecated(since = "0.27.0", note = "use `Bound::cast_into_exact` instead")]
+    #[allow(deprecated)]
     fn downcast_into_exact<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeInfo;
@@ -1445,6 +1451,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeCheck,
@@ -1459,6 +1466,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_into<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeCheck,
@@ -1473,6 +1481,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_exact<T>(&self) -> Result<&Bound<'py, T>, DowncastError<'_, 'py>>
     where
         T: PyTypeInfo,
@@ -1487,6 +1496,7 @@ impl<'py> PyAnyMethods<'py> for Bound<'py, PyAny> {
     }
 
     #[inline]
+    #[allow(deprecated)]
     fn downcast_into_exact<T>(self) -> Result<Bound<'py, T>, DowncastIntoError<'py>>
     where
         T: PyTypeInfo,
diff --git a/src/types/iterator.rs b/src/types/iterator.rs
index 8900a62a077..7ee15531a2b 100644
--- a/src/types/iterator.rs
+++ b/src/types/iterator.rs
@@ -354,7 +354,7 @@ def fibonacci(target):
 
             assert_eq!(
                 downcaster.borrow_mut(py).failed.take().unwrap().to_string(),
-                "TypeError: 'MySequence' object cannot be converted to 'Iterator'"
+                "TypeError: 'MySequence' object cannot be cast as 'Iterator'"
             );
         });
     }
diff --git a/src/types/weakref/anyref.rs b/src/types/weakref/anyref.rs
index 4c5772f98f2..8567922419a 100644
--- a/src/types/weakref/anyref.rs
+++ b/src/types/weakref/anyref.rs
@@ -535,7 +535,7 @@ mod tests {
                         .cast_into::<PyWeakref>()
                         .unwrap_err()
                         .to_string(),
-                    "'int' object cannot be converted to 'ProxyType | CallableProxyType | ReferenceType'"
+                    "'int' object cannot be cast as 'ProxyType | CallableProxyType | ReferenceType'"
                 );
                 Ok(())
             })
diff --git a/src/types/weakref/proxy.rs b/src/types/weakref/proxy.rs
index 6f2bc1d57ac..90f682ab1ad 100644
--- a/src/types/weakref/proxy.rs
+++ b/src/types/weakref/proxy.rs
@@ -443,7 +443,7 @@ mod tests {
                             .cast_into::<PyWeakrefProxy>()
                             .unwrap_err()
                             .to_string(),
-                        "'int' object cannot be converted to 'ProxyType | CallableProxyType'"
+                        "'int' object cannot be cast as 'ProxyType | CallableProxyType'"
                     );
                     Ok(())
                 })
diff --git a/tests/test_frompyobject.rs b/tests/test_frompyobject.rs
index cece183abb0..e0353221db9 100644
--- a/tests/test_frompyobject.rs
+++ b/tests/test_frompyobject.rs
@@ -295,9 +295,9 @@ fn test_transparent_struct_error_message() {
         let tup = tup.extract::<B>();
         assert!(tup.is_err());
         assert_eq!(
-            extract_traceback(py,tup.unwrap_err()),
-            "TypeError: failed to extract field B.test: TypeError: \'int\' object cannot be converted \
-         to \'str\'"
+            extract_traceback(py, tup.unwrap_err()),
+            "TypeError: failed to extract field B.test: TypeError: \'int\' object cannot be cast \
+         as \'str\'"
         );
     });
 }
@@ -310,8 +310,8 @@ fn test_tuple_struct_error_message() {
         assert!(tup.is_err());
         assert_eq!(
             extract_traceback(py, tup.unwrap_err()),
-            "TypeError: failed to extract field Tuple.0: TypeError: \'int\' object cannot be \
-         converted to \'str\'"
+            "TypeError: failed to extract field Tuple.0: TypeError: \'int\' object cannot be cast \
+         as \'str\'"
         );
     });
 }
@@ -325,7 +325,7 @@ fn test_transparent_tuple_error_message() {
         assert_eq!(
             extract_traceback(py, tup.unwrap_err()),
             "TypeError: failed to extract field TransparentTuple.0: TypeError: 'int' object \
-         cannot be converted to 'str'",
+         cannot be cast as 'str'",
         );
     });
 }
@@ -540,10 +540,10 @@ fn test_enum_error() {
             err.to_string(),
             "\
 TypeError: failed to extract enum Foo ('TupleVar | StructVar | TransparentTuple | TransparentStructVar | StructVarGetAttrArg | StructWithGetItem | StructWithGetItemArg')
-- variant TupleVar (TupleVar): TypeError: 'dict' object cannot be converted to 'tuple'
+- variant TupleVar (TupleVar): TypeError: 'dict' object cannot be cast as 'tuple'
 - variant StructVar (StructVar): AttributeError: 'dict' object has no attribute 'test'
 - variant TransparentTuple (TransparentTuple): TypeError: failed to extract field Foo::TransparentTuple.0, caused by TypeError: 'dict' object cannot be interpreted as an integer
-- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'dict' object cannot be converted to 'str'
+- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'dict' object cannot be cast as 'str'
 - variant StructVarGetAttrArg (StructVarGetAttrArg): AttributeError: 'dict' object has no attribute 'bla'
 - variant StructWithGetItem (StructWithGetItem): KeyError: 'a'
 - variant StructWithGetItemArg (StructWithGetItemArg): KeyError: 'foo'"
@@ -558,7 +558,7 @@ TypeError: failed to extract enum Foo ('TupleVar | StructVar | TransparentTuple
 - variant TupleVar (TupleVar): ValueError: expected tuple of length 2, but got tuple of length 0
 - variant StructVar (StructVar): AttributeError: 'tuple' object has no attribute 'test'
 - variant TransparentTuple (TransparentTuple): TypeError: failed to extract field Foo::TransparentTuple.0, caused by TypeError: 'tuple' object cannot be interpreted as an integer
-- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'tuple' object cannot be converted to 'str'
+- variant TransparentStructVar (TransparentStructVar): TypeError: failed to extract field Foo::TransparentStructVar.a, caused by TypeError: 'tuple' object cannot be cast as 'str'
 - variant StructVarGetAttrArg (StructVarGetAttrArg): AttributeError: 'tuple' object has no attribute 'bla'
 - variant StructWithGetItem (StructWithGetItem): TypeError: tuple indices must be integers or slices, not str
 - variant StructWithGetItemArg (StructWithGetItemArg): TypeError: tuple indices must be integers or slices, not str"
@@ -612,7 +612,7 @@ fn test_err_rename() {
             f.unwrap_err().to_string(),
             "\
 TypeError: failed to extract enum Bar ('str | uint | int')
-- variant A (str): TypeError: failed to extract field Bar::A.0, caused by TypeError: 'dict' object cannot be converted to 'str'
+- variant A (str): TypeError: failed to extract field Bar::A.0, caused by TypeError: 'dict' object cannot be cast as 'str'
 - variant B (uint): TypeError: failed to extract field Bar::B.0, caused by TypeError: 'dict' object cannot be interpreted as an integer
 - variant C (int): TypeError: failed to extract field Bar::C.0, caused by TypeError: 'dict' object cannot be interpreted as an integer"
         );
diff --git a/tests/test_pyerr_debug_unformattable.rs b/tests/test_pyerr_debug_unformattable.rs
index 2c4b7ad3fac..9bb481ffec8 100644
--- a/tests/test_pyerr_debug_unformattable.rs
+++ b/tests/test_pyerr_debug_unformattable.rs
@@ -17,7 +17,7 @@ fn err_debug_unformattable() {
     Python::attach(|py| {
         // PyTracebackMethods::format uses io.StringIO. Mock it out to trigger a
         // formatting failure:
-        // TypeError: 'Mock' object cannot be converted to 'str'
+        // TypeError: 'Mock' object cannot be cast as 'str'
         let err = py
             .run(
                 ffi::c_str!(
diff --git a/tests/test_pyfunction.rs b/tests/test_pyfunction.rs
index 57d987c8aee..eb4e02dae04 100644
--- a/tests/test_pyfunction.rs
+++ b/tests/test_pyfunction.rs
@@ -221,7 +221,7 @@ fn test_function_with_custom_conversion_error() {
             custom_conv_func,
             "custom_conv_func(['a'])",
             PyTypeError,
-            "argument 'timestamp': 'list' object cannot be converted to 'datetime'"
+            "argument 'timestamp': 'list' object cannot be cast as 'datetime'"
         );
     });
 }
@@ -293,14 +293,14 @@ fn test_conversion_error() {
             conversion_error,
             "conversion_error(None, None, None, None, None)",
             PyTypeError,
-            "argument 'str_arg': 'NoneType' object cannot be converted to 'str'"
+            "argument 'str_arg': 'NoneType' object cannot be cast as 'str'"
         );
         py_expect_exception!(
             py,
             conversion_error,
             "conversion_error(100, None, None, None, None)",
             PyTypeError,
-            "argument 'str_arg': 'int' object cannot be converted to 'str'"
+            "argument 'str_arg': 'int' object cannot be cast as 'str'"
         );
         py_expect_exception!(
             py,
@@ -314,7 +314,7 @@ fn test_conversion_error() {
             conversion_error,
             "conversion_error('string1', -100, 'string2', None, None)",
             PyTypeError,
-            "argument 'tuple_arg': 'str' object cannot be converted to 'tuple'"
+            "argument 'tuple_arg': 'str' object cannot be cast as 'tuple'"
         );
         py_expect_exception!(
             py,