diff --git a/Cargo.lock b/Cargo.lock
index b74074c8d..667d15b1b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -148,32 +148,19 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.0.6"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87db066a99f69382be06d02313f8ce989996b53a04a8a70cfd1a6483a56227f7"
+checksum = "c2a1b6e316923afd3087ec73829f646a67c18f3a5bd61624247b05e652e4a99d"
 dependencies = [
  "ahash",
  "hashbrown",
- "lexical-core",
+ "lexical-parse-float",
  "num-bigint",
  "num-traits",
  "pyo3",
  "smallvec",
 ]
 
-[[package]]
-name = "lexical-core"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cde5de06e8d4c2faabc400238f9ae1c74d5412d03a7bd067645ccbc47070e46"
-dependencies = [
- "lexical-parse-float",
- "lexical-parse-integer",
- "lexical-util",
- "lexical-write-float",
- "lexical-write-integer",
-]
-
 [[package]]
 name = "lexical-parse-float"
 version = "0.8.5"
@@ -204,27 +191,6 @@ dependencies = [
  "static_assertions",
 ]
 
-[[package]]
-name = "lexical-write-float"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accabaa1c4581f05a3923d1b4cfd124c329352288b7b9da09e766b0668116862"
-dependencies = [
- "lexical-util",
- "lexical-write-integer",
- "static_assertions",
-]
-
-[[package]]
-name = "lexical-write-integer"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b6f3d1f4422866b68192d62f77bc5c700bee84f3069f2469d7bc8c77852446"
-dependencies = [
- "lexical-util",
- "static_assertions",
-]
-
 [[package]]
 name = "libc"
 version = "0.2.147"
@@ -363,9 +329,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53bdbb96d49157e65d45cc287af5f32ffadd5f4761438b527b055fb0d4bb8233"
+checksum = "5d0c41d899f822e5f39186d6da130a822a0a43edb19992b51bf4ef6cd0b4cfd1"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -382,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deaa5745de3f5231ce10517a1f5dd97d53e5a2fd77aa6b5842292085831d48d7"
+checksum = "5509c2aa78c7e770077e41ba86f806e60dcee812e924ccb2d6fe78c0a0128ce2"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -393,9 +359,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b42531d03e08d4ef1f6e85a2ed422eb678b8cd62b762e53891c05faf0d4afa"
+checksum = "e6bb234a86ed619a661f3bb3c2493aaff9cb937e33e198d17f5f20a15881e155"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -403,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7305c720fa01b8055ec95e484a6eca7a83c841267f0dd5280f0c8b8551d2c158"
+checksum = "f0b787de2c6832eb1eb393c9f82f976a5a87bda979780d9b853878846a8d2e4b"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -415,9 +381,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c7e9b68bb9c3149c5b0cade5d07f953d6d125eb4337723c4ccdb665f1f96185"
+checksum = "5e3b7beed357786d2afe845871964e824ad8af0df38a403f7d01cdc81aadb211"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index ea3e3d73c..f74976967 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.70"
 
 [dependencies]
-pyo3 = { version = "0.20.3", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = {version = "0.0.6", features = ["python"]}
+jiter = {version = "0.0.7", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"
@@ -71,12 +71,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.3", features = ["auto-initialize"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.20.2" }
+pyo3-build-config = { version = "0.21.0-beta.0" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/benches/main.rs b/benches/main.rs
index 4b8a2b106..d1ef27a93 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -10,17 +10,17 @@ use pyo3::types::{PyDict, PyString};
 use _pydantic_core::{validate_core_schema, SchemaValidator};
 
 fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&PyDict>) -> SchemaValidator {
-    let mut schema: &PyDict = py.eval(code, globals, None).unwrap().extract().unwrap();
-    schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-    SchemaValidator::py_new(py, schema, None).unwrap()
+    let mut schema = py.eval(code, globals, None).unwrap().extract().unwrap();
+    schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+    SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
 fn build_schema_validator(py: Python, code: &str) -> SchemaValidator {
     build_schema_validator_with_globals(py, code, None)
 }
 
-fn json<'a>(py: Python<'a>, code: &'a str) -> &'a PyAny {
-    black_box(PyString::new(py, code))
+fn json<'a>(py: Python<'a>, code: &'a str) -> Bound<'a, PyAny> {
+    black_box(PyString::new_bound(py, code).into_any())
 }
 
 #[bench]
@@ -28,11 +28,11 @@ fn ints_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
-        let result = validator.validate_json(py, json(py, "123"), None, None, None).unwrap();
+        let result = validator.validate_json(py, &json(py, "123"), None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, "123"), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, "123"), None, None, None).unwrap()))
     })
 }
 
@@ -41,14 +41,13 @@ fn ints_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
-        let input = 123_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = 123_i64.into_py(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -61,7 +60,7 @@ fn list_int_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -80,9 +79,9 @@ fn list_int_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
 fn list_int_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_int_input(py);
-        let input = black_box(input.as_ref(py));
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -92,12 +91,12 @@ fn list_int_python(bench: &mut Bencher) {
 fn list_int_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_int_input(py);
-        let input = black_box(input.as_ref(py));
-        let v = validator.isinstance_python(py, input, None, None, None, None).unwrap();
+        let input = black_box(input.bind(py));
+        let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
         assert!(v);
 
         bench.iter(|| {
-            let v = validator.isinstance_python(py, input, None, None, None, None).unwrap();
+            let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -115,7 +114,7 @@ fn list_error_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        match validator.validate_json(py, json(py, &code), None, None, None) {
+        match validator.validate_json(py, &json(py, &code), None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -127,7 +126,7 @@ fn list_error_json(bench: &mut Bencher) {
         };
 
         bench.iter(
-            || match validator.validate_json(py, json(py, &code), None, None, None) {
+            || match validator.validate_json(py, &json(py, &code), None, None, None) {
                 Ok(_) => panic!("unexpectedly valid"),
                 Err(e) => black_box(e),
             },
@@ -145,9 +144,9 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
             .join(", ")
     );
 
-    let input = py.eval(&code, None, None).unwrap();
+    let input = py.eval(&code, None, None).unwrap().extract().unwrap();
 
-    match validator.validate_python(py, input, None, None, None, None) {
+    match validator.validate_python(py, &input, None, None, None, None) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value(py);
@@ -165,9 +164,9 @@ fn list_error_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_error_python_input(py);
 
-        let input = black_box(input.as_ref(py));
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -181,14 +180,12 @@ fn list_error_python(bench: &mut Bencher) {
 fn list_error_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_error_python_input(py);
-        let r = validator
-            .isinstance_python(py, black_box(input.as_ref(py)), None, None, None, None)
-            .unwrap();
+        let input = black_box(input.bind(py));
+        let r = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
         assert!(!r);
 
-        let input = black_box(input.as_ref(py));
         bench.iter(|| {
-            black_box(validator.isinstance_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.isinstance_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -202,7 +199,7 @@ fn list_any_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -214,10 +211,10 @@ fn list_any_python(bench: &mut Bencher) {
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -247,7 +244,7 @@ fn dict_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -266,10 +263,10 @@ fn dict_python(bench: &mut Bencher) {
                 .collect::<Vec<String>>()
                 .join(", ")
         );
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -295,9 +292,9 @@ fn dict_value_error(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        let input = py.eval(&code, None, None).unwrap();
+        let input = py.eval(&code, None, None).unwrap().to_object(py).into_bound(py);
 
-        match validator.validate_python(py, input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -310,7 +307,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = black_box(input);
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -345,7 +342,7 @@ fn typed_dict_json(bench: &mut Bencher) {
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -373,10 +370,10 @@ fn typed_dict_python(bench: &mut Bencher) {
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -413,10 +410,10 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 
         let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
 
-        let input = py.eval(code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
 
-        match validator.validate_python(py, input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -428,7 +425,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         };
 
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -444,16 +441,16 @@ fn complete_model(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("complete_schema").unwrap();
+        let complete_schema = py.import_bound("complete_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_lax").unwrap();
         let input = black_box(input);
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -464,18 +461,18 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("nested_schema").unwrap();
+        let complete_schema = py.import_bound("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema_using_defs").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, input, None, None, None, None).unwrap();
+        validator.validate_python(py, &input, None, None, None, None).unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -486,18 +483,18 @@ fn nested_model_inlined(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("nested_schema").unwrap();
+        let complete_schema = py.import_bound("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("inlined_schema").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, input, None, None, None, None).unwrap();
+        validator.validate_python(py, &input, None, None, None, None).unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -508,13 +505,13 @@ fn literal_ints_few_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(5))}");
 
         let input = 4_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = input.bind(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 4);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -524,13 +521,14 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(5)]}");
 
         let input = py.eval("'4'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -543,20 +541,21 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '4'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
 #[bench]
 fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new(py);
+        let globals = PyDict::new_bound(py);
         py.run(
             r#"
 from enum import Enum
@@ -567,7 +566,7 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals),
+            Some(globals.as_gil_ref()),
             None,
         )
         .unwrap();
@@ -575,15 +574,16 @@ class Foo(Enum):
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [Foo.v1, Foo.v2, Foo.v3, Foo.v4]}",
-            Some(globals),
+            Some(globals.as_gil_ref()),
         );
 
-        let input = py.eval("Foo.v4", Some(globals), None).unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+        let input = input.to_object(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         assert!(input.eq(result).unwrap());
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -592,14 +592,13 @@ fn literal_ints_many_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
-        let input = 99_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = 99_i64.into_py(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -609,13 +608,14 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(100)]}");
 
         let input = py.eval("'99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -628,13 +628,14 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -644,12 +645,13 @@ fn literal_ints_many_json(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
         let input_json = py.eval("'99'", None, None).unwrap();
-        let result = validator.validate_json(py, input_json, None, None, None).unwrap();
+        let input_json = input_json.to_object(py).into_bound(py);
+        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, input_json, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
     })
 }
 
@@ -662,21 +664,23 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_json = py.eval("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
+        let input_json = input_json.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_json(py, input_json, None, None, None).unwrap();
+        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, input_json, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
     })
 }
 
 #[bench]
 fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new(py);
+        let globals = PyDict::new_bound(py);
         py.run(
             r#"
 from enum import Enum
@@ -687,58 +691,62 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals),
+            Some(globals.as_gil_ref()),
             None,
         )
         .unwrap();
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [None, 'null', -1, Foo.v4]}",
-            Some(globals),
+            Some(globals.as_gil_ref()),
         );
 
         // String
         {
             let input = py.eval("'null'", None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
             let input_str: String = input.extract().unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             let result_str: String = result.extract(py).unwrap();
             assert_eq!(result_str, input_str);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // Int
         {
             let input = py.eval("-1", None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
             let input_int: i64 = input.extract().unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             let result_int: i64 = result.extract(py).unwrap();
             assert_eq!(result_int, input_int);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // None
         {
             let input = py.eval("None", None, None).unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // Enum
         {
-            let input = py.eval("Foo.v4", Some(globals), None).unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+            let input = input.to_object(py).into_bound(py);
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
     })
 }
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 3e73fb629..748dd0ae2 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -15,9 +15,9 @@ pub struct ArgsKwargs {
 
 impl ArgsKwargs {
     fn eq(&self, py: Python, other: &Self) -> PyResult<bool> {
-        if self.args.as_ref(py).eq(other.args.as_ref(py))? {
+        if self.args.bind(py).eq(other.args.bind(py))? {
             match (&self.kwargs, &other.kwargs) {
-                (Some(d1), Some(d2)) => d1.as_ref(py).eq(d2.as_ref(py)),
+                (Some(d1), Some(d2)) => d1.bind(py).eq(d2.bind(py)),
                 (None, None) => Ok(true),
                 _ => Ok(false),
             }
@@ -55,9 +55,9 @@ impl ArgsKwargs {
     }
 
     pub fn __repr__(&self, py: Python) -> String {
-        let args = safe_repr(self.args.as_ref(py));
+        let args = safe_repr(self.args.bind(py));
         match self.kwargs {
-            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.as_ref(py))),
+            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.bind(py))),
             None => format!("ArgsKwargs({args})"),
         }
     }
diff --git a/src/build_tools.rs b/src/build_tools.rs
index c242f97a3..23c88970b 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -12,10 +12,10 @@ use crate::tools::SchemaDict;
 use crate::ValidationError;
 
 pub fn schema_or_config<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
-    schema_key: &PyString,
-    config_key: &PyString,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
+    schema_key: &Bound<'py, PyString>,
+    config_key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,
@@ -30,9 +30,9 @@ where
 }
 
 pub fn schema_or_config_same<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
-    key: &PyString,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
+    key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,
@@ -40,7 +40,7 @@ where
     schema_or_config(schema, config, key, key)
 }
 
-pub fn is_strict(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+pub fn is_strict(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     Ok(schema_or_config_same(schema, config, intern!(py, "strict"))?.unwrap_or(false))
 }
@@ -90,7 +90,7 @@ impl SchemaError {
                     ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
-                    Ok(err) => PyErr::from_value(err.into_ref(py)),
+                    Ok(err) => PyErr::from_value_bound(err.into_bound(py).into_any()),
                     Err(err) => err,
                 }
             }
@@ -124,7 +124,7 @@ impl SchemaError {
 
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
-            SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).into_py(py)),
+            SchemaErrorEnum::Message(_) => Ok(PyList::empty_bound(py).unbind()),
             SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false, true),
         }
     }
@@ -174,18 +174,18 @@ pub(crate) enum ExtraBehavior {
 impl ExtraBehavior {
     pub fn from_schema_or_config(
         py: Python,
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         default: Self,
     ) -> PyResult<Self> {
-        let extra_behavior = schema_or_config::<Option<&str>>(
+        let extra_behavior = schema_or_config::<Option<Bound<'_, PyString>>>(
             schema,
             config,
             intern!(py, "extra_behavior"),
             intern!(py, "extra_fields_behavior"),
         )?
         .flatten();
-        let res = match extra_behavior {
+        let res = match extra_behavior.as_ref().map(|s| s.to_str()).transpose()? {
             Some("allow") => Self::Allow,
             Some("ignore") => Self::Ignore,
             Some("forbid") => Self::Forbid,
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index 2a48bfaf4..ecd429409 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::PyDowncastError;
+use pyo3::DowncastError;
+use pyo3::DowncastIntoError;
 
 use jiter::JsonValue;
 
@@ -35,8 +36,14 @@ impl From<PyErr> for ValError {
     }
 }
 
-impl From<PyDowncastError<'_>> for ValError {
-    fn from(py_downcast: PyDowncastError) -> Self {
+impl From<DowncastError<'_, '_>> for ValError {
+    fn from(py_downcast: DowncastError) -> Self {
+        Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
+    }
+}
+
+impl From<DowncastIntoError<'_>> for ValError {
+    fn from(py_downcast: DowncastIntoError) -> Self {
         Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
     }
 }
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 55bab0017..138d327ce 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -1,5 +1,5 @@
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
+use pyo3::sync::GILOnceCell;
 use std::fmt;
 
 use pyo3::prelude::*;
@@ -126,9 +126,9 @@ static EMPTY_TUPLE: GILOnceCell<PyObject> = GILOnceCell::new();
 impl ToPyObject for Location {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         match self {
-            Self::List(loc) => PyTuple::new(py, loc.iter().rev()).to_object(py),
+            Self::List(loc) => PyTuple::new_bound(py, loc.iter().rev()).to_object(py),
             Self::Empty => EMPTY_TUPLE
-                .get_or_init(py, || PyTuple::empty(py).to_object(py))
+                .get_or_init(py, || PyTuple::empty_bound(py).to_object(py))
                 .clone_ref(py),
         }
     }
@@ -193,12 +193,12 @@ impl Serialize for Location {
     }
 }
 
-impl TryFrom<Option<&PyAny>> for Location {
+impl TryFrom<Option<&Bound<'_, PyAny>>> for Location {
     type Error = PyErr;
 
     /// Only ever called by ValidationError -> PyLineError to convert user input to our internal Location
     /// Thus this expects the location to *not* be reversed and reverses it before storing it.
-    fn try_from(location: Option<&PyAny>) -> PyResult<Self> {
+    fn try_from(location: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
         if let Some(location) = location {
             let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.downcast::<PyTuple>() {
                 tuple.iter().map(Into::into).collect()
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index de6650527..bee5f7225 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -13,8 +13,8 @@ pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
-    let value = err.value(py);
-    match value.get_type().name() {
+    let value = err.value_bound(py);
+    match value.get_type().qualname() {
         Ok(type_name) => match value.str() {
             Ok(py_str) => {
                 let str_cow = py_str.to_string_lossy();
diff --git a/src/errors/types.rs b/src/errors/types.rs
index eddd7dbaa..a77ed6a8e 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -3,8 +3,8 @@ use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError};
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList};
 
 use ahash::AHashMap;
@@ -18,11 +18,11 @@ use crate::tools::{extract_i64, py_err, py_error_type};
 use super::PydanticCustomError;
 
 #[pyfunction]
-pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
-    let mut errors: Vec<&PyDict> = Vec::with_capacity(100);
+pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
+    let mut errors: Vec<Bound<'_, PyDict>> = Vec::with_capacity(100);
     for error_type in ErrorType::iter() {
         if !matches!(error_type, ErrorType::CustomError { .. }) {
-            let d = PyDict::new(py);
+            let d = PyDict::new_bound(py);
             d.set_item("type", error_type.to_string())?;
             let message_template_python = error_type.message_template_python();
             d.set_item("message_template_python", message_template_python)?;
@@ -39,7 +39,7 @@ pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
             errors.push(d);
         }
     }
-    Ok(PyList::new(py, errors))
+    Ok(PyList::new_bound(py, errors))
 }
 
 fn field_from_context<'py, T: FromPyObject<'py>>(
@@ -121,7 +121,8 @@ macro_rules! error_types {
                 }
             }
 
-            fn py_dict_update_ctx(&self, py: Python, dict: &PyDict) -> PyResult<bool> {
+            fn py_dict_update_ctx(&self, py: Python, dict: &Bound<'_, PyDict>) -> PyResult<bool> {
+                use pyo3::types::PyMapping;
                 match self {
                     $(
                         Self::$item { context, $($key,)* } => {
@@ -129,7 +130,7 @@ macro_rules! error_types {
                                 dict.set_item::<&str, Py<PyAny>>(stringify!($key), $key.to_object(py))?;
                             )*
                             if let Some(ctx) = context {
-                                dict.update(ctx.as_ref(py).downcast()?)?;
+                                dict.update(ctx.bind(py).downcast::<PyMapping>()?)?;
                                 Ok(true)
                             } else {
                                 Ok(false)
@@ -669,20 +670,20 @@ impl ErrorType {
             Self::ValueError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::AssertionError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::CustomError {
                 message_template,
                 context,
                 ..
-            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.as_ref(py))),
+            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.bind(py))),
             Self::LiteralError { expected, .. } => render!(tmpl, expected),
             Self::DateParsing { error, .. } => render!(tmpl, error),
             Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
@@ -729,8 +730,8 @@ impl ErrorType {
     }
 
     pub fn py_dict(&self, py: Python) -> PyResult<Option<Py<PyDict>>> {
-        let dict = PyDict::new(py);
-        let custom_ctx_used = self.py_dict_update_ctx(py, dict)?;
+        let dict = PyDict::new_bound(py);
+        let custom_ctx_used = self.py_dict_update_ctx(py, &dict)?;
 
         if let Self::CustomError { .. } = self {
             if custom_ctx_used {
@@ -785,7 +786,7 @@ impl From<Int> for Number {
 }
 
 impl FromPyObject<'_> for Number {
-    fn extract(obj: &PyAny) -> PyResult<Self> {
+    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Some(int) = extract_i64(obj) {
             Ok(Number::Int(int))
         } else if let Ok(float) = obj.extract::<f64>() {
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index e87f4b0d9..059763a21 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -5,8 +5,8 @@ use std::str::from_utf8;
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
 use pyo3::ffi;
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList, PyString};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
@@ -73,7 +73,7 @@ impl ValidationError {
                                 return cause_problem;
                             }
                         }
-                        PyErr::from_value(err.as_ref(py))
+                        PyErr::from_value_bound(err.into_bound(py).into_any())
                     }
                     Err(err) => err,
                 }
@@ -202,9 +202,9 @@ fn include_url_env(py: Python) -> bool {
         match std::env::var_os("PYDANTIC_ERRORS_OMIT_URL") {
             Some(val) => {
                 // We don't care whether warning succeeded or not, hence the assignment
-                let _ = PyErr::warn(
+                let _ = PyErr::warn_bound(
                     py,
-                    py.get_type::<pyo3::exceptions::PyDeprecationWarning>(),
+                    &py.get_type_bound::<pyo3::exceptions::PyDeprecationWarning>(),
                     "PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead",
                     1,
                 );
@@ -253,14 +253,17 @@ impl ValidationError {
     fn from_exception_data(
         py: Python,
         title: PyObject,
-        line_errors: &PyList,
+        line_errors: Bound<'_, PyList>,
         input_type: &str,
         hide_input: bool,
     ) -> PyResult<Py<Self>> {
         Py::new(
             py,
             Self {
-                line_errors: line_errors.iter().map(PyLineError::try_from).collect::<PyResult<_>>()?,
+                line_errors: line_errors
+                    .iter()
+                    .map(|error| PyLineError::try_from(&error))
+                    .collect::<PyResult<_>>()?,
                 title,
                 input_type: InputType::try_from(input_type)?,
                 hide_input,
@@ -287,7 +290,7 @@ impl ValidationError {
     ) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
         let mut iteration_error = None;
-        let list = PyList::new(
+        let list = PyList::new_bound(
             py,
             // PyList::new takes ExactSizeIterator, so if an error occurs during iteration we
             // fill the list with None before returning the error; the list will then be thrown
@@ -318,7 +321,7 @@ impl ValidationError {
         include_url: bool,
         include_context: bool,
         include_input: bool,
-    ) -> PyResult<&'py PyString> {
+    ) -> PyResult<Bound<'py, PyString>> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
         let extra = state.extra(py, &SerMode::Json, true, false, false, true, None, None);
         let serializer = ValidationErrorSerializer {
@@ -347,7 +350,7 @@ impl ValidationError {
             }
         };
         let s = from_utf8(&bytes).map_err(json_py_err)?;
-        Ok(PyString::new(py, s))
+        Ok(PyString::new_bound(py, s))
     }
 
     fn __repr__(&self, py: Python) -> String {
@@ -358,12 +361,12 @@ impl ValidationError {
         self.__repr__(py)
     }
 
-    fn __reduce__(slf: &PyCell<Self>) -> PyResult<(&PyAny, PyObject)> {
+    fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyAny>, PyObject)> {
         let py = slf.py();
         let callable = slf.getattr("from_exception_data")?;
         let borrow = slf.try_borrow()?;
         let args = (
-            borrow.title.as_ref(py),
+            borrow.title.bind(py),
             borrow.errors(py, include_url_env(py), true, true)?,
             borrow.input_type.into_py(py),
             borrow.hide_input,
@@ -463,11 +466,11 @@ impl From<PyLineError> for ValLineError {
     }
 }
 
-impl TryFrom<&PyAny> for PyLineError {
+impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
     type Error = PyErr;
 
-    fn try_from(value: &PyAny) -> PyResult<Self> {
-        let dict: &PyDict = value.downcast()?;
+    fn try_from(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let dict = value.downcast::<PyDict>()?;
         let py = value.py();
 
         let type_raw = dict
@@ -485,7 +488,7 @@ impl TryFrom<&PyAny> for PyLineError {
             ));
         };
 
-        let location = Location::try_from(dict.get_item("loc")?)?;
+        let location = Location::try_from(dict.get_item("loc")?.as_ref())?;
 
         let input_value = match dict.get_item("input")? {
             Some(i) => i.into_py(py),
@@ -513,7 +516,7 @@ impl PyLineError {
         input_type: InputType,
         include_input: bool,
     ) -> PyResult<PyObject> {
-        let dict = PyDict::new(py);
+        let dict = PyDict::new_bound(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
@@ -555,11 +558,11 @@ impl PyLineError {
         write!(output, "  {message} [type={}", self.error_type.type_string())?;
 
         if !hide_input {
-            let input_value = self.input_value.as_ref(py);
+            let input_value = self.input_value.bind(py);
             let input_str = safe_repr(input_value);
-            truncate_input_value!(output, &input_str);
+            truncate_input_value!(output, &input_str.to_cow());
 
-            if let Ok(type_) = input_value.get_type().name() {
+            if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
             }
         }
@@ -663,13 +666,13 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
         if self.include_input {
             map.serialize_entry(
                 "input",
-                &self.extra.serialize_infer(self.line_error.input_value.as_ref(py)),
+                &self.extra.serialize_infer(self.line_error.input_value.bind(py)),
             )?;
         }
 
         if self.include_context {
             if let Some(context) = self.line_error.error_type.py_dict(py).map_err(py_err_json::<S>)? {
-                map.serialize_entry("ctx", &self.extra.serialize_infer(context.as_ref(py)))?;
+                map.serialize_entry("ctx", &self.extra.serialize_infer(context.bind(py)))?;
             }
         }
         if let Some(url_prefix) = self.url_prefix {
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 3152044d1..e69fc0a9c 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -89,7 +89,7 @@ impl PydanticCustomError {
     }
 
     pub fn message(&self, py: Python) -> PyResult<String> {
-        Self::format_message(&self.message_template, self.context.as_ref().map(|c| c.as_ref(py)))
+        Self::format_message(&self.message_template, self.context.as_ref().map(|c| c.bind(py)))
     }
 
     fn __str__(&self, py: Python) -> PyResult<String> {
@@ -99,7 +99,7 @@ impl PydanticCustomError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match self.context.as_ref() {
-            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type, ctx.as_ref(py))),
+            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type, ctx.bind(py))),
             None => Ok(format!("{msg} [type={}, context=None]", self.error_type)),
         }
     }
@@ -115,14 +115,14 @@ impl PydanticCustomError {
         ValError::new(error_type, input)
     }
 
-    pub fn format_message(message_template: &str, context: Option<&PyDict>) -> PyResult<String> {
+    pub fn format_message(message_template: &str, context: Option<&Bound<'_, PyDict>>) -> PyResult<String> {
         let mut message = message_template.to_string();
         if let Some(ctx) = context {
-            for (key, value) in ctx {
-                let key: &PyString = key.downcast()?;
+            for (key, value) in ctx.iter() {
+                let key = key.downcast::<PyString>()?;
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), py_str.to_str()?);
-                } else if let Some(value_int) = extract_i64(value) {
+                } else if let Some(value_int) = extract_i64(&value) {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), &value_int.to_string());
                 } else {
                     // fallback for anything else just in case
@@ -174,11 +174,7 @@ impl PydanticKnownError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match self.context(py)?.as_ref() {
-            Some(ctx) => Ok(format!(
-                "{msg} [type={}, context={}]",
-                self.error_type(),
-                ctx.as_ref(py)
-            )),
+            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type(), ctx.bind(py))),
             None => Ok(format!("{msg} [type={}, context=None]", self.error_type())),
         }
     }
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index ebb5675f2..9dcf9006e 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -20,7 +20,7 @@ use crate::tools::py_err;
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDate<'a> {
     Raw(Date),
-    Py(&'a PyDate),
+    Py(Bound<'a, PyDate>),
 }
 
 impl<'a> From<Date> for EitherDate<'a> {
@@ -29,13 +29,13 @@ impl<'a> From<Date> for EitherDate<'a> {
     }
 }
 
-impl<'a> From<&'a PyDate> for EitherDate<'a> {
-    fn from(date: &'a PyDate) -> Self {
+impl<'a> From<Bound<'a, PyDate>> for EitherDate<'a> {
+    fn from(date: Bound<'a, PyDate>) -> Self {
         Self::Py(date)
     }
 }
 
-pub fn pydate_as_date(py_date: &PyAny) -> PyResult<Date> {
+pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     let py = py_date.py();
     Ok(Date {
         year: py_date.getattr(intern!(py, "year"))?.extract()?,
@@ -55,7 +55,7 @@ impl<'a> EitherDate<'a> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let date = match self {
             Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
+            Self::Raw(date) => PyDate::new_bound(py, date.year.into(), date.month, date.day),
         }?;
         Ok(date.into_py(py))
     }
@@ -64,7 +64,7 @@ impl<'a> EitherDate<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTime<'a> {
     Raw(Time),
-    Py(&'a PyTime),
+    Py(Bound<'a, PyTime>),
 }
 
 impl<'a> From<Time> for EitherTime<'a> {
@@ -73,8 +73,8 @@ impl<'a> From<Time> for EitherTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyTime> for EitherTime<'a> {
-    fn from(time: &'a PyTime) -> Self {
+impl<'a> From<Bound<'a, PyTime>> for EitherTime<'a> {
+    fn from(time: Bound<'a, PyTime>) -> Self {
         Self::Py(time)
     }
 }
@@ -82,8 +82,8 @@ impl<'a> From<&'a PyTime> for EitherTime<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTimedelta<'a> {
     Raw(Duration),
-    PyExact(&'a PyDelta),
-    PySubclass(&'a PyDelta),
+    PyExact(Bound<'a, PyDelta>),
+    PySubclass(Bound<'a, PyDelta>),
 }
 
 impl<'a> From<Duration> for EitherTimedelta<'a> {
@@ -101,29 +101,29 @@ impl<'a> EitherTimedelta<'a> {
         }
     }
 
-    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<&'a PyDelta> {
+    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<Bound<'a, PyDelta>> {
         match self {
-            Self::PyExact(timedelta) => Ok(*timedelta),
-            Self::PySubclass(timedelta) => Ok(*timedelta),
+            Self::PyExact(timedelta) => Ok(timedelta.clone()),
+            Self::PySubclass(timedelta) => Ok(timedelta.clone()),
             Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
 }
 
-impl<'a> TryFrom<&'a PyAny> for EitherTimedelta<'a> {
+impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {
     type Error = PyErr;
 
-    fn try_from(value: &'a PyAny) -> PyResult<Self> {
-        if let Ok(dt) = <PyDelta as PyTryFrom>::try_from_exact(value) {
-            Ok(EitherTimedelta::PyExact(dt))
+    fn try_from(value: &Bound<'a, PyAny>) -> PyResult<Self> {
+        if let Ok(dt) = value.downcast_exact() {
+            Ok(EitherTimedelta::PyExact(dt.clone()))
         } else {
-            let dt = value.downcast::<PyDelta>()?;
-            Ok(EitherTimedelta::PySubclass(dt))
+            let dt = value.downcast()?;
+            Ok(EitherTimedelta::PySubclass(dt.clone()))
         }
     }
 }
 
-pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
+pub fn pytimedelta_exact_as_duration(py_timedelta: &Bound<'_, PyDelta>) -> Duration {
     // see https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_DAYS
     // days can be negative, but seconds and microseconds are always positive.
     let mut days = py_timedelta.get_days(); // -999999999 to 999999999
@@ -146,7 +146,7 @@ pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
     Duration::new(positive, days as u32, seconds as u32, microseconds as u32).unwrap()
 }
 
-pub fn pytimedelta_subclass_as_duration(py_timedelta: &PyDelta) -> PyResult<Duration> {
+pub fn pytimedelta_subclass_as_duration(py_timedelta: &Bound<'_, PyDelta>) -> PyResult<Duration> {
     let total_seconds: f64 = py_timedelta
         .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
         .extract()?;
@@ -162,9 +162,9 @@ pub fn pytimedelta_subclass_as_duration(py_timedelta: &PyDelta) -> PyResult<Dura
         .map_err(|err| PyValueError::new_err(err.to_string()))
 }
 
-pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyResult<&'py PyDelta> {
+pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyResult<Bound<'py, PyDelta>> {
     let sign = if duration.positive { 1 } else { -1 };
-    PyDelta::new(
+    PyDelta::new_bound(
         py,
         sign * duration.day as i32,
         sign * duration.second as i32,
@@ -173,16 +173,16 @@ pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyR
     )
 }
 
-pub fn pytime_as_time(py_time: &PyAny, py_dt: Option<&PyAny>) -> PyResult<Time> {
+pub fn pytime_as_time(py_time: &Bound<'_, PyAny>, py_dt: Option<&Bound<'_, PyAny>>) -> PyResult<Time> {
     let py = py_time.py();
 
     let tzinfo = py_time.getattr(intern!(py, "tzinfo"))?;
-    let tz_offset: Option<i32> = if tzinfo.is_none() {
+    let tz_offset: Option<i32> = if PyAnyMethods::is_none(&tzinfo) {
         None
     } else {
         let offset_delta = tzinfo.call_method1(intern!(py, "utcoffset"), (py_dt,))?;
         // as per the docs, utcoffset() can return None
-        if offset_delta.is_none() {
+        if PyAnyMethods::is_none(&offset_delta) {
             None
         } else {
             let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
@@ -210,25 +210,24 @@ impl<'a> EitherTime<'a> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let time = match self {
             Self::Py(time) => Ok(time),
-            Self::Raw(time) => PyTime::new(
+            Self::Raw(time) => PyTime::new_bound(
                 py,
                 time.hour,
                 time.minute,
                 time.second,
                 time.microsecond,
-                time_as_tzinfo(py, &time)?,
+                time_as_tzinfo(py, &time)?.as_ref(),
             ),
         }?;
         Ok(time.into_py(py))
     }
 }
 
-fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<&'py PyTzInfo>> {
+fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<Bound<'py, PyTzInfo>>> {
     match time.tz_offset {
         Some(offset) => {
             let tz_info: TzInfo = offset.try_into()?;
-            let py_tz_info = Py::new(py, tz_info)?.to_object(py).into_ref(py);
-            Ok(Some(py_tz_info.extract()?))
+            Ok(Some(Bound::new(py, tz_info)?.into_any().downcast_into()?))
         }
         None => Ok(None),
     }
@@ -237,7 +236,7 @@ fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<&'py PyT
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDateTime<'a> {
     Raw(DateTime),
-    Py(&'a PyDateTime),
+    Py(Bound<'a, PyDateTime>),
 }
 
 impl<'a> From<DateTime> for EitherDateTime<'a> {
@@ -246,13 +245,13 @@ impl<'a> From<DateTime> for EitherDateTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyDateTime> for EitherDateTime<'a> {
-    fn from(dt: &'a PyDateTime) -> Self {
+impl<'a> From<Bound<'a, PyDateTime>> for EitherDateTime<'a> {
+    fn from(dt: Bound<'a, PyDateTime>) -> Self {
         Self::Py(dt)
     }
 }
 
-pub fn pydatetime_as_datetime(py_dt: &PyAny) -> PyResult<DateTime> {
+pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
     Ok(DateTime {
         date: pydate_as_date(py_dt)?,
         time: pytime_as_time(py_dt, Some(py_dt))?,
@@ -269,7 +268,7 @@ impl<'a> EitherDateTime<'a> {
 
     pub fn try_into_py(self, py: Python<'a>) -> PyResult<PyObject> {
         let dt = match self {
-            Self::Raw(datetime) => PyDateTime::new(
+            Self::Raw(datetime) => PyDateTime::new_bound(
                 py,
                 datetime.date.year.into(),
                 datetime.date.month,
@@ -278,9 +277,9 @@ impl<'a> EitherDateTime<'a> {
                 datetime.time.minute,
                 datetime.time.second,
                 datetime.time.microsecond,
-                time_as_tzinfo(py, &datetime.time)?,
+                time_as_tzinfo(py, &datetime.time)?.as_ref(),
             )?,
-            Self::Py(dt) => dt,
+            Self::Py(dt) => dt.clone(),
         };
         Ok(dt.into_py(py))
     }
@@ -391,9 +390,9 @@ pub fn float_as_datetime<'a>(input: &'a impl Input<'a>, timestamp: f64) -> ValRe
     int_as_datetime(input, timestamp.floor() as i64, microseconds.round() as u32)
 }
 
-pub fn date_as_datetime(date: &PyDate) -> PyResult<EitherDateTime> {
+pub fn date_as_datetime<'py>(date: &Bound<'py, PyDate>) -> PyResult<EitherDateTime<'py>> {
     let py = date.py();
-    let dt = PyDateTime::new(
+    let dt = PyDateTime::new_bound(
         py,
         date.getattr(intern!(py, "year"))?.extract()?,
         date.getattr(intern!(py, "month"))?.extract()?,
@@ -516,21 +515,21 @@ impl TzInfo {
         Self::try_from(seconds.trunc() as i32)
     }
 
-    fn utcoffset<'py>(&self, py: Python<'py>, _dt: &PyAny) -> PyResult<&'py PyDelta> {
-        PyDelta::new(py, 0, self.seconds, 0, true)
+    fn utcoffset<'py>(&self, py: Python<'py>, _dt: &Bound<'_, PyAny>) -> PyResult<Bound<'py, PyDelta>> {
+        PyDelta::new_bound(py, 0, self.seconds, 0, true)
     }
 
-    fn tzname(&self, _dt: &PyAny) -> String {
+    fn tzname(&self, _dt: &Bound<'_, PyAny>) -> String {
         self.__str__()
     }
 
-    fn dst(&self, _dt: &PyAny) -> Option<&PyDelta> {
+    fn dst(&self, _dt: &Bound<'_, PyAny>) -> Option<&PyDelta> {
         None
     }
 
-    fn fromutc<'py>(&self, dt: &'py PyDateTime) -> PyResult<&'py PyAny> {
+    fn fromutc<'py>(&self, dt: &Bound<'py, PyDateTime>) -> PyResult<Bound<'py, PyAny>> {
         let py = dt.py();
-        dt.call_method1("__add__", (self.utcoffset(py, py.None().as_ref(py))?,))
+        dt.call_method1("__add__", (self.utcoffset(py, py.None().bind(py))?,))
     }
 
     fn __repr__(&self) -> String {
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 6ce1479f6..249161343 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -22,9 +22,9 @@ pub enum InputType {
 impl IntoPy<PyObject> for InputType {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            Self::Json => intern!(py, "json").into(),
-            Self::Python => intern!(py, "python").into(),
-            Self::String => intern!(py, "string").into(),
+            Self::Json => intern!(py, "json").into_py(py),
+            Self::Python => intern!(py, "python").into_py(py),
+            Self::String => intern!(py, "string").into_py(py),
         }
     }
 }
@@ -57,7 +57,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn input_is_instance(&self, _class: &PyType) -> Option<&PyAny> {
+    fn input_is_instance(&self, _class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
         None
     }
 
@@ -65,9 +65,9 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn as_kwargs(&'a self, py: Python<'a>) -> Option<&'a PyDict>;
+    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>>;
 
-    fn input_is_subclass(&self, _class: &PyType) -> PyResult<bool> {
+    fn input_is_subclass(&self, _class: &Bound<'_, PyType>) -> PyResult<bool> {
         Ok(false)
     }
 
@@ -119,16 +119,16 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>>;
 
-    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         if strict {
             self.strict_decimal(py)
         } else {
             self.lax_decimal(py)
         }
     }
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny>;
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         self.strict_decimal(py)
     }
 
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index dde73cf65..6cc21f98c 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -47,10 +47,10 @@ impl<'a> Input<'a> for JsonValue {
         matches!(self, JsonValue::Null)
     }
 
-    fn as_kwargs(&'a self, py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         match self {
             JsonValue::Object(object) => {
-                let dict = PyDict::new(py);
+                let dict = PyDict::new_bound(py);
                 for (k, v) in object.iter() {
                     dict.set_item(k, v.to_object(py)).unwrap();
                 }
@@ -154,12 +154,12 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         match self {
-            JsonValue::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, py),
+            JsonValue::Float(f) => create_decimal(&PyString::new_bound(py, &f.to_string()), self),
 
             JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
-                create_decimal(self.to_object(py).into_ref(py), self, py)
+                create_decimal(self.to_object(py).bind(py), self)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
@@ -327,7 +327,7 @@ impl<'a> Input<'a> for String {
         InputValue::Json(JsonValue::Str(self.clone()))
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         None
     }
 
@@ -377,8 +377,8 @@ impl<'a> Input<'a> for String {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        create_decimal(self.to_object(py).into_ref(py), self, py)
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        create_decimal(self.to_object(py).bind(py), self)
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index fd93820ef..471eb8de7 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 use std::str::from_utf8;
 
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
@@ -8,7 +9,6 @@ use pyo3::types::{
 };
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
-use pyo3::{intern, PyTypeInfo};
 
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
@@ -34,18 +34,18 @@ use super::{
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_keys {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictKeys>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_keys {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_keys_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
@@ -54,18 +54,18 @@ macro_rules! extract_dict_keys {
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_values {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictValues>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_values {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_values_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
@@ -74,26 +74,26 @@ macro_rules! extract_dict_values {
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_items {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictItems>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_items {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_items_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
     };
 }
 
-impl From<&PyAny> for LocItem {
-    fn from(py_any: &PyAny) -> Self {
+impl From<&Bound<'_, PyAny>> for LocItem {
+    fn from(py_any: &Bound<'_, PyAny>) -> Self {
         if let Ok(py_str) = py_any.downcast::<PyString>() {
             py_str.to_string_lossy().as_ref().into()
         } else if let Some(key_int) = extract_i64(py_any) {
@@ -104,15 +104,15 @@ impl From<&PyAny> for LocItem {
     }
 }
 
-impl From<PyAny> for LocItem {
-    fn from(py_any: PyAny) -> Self {
+impl From<Bound<'_, PyAny>> for LocItem {
+    fn from(py_any: Bound<'_, PyAny>) -> Self {
         (&py_any).into()
     }
 }
 
-impl<'a> Input<'a> for PyAny {
+impl<'a> Input<'a> for Bound<'a, PyAny> {
     fn as_error_value(&self) -> InputValue {
-        InputValue::Python(self.into())
+        InputValue::Python(self.clone().into())
     }
 
     fn identity(&self) -> Option<usize> {
@@ -120,10 +120,10 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn is_none(&self) -> bool {
-        self.is_none()
+        PyAnyMethods::is_none(self)
     }
 
-    fn input_is_instance(&self, class: &PyType) -> Option<&PyAny> {
+    fn input_is_instance(&self, class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
         if self.is_instance(class).unwrap_or(false) {
             Some(self)
         } else {
@@ -135,11 +135,11 @@ impl<'a> Input<'a> for PyAny {
         true
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
-        self.downcast::<PyDict>().ok()
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
+        self.downcast::<PyDict>().ok().map(Clone::clone)
     }
 
-    fn input_is_subclass(&self, class: &PyType) -> PyResult<bool> {
+    fn input_is_subclass(&self, class: &Bound<'_, PyType>) -> PyResult<bool> {
         match self.downcast::<PyType>() {
             Ok(py_type) => py_type.is_subclass(class),
             Err(_) => Ok(false),
@@ -160,13 +160,13 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict)).into())
+            Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
-            let args = args_kwargs.args.into_ref(self.py());
-            let kwargs = args_kwargs.kwargs.map(|d| d.into_ref(self.py()));
+            let args = args_kwargs.args.into_bound(self.py());
+            let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
             Ok(PyArgs::new(Some(args), kwargs).into())
         } else if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(PyArgs::new(Some(tuple), None).into())
+            Ok(PyArgs::new(Some(tuple.clone()), None).into())
         } else if let Ok(list) = self.downcast::<PyList>() {
             Ok(PyArgs::new(Some(list.to_tuple()), None).into())
         } else {
@@ -176,10 +176,10 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict)).into())
+            Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
-            let args = args_kwargs.args.into_ref(self.py());
-            let kwargs = args_kwargs.kwargs.map(|d| d.into_ref(self.py()));
+            let args = args_kwargs.args.into_bound(self.py());
+            let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
             Ok(PyArgs::new(Some(args), kwargs).into())
         } else {
             let class_name = class_name.to_string();
@@ -199,7 +199,7 @@ impl<'a> Input<'a> for PyAny {
         coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'a>>> {
         if let Ok(py_str) = self.downcast_exact::<PyString>() {
-            return Ok(ValidationMatch::exact(py_str.into()));
+            return Ok(ValidationMatch::exact(py_str.clone().into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
             // force to a rust string to make sure behavior is consistent whether or not we go via a
             // rust string in StrConstrainedValidator - e.g. to_lower
@@ -219,17 +219,17 @@ impl<'a> Input<'a> for PyAny {
                     match from_utf8(unsafe { py_byte_array.as_bytes() }) {
                         // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
                         // final output needs to be Python anyway.
-                        Ok(s) => Ok(PyString::new(self.py(), s).into()),
+                        Ok(s) => Ok(PyString::new_bound(self.py(), s).into()),
                         Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
                     }
-                } else if coerce_numbers_to_str && !PyBool::is_exact_type_of(self) && {
+                } else if coerce_numbers_to_str && !self.is_exact_instance_of::<PyBool>() && {
                     let py = self.py();
-                    let decimal_type: Py<PyType> = get_decimal_type(py);
+                    let decimal_type = get_decimal_type(py);
 
                     // only allow int, float, and decimal (not bool)
                     self.is_instance_of::<PyInt>()
                         || self.is_instance_of::<PyFloat>()
-                        || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
+                        || self.is_instance(decimal_type).unwrap_or_default()
                 } {
                     Ok(self.str()?.into())
                 } else if let Some(enum_val) = maybe_as_enum(self) {
@@ -293,7 +293,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         if self.is_exact_instance_of::<PyInt>() {
-            return Ok(ValidationMatch::exact(EitherInt::Py(self)));
+            return Ok(ValidationMatch::exact(EitherInt::Py(self.clone())));
         } else if self.is_instance_of::<PyInt>() {
             // bools are a subclass of int, so check for bool type in this specific case
             let exactness = if self.is_instance_of::<PyBool>() {
@@ -316,7 +316,7 @@ impl<'a> Input<'a> for PyAny {
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
                 } else if let Ok(decimal) = self.strict_decimal(self.py()) {
-                    decimal_as_int(self.py(), self, decimal)
+                    decimal_as_int(self, &decimal)
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
                 } else if let Some(enum_val) = maybe_as_enum(self) {
@@ -332,16 +332,16 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
+        if self.is_exact_instance_of::<PyInt>() {
+            Ok(EitherInt::Py(self.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
     }
 
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
-            Ok(EitherString::Py(py_str))
+        if let Ok(py_str) = self.downcast_exact() {
+            Ok(EitherString::Py(py_str.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
@@ -349,7 +349,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         if let Ok(float) = self.downcast_exact::<PyFloat>() {
-            return Ok(ValidationMatch::exact(EitherFloat::Py(float)));
+            return Ok(ValidationMatch::exact(EitherFloat::Py(float.clone())));
         }
 
         if !strict {
@@ -374,44 +374,42 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-        let decimal_type = decimal_type_obj.as_ref(py);
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self);
+            return Ok(self.clone());
         }
 
         // Try subclasses of decimals, they will be upcast to Decimal
         if self.is_instance(decimal_type)? {
-            return create_decimal(self, self, py);
+            return create_decimal(self, self);
         }
 
         Err(ValError::new(
             ErrorType::IsInstanceOf {
-                class: decimal_type.name().unwrap_or("Decimal").to_string(),
+                class: decimal_type.qualname().unwrap_or_else(|_| "Decimal".to_owned()),
                 context: None,
             },
             self,
         ))
     }
 
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-        let decimal_type = decimal_type_obj.as_ref(py);
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self);
+            return Ok(self.clone());
         }
 
         if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>()) {
             // checking isinstance for str / int / bool is fast compared to decimal / float
-            create_decimal(self, self, py)
+            create_decimal(self, self)
         } else if self.is_instance(decimal_type)? {
             // upcast subclasses to decimal
-            return create_decimal(self, self, py);
+            return create_decimal(self, self);
         } else if self.is_instance_of::<PyFloat>() {
-            create_decimal(self.str()?, self, py)
+            create_decimal(self.str()?.as_any(), self)
         } else {
             Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
         }
@@ -419,7 +417,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(dict.clone().into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
@@ -427,9 +425,9 @@ impl<'a> Input<'a> for PyAny {
 
     fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(dict.clone().into())
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {
-            Ok(mapping.into())
+            Ok(mapping.clone().into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
@@ -439,17 +437,17 @@ impl<'a> Input<'a> for PyAny {
         if from_attributes {
             // if from_attributes, first try a dict, then mapping then from_attributes
             if let Ok(dict) = self.downcast::<PyDict>() {
-                return Ok(dict.into());
+                return Ok(dict.clone().into());
             } else if !strict {
                 if let Ok(mapping) = self.downcast::<PyMapping>() {
-                    return Ok(mapping.into());
+                    return Ok(mapping.clone().into());
                 }
             }
 
             if from_attributes_applicable(self) {
-                Ok(self.into())
-            } else if let Ok((obj, kwargs)) = self.extract::<(&PyAny, &PyDict)>() {
-                if from_attributes_applicable(obj) {
+                Ok(self.clone().into())
+            } else if let Ok((obj, kwargs)) = self.extract() {
+                if from_attributes_applicable(&obj) {
                     Ok(GenericMapping::PyGetAttr(obj, Some(kwargs)))
                 } else {
                     Err(ValError::new(ErrorTypeDefaults::ModelAttributesType, self))
@@ -548,15 +546,15 @@ impl<'a> Input<'a> for PyAny {
     fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
         // Handle concrete non-overlapping types first, then abstract types
         if let Ok(iterable) = self.downcast::<PyList>() {
-            Ok(GenericIterable::List(iterable))
+            Ok(GenericIterable::List(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyTuple>() {
-            Ok(GenericIterable::Tuple(iterable))
+            Ok(GenericIterable::Tuple(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PySet>() {
-            Ok(GenericIterable::Set(iterable))
+            Ok(GenericIterable::Set(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyFrozenSet>() {
-            Ok(GenericIterable::FrozenSet(iterable))
+            Ok(GenericIterable::FrozenSet(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyDict>() {
-            Ok(GenericIterable::Dict(iterable))
+            Ok(GenericIterable::Dict(iterable.clone()))
         } else if let Some(iterable) = extract_dict_keys!(self.py(), self) {
             Ok(GenericIterable::DictKeys(iterable))
         } else if let Some(iterable) = extract_dict_values!(self.py(), self) {
@@ -564,15 +562,15 @@ impl<'a> Input<'a> for PyAny {
         } else if let Some(iterable) = extract_dict_items!(self.py(), self) {
             Ok(GenericIterable::DictItems(iterable))
         } else if let Ok(iterable) = self.downcast::<PyMapping>() {
-            Ok(GenericIterable::Mapping(iterable))
+            Ok(GenericIterable::Mapping(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyString>() {
-            Ok(GenericIterable::PyString(iterable))
+            Ok(GenericIterable::PyString(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyBytes>() {
-            Ok(GenericIterable::Bytes(iterable))
+            Ok(GenericIterable::Bytes(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyByteArray>() {
-            Ok(GenericIterable::PyByteArray(iterable))
+            Ok(GenericIterable::PyByteArray(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PySequence>() {
-            Ok(GenericIterable::Sequence(iterable))
+            Ok(GenericIterable::Sequence(iterable.clone()))
         } else if let Ok(iterable) = self.iter() {
             Ok(GenericIterable::Iterator(iterable))
         } else {
@@ -590,13 +588,13 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
         if let Ok(date) = self.downcast_exact::<PyDate>() {
-            Ok(ValidationMatch::exact(date.into()))
-        } else if PyDateTime::is_type_of(self) {
+            Ok(ValidationMatch::exact(date.clone().into()))
+        } else if self.is_instance_of::<PyDateTime>() {
             // have to check if it's a datetime first, otherwise the line below converts to a date
             // even if we later try coercion from a datetime, we don't want to return a datetime now
             Err(ValError::new(ErrorTypeDefaults::DateType, self))
         } else if let Ok(date) = self.downcast::<PyDate>() {
-            Ok(ValidationMatch::strict(date.into()))
+            Ok(ValidationMatch::strict(date.clone().into()))
         } else if let Some(bytes) = {
             if strict {
                 None
@@ -621,9 +619,9 @@ impl<'a> Input<'a> for PyAny {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<ValidationMatch<EitherTime>> {
         if let Ok(time) = self.downcast_exact::<PyTime>() {
-            return Ok(ValidationMatch::exact(time.into()));
+            return Ok(ValidationMatch::exact(time.clone().into()));
         } else if let Ok(time) = self.downcast::<PyTime>() {
-            return Ok(ValidationMatch::strict(time.into()));
+            return Ok(ValidationMatch::strict(time.clone().into()));
         }
 
         'lax: {
@@ -633,7 +631,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_time(self, str.as_bytes(), microseconds_overflow_behavior)
                 } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
                     bytes_as_time(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-                } else if PyBool::is_exact_type_of(self) {
+                } else if self.is_exact_instance_of::<PyBool>() {
                     Err(ValError::new(ErrorTypeDefaults::TimeType, self))
                 } else if let Some(int) = extract_i64(self) {
                     int_as_time(self, int, 0)
@@ -655,9 +653,9 @@ impl<'a> Input<'a> for PyAny {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<ValidationMatch<EitherDateTime>> {
         if let Ok(dt) = self.downcast_exact::<PyDateTime>() {
-            return Ok(ValidationMatch::exact(dt.into()));
+            return Ok(ValidationMatch::exact(dt.clone().into()));
         } else if let Ok(dt) = self.downcast::<PyDateTime>() {
-            return Ok(ValidationMatch::strict(dt.into()));
+            return Ok(ValidationMatch::strict(dt.clone().into()));
         }
 
         'lax: {
@@ -667,7 +665,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_datetime(self, str.as_bytes(), microseconds_overflow_behavior)
                 } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
                     bytes_as_datetime(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-                } else if PyBool::is_exact_type_of(self) {
+                } else if self.is_exact_instance_of::<PyBool>() {
                     Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
                 } else if let Some(int) = extract_i64(self) {
                     int_as_datetime(self, int, 0)
@@ -721,8 +719,15 @@ impl<'a> Input<'a> for PyAny {
     }
 }
 
-impl BorrowInput for &'_ PyAny {
-    type Input<'a> = PyAny where Self: 'a;
+impl BorrowInput for Bound<'_, PyAny> {
+    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
+}
+
+impl BorrowInput for Borrowed<'_, '_, PyAny> {
+    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
     fn borrow_input(&self) -> &Self::Input<'_> {
         self
     }
@@ -730,23 +735,24 @@ impl BorrowInput for &'_ PyAny {
 
 /// Best effort check of whether it's likely to make sense to inspect obj for attributes and iterate over it
 /// with `obj.dir()`
-fn from_attributes_applicable(obj: &PyAny) -> bool {
-    let module_name = match obj.get_type().getattr(intern!(obj.py(), "__module__")) {
-        Ok(module) => match module.extract::<&str>() {
-            Ok(s) => s,
-            Err(_) => return false,
-        },
-        Err(_) => return false,
+fn from_attributes_applicable(obj: &Bound<'_, PyAny>) -> bool {
+    let Some(module_name) = obj
+        .get_type()
+        .getattr(intern!(obj.py(), "__module__"))
+        .ok()
+        .and_then(|module_name| module_name.downcast_into::<PyString>().ok())
+    else {
+        return false;
     };
     // I don't think it's a very good list at all! But it doesn't have to be at perfect, it just needs to avoid
     // the most egregious foot guns, it's mostly just to catch "builtins"
     // still happy to add more or do something completely different if anyone has a better idea???
     // dbg!(obj, module_name);
-    !matches!(module_name, "builtins" | "datetime" | "collections")
+    !matches!(module_name.to_str(), Ok("builtins" | "datetime" | "collections"))
 }
 
 /// Utility for extracting a string from a PyAny, if possible.
-fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<str>>> {
+fn maybe_as_string<'a>(v: &'a Bound<'_, PyAny>, unicode_error: ErrorType) -> ValResult<Option<Cow<'a, str>>> {
     if let Ok(py_string) = v.downcast::<PyString>() {
         let str = py_string_str(py_string)?;
         Ok(Some(Cow::Borrowed(str)))
@@ -761,11 +767,11 @@ fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<
 }
 
 /// Utility for extracting an enum value, if possible.
-fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
+fn maybe_as_enum<'py>(v: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
     let py = v.py();
     let enum_meta_object = get_enum_meta_object(py);
     let meta_type = v.get_type().get_type();
-    if meta_type.is(&enum_meta_object) {
+    if meta_type.is(enum_meta_object) {
         v.getattr(intern!(py, "value")).ok()
     } else {
         None
@@ -773,55 +779,55 @@ fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
 }
 
 #[cfg(PyPy)]
-static DICT_KEYS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_KEYS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_keys_type(v: &PyAny) -> bool {
+fn is_dict_keys_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let keys_type = DICT_KEYS_TYPE
         .get_or_init(py, || {
             py.eval("type({}.keys())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(keys_type).unwrap_or(false)
 }
 
 #[cfg(PyPy)]
-static DICT_VALUES_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_VALUES_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_values_type(v: &PyAny) -> bool {
+fn is_dict_values_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let values_type = DICT_VALUES_TYPE
         .get_or_init(py, || {
             py.eval("type({}.values())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(values_type).unwrap_or(false)
 }
 
 #[cfg(PyPy)]
-static DICT_ITEMS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_ITEMS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_items_type(v: &PyAny) -> bool {
+fn is_dict_items_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let items_type = DICT_ITEMS_TYPE
         .get_or_init(py, || {
             py.eval("type({}.items())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(items_type).unwrap_or(false)
 }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index f6c33d784..6cc0226ac 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -19,8 +19,8 @@ use super::{
 
 #[derive(Debug, Clone)]
 pub enum StringMapping<'py> {
-    String(&'py PyString),
-    Mapping(&'py PyDict),
+    String(Bound<'py, PyString>),
+    Mapping(Bound<'py, PyDict>),
 }
 
 impl<'py> ToPyObject for StringMapping<'py> {
@@ -33,19 +33,19 @@ impl<'py> ToPyObject for StringMapping<'py> {
 }
 
 impl<'py> StringMapping<'py> {
-    pub fn new_key(py_key: &'py PyAny) -> ValResult<StringMapping> {
+    pub fn new_key(py_key: &Bound<'py, PyAny>) -> ValResult<Self> {
         if let Ok(py_str) = py_key.downcast::<PyString>() {
-            Ok(Self::String(py_str))
+            Ok(Self::String(py_str.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, py_key))
         }
     }
 
-    pub fn new_value(py_value: &'py PyAny) -> ValResult<Self> {
+    pub fn new_value(py_value: &Bound<'py, PyAny>) -> ValResult<Self> {
         if let Ok(py_str) = py_value.downcast::<PyString>() {
-            Ok(Self::String(py_str))
+            Ok(Self::String(py_str.clone()))
         } else if let Ok(value) = py_value.downcast::<PyDict>() {
-            Ok(Self::Mapping(value))
+            Ok(Self::Mapping(value.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, py_value))
         }
@@ -56,7 +56,7 @@ impl From<StringMapping<'_>> for LocItem {
     fn from(string_mapping: StringMapping<'_>) -> Self {
         match string_mapping {
             StringMapping::String(s) => s.to_string_lossy().as_ref().into(),
-            StringMapping::Mapping(d) => safe_repr(d).to_string().into(),
+            StringMapping::Mapping(d) => safe_repr(&d).to_string().into(),
         }
     }
 }
@@ -69,7 +69,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         None
     }
 
@@ -81,7 +81,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
     fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
-            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m)),
+            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m.clone())),
         }
     }
 
@@ -91,7 +91,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
         _coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'a>>> {
         match self {
-            Self::String(s) => Ok(ValidationMatch::strict((*s).into())),
+            Self::String(s) => Ok(ValidationMatch::strict(s.clone().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
@@ -124,9 +124,9 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn strict_decimal(&'a self, _py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         match self {
-            Self::String(s) => create_decimal(s, self, py),
+            Self::String(s) => create_decimal(s, self),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
     }
@@ -134,7 +134,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         match self {
             Self::String(_) => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
-            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d)),
+            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d.clone())),
         }
     }
 
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index b323383b7..9e881c10d 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -9,17 +9,15 @@ use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::types::iter::PyDictIterator;
+use pyo3::types::iter::{BoundDictIterator, BoundListIterator};
 use pyo3::types::{
     PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
     PyTuple,
 };
-use pyo3::{ffi, intern, PyNativeType};
+use pyo3::{ffi, intern};
 
 #[cfg(not(PyPy))]
 use pyo3::types::PyFunction;
-#[cfg(not(PyPy))]
-use pyo3::PyTypeInfo;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
@@ -27,7 +25,7 @@ use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::input_string::StringMapping;
-use super::{py_error_on_minusone, Input};
+use super::{py_error_on_minusone, BorrowInput, Input};
 
 pub struct ValidationMatch<T>(T, Exactness);
 
@@ -67,22 +65,22 @@ impl<T> ValidationMatch<T> {
 /// This mostly matches python's definition of `Collection`.
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum GenericIterable<'a> {
-    List(&'a PyList),
-    Tuple(&'a PyTuple),
-    Set(&'a PySet),
-    FrozenSet(&'a PyFrozenSet),
-    Dict(&'a PyDict),
+    List(Bound<'a, PyList>),
+    Tuple(Bound<'a, PyTuple>),
+    Set(Bound<'a, PySet>),
+    FrozenSet(Bound<'a, PyFrozenSet>),
+    Dict(Bound<'a, PyDict>),
     // Treat dict values / keys / items as generic iterators
     // since PyPy doesn't export the concrete types
-    DictKeys(&'a PyIterator),
-    DictValues(&'a PyIterator),
-    DictItems(&'a PyIterator),
-    Mapping(&'a PyMapping),
-    PyString(&'a PyString),
-    Bytes(&'a PyBytes),
-    PyByteArray(&'a PyByteArray),
-    Sequence(&'a PySequence),
-    Iterator(&'a PyIterator),
+    DictKeys(Bound<'a, PyIterator>),
+    DictValues(Bound<'a, PyIterator>),
+    DictItems(Bound<'a, PyIterator>),
+    Mapping(Bound<'a, PyMapping>),
+    PyString(Bound<'a, PyString>),
+    Bytes(Bound<'a, PyBytes>),
+    PyByteArray(Bound<'a, PyByteArray>),
+    Sequence(Bound<'a, PySequence>),
+    Iterator(Bound<'a, PyIterator>),
     JsonArray(&'a [JsonValue]),
     JsonObject(&'a JsonObject),
     JsonString(&'a String),
@@ -92,10 +90,10 @@ impl<'a, 'py: 'a> GenericIterable<'a> {
     pub fn as_sequence_iterator(
         &self,
         py: Python<'py>,
-    ) -> PyResult<Box<dyn Iterator<Item = PyResult<&'a PyAny>> + 'a>> {
+    ) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'a, PyAny>>> + 'a>> {
         match self {
-            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::List(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
+            GenericIterable::Tuple(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
             GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
             GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
             // Note that this iterates over only the keys, just like doing iter({}) in Python
@@ -111,28 +109,18 @@ impl<'a, 'py: 'a> GenericIterable<'a> {
             GenericIterable::Sequence(iter) => Ok(Box::new(iter.iter()?)),
             GenericIterable::Iterator(iter) => Ok(Box::new(iter.iter()?)),
             GenericIterable::JsonArray(iter) => Ok(Box::new(iter.iter().map(move |v| {
-                let v = v.to_object(py);
-                Ok(v.into_ref(py))
+                let v = v.to_object(py).into_bound(py);
+                Ok(v)
             }))),
             // Note that this iterates over only the keys, just like doing iter({}) in Python, just for consistency
             GenericIterable::JsonObject(iter) => Ok(Box::new(
-                iter.iter().map(move |(k, _)| Ok(k.to_object(py).into_ref(py))),
+                iter.iter().map(move |(k, _)| Ok(k.to_object(py).into_bound(py))),
             )),
-            GenericIterable::JsonString(s) => Ok(Box::new(PyString::new(py, s).iter()?)),
+            GenericIterable::JsonString(s) => Ok(Box::new(PyString::new_bound(py, s).iter()?)),
         }
     }
 }
 
-macro_rules! derive_from {
-    ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
-        impl<'a> From<&'a $type> for $enum<'a> {
-            fn from(s: &'a $type) -> $enum<'a> {
-                Self::$key(s $(, $extra_types )*)
-            }
-        }
-    };
-}
-
 #[derive(Debug)]
 struct MaxLengthCheck<'a, INPUT> {
     current_length: usize,
@@ -188,7 +176,7 @@ macro_rules! any_next_error {
 #[allow(clippy::too_many_arguments)]
 fn validate_iter_to_vec<'a, 's>(
     py: Python<'a>,
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     capacity: usize,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
     validator: &'s CombinedValidator,
@@ -198,7 +186,7 @@ fn validate_iter_to_vec<'a, 's>(
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
-        match validator.validate(py, item, state) {
+        match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
                 max_length_check.incr()?;
                 output.push(item);
@@ -225,7 +213,7 @@ pub trait BuildSet {
     fn build_len(&self) -> usize;
 }
 
-impl BuildSet for &PySet {
+impl BuildSet for Bound<'_, PySet> {
     fn build_add(&self, item: PyObject) -> PyResult<()> {
         self.add(item)
     }
@@ -235,7 +223,7 @@ impl BuildSet for &PySet {
     }
 }
 
-impl BuildSet for &PyFrozenSet {
+impl BuildSet for Bound<'_, PyFrozenSet> {
     fn build_add(&self, item: PyObject) -> PyResult<()> {
         py_error_on_minusone(self.py(), unsafe {
             // Safety: self.as_ptr() the _only_ pointer to the `frozenset`, and it's allowed
@@ -252,8 +240,8 @@ impl BuildSet for &PyFrozenSet {
 #[allow(clippy::too_many_arguments)]
 fn validate_iter_to_set<'a, 's>(
     py: Python<'a>,
-    set: impl BuildSet,
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    set: &impl BuildSet,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     input: &'a (impl Input<'a> + 'a),
     field_type: &'static str,
     max_length: Option<usize>,
@@ -263,7 +251,7 @@ fn validate_iter_to_set<'a, 's>(
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
-        match validator.validate(py, item, state) {
+        match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
                 set.build_add(item)?;
                 if let Some(max_length) = max_length {
@@ -301,14 +289,14 @@ fn validate_iter_to_set<'a, 's>(
 fn no_validator_iter_to_vec<'a, 's>(
     py: Python<'a>,
     input: &'a (impl Input<'a> + 'a),
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
 ) -> ValResult<Vec<PyObject>> {
     iter.enumerate()
         .map(|(index, result)| {
             let v = result.map_err(|e| any_next_error!(py, e, input, index))?;
             max_length_check.incr()?;
-            Ok(v.to_object(py))
+            Ok(v.borrow_input().to_object(py))
         })
         .collect()
 }
@@ -375,7 +363,7 @@ impl<'a> GenericIterable<'a> {
     pub fn validate_to_set<'s>(
         &'s self,
         py: Python<'a>,
-        set: impl BuildSet,
+        set: &impl BuildSet,
         input: &'a impl Input<'a>,
         max_length: Option<usize>,
         field_type: &'static str,
@@ -439,30 +427,45 @@ impl<'a> GenericIterable<'a> {
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum GenericMapping<'a> {
-    PyDict(&'a PyDict),
-    PyMapping(&'a PyMapping),
-    StringMapping(&'a PyDict),
-    PyGetAttr(&'a PyAny, Option<&'a PyDict>),
+    PyDict(Bound<'a, PyDict>),
+    PyMapping(Bound<'a, PyMapping>),
+    StringMapping(Bound<'a, PyDict>),
+    PyGetAttr(Bound<'a, PyAny>, Option<Bound<'a, PyDict>>),
     JsonObject(&'a JsonObject),
 }
 
+macro_rules! derive_from {
+    ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
+        impl<'a> From<Bound<'a, $type>> for $enum<'a> {
+            fn from(s: Bound<'a, $type>) -> $enum<'a> {
+                Self::$key(s $(, $extra_types )*)
+            }
+        }
+    };
+}
+
 derive_from!(GenericMapping, PyDict, PyDict);
 derive_from!(GenericMapping, PyMapping, PyMapping);
 derive_from!(GenericMapping, PyGetAttr, PyAny, None);
-derive_from!(GenericMapping, JsonObject, JsonObject);
+
+impl<'a> From<&'a JsonObject> for GenericMapping<'a> {
+    fn from(s: &'a JsonObject) -> GenericMapping<'a> {
+        Self::JsonObject(s)
+    }
+}
 
 pub struct DictGenericIterator<'py> {
-    dict_iter: PyDictIterator<'py>,
+    dict_iter: BoundDictIterator<'py>,
 }
 
 impl<'py> DictGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
+    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
 
 impl<'py> Iterator for DictGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.dict_iter.next().map(Ok)
@@ -471,8 +474,8 @@ impl<'py> Iterator for DictGenericIterator<'py> {
 }
 
 pub struct MappingGenericIterator<'py> {
-    input: &'py PyAny,
-    iter: &'py PyIterator,
+    input: Bound<'py, PyAny>,
+    iter: Bound<'py, PyIterator>,
 }
 
 fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) -> ValError {
@@ -486,22 +489,25 @@ fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) ->
 }
 
 impl<'py> MappingGenericIterator<'py> {
-    pub fn new(mapping: &'py PyMapping) -> ValResult<Self> {
+    pub fn new(mapping: &Bound<'py, PyMapping>) -> ValResult<Self> {
         let py = mapping.py();
-        let input: &PyAny = mapping;
+        let input = mapping.as_any();
         let iter = mapping
             .items()
             .map_err(|e| mapping_err(e, py, input))?
             .iter()
             .map_err(|e| mapping_err(e, py, input))?;
-        Ok(Self { input, iter })
+        Ok(Self {
+            input: input.clone(),
+            iter,
+        })
     }
 }
 
 const MAPPING_TUPLE_ERROR: &str = "Mapping items must be tuples of (key, value) pairs";
 
 impl<'py> Iterator for MappingGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         Some(match self.iter.next()? {
@@ -511,20 +517,20 @@ impl<'py> Iterator for MappingGenericIterator<'py> {
                         error: MAPPING_TUPLE_ERROR.into(),
                         context: None,
                     },
-                    self.input,
+                    &self.input,
                 )
             }),
-            Err(e) => Err(mapping_err(e, self.iter.py(), self.input)),
+            Err(e) => Err(mapping_err(e, self.iter.py(), &self.input)),
         })
     }
 }
 
 pub struct StringMappingGenericIterator<'py> {
-    dict_iter: PyDictIterator<'py>,
+    dict_iter: BoundDictIterator<'py>,
 }
 
 impl<'py> StringMappingGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
+    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
@@ -536,11 +542,11 @@ impl<'py> Iterator for StringMappingGenericIterator<'py> {
     fn next(&mut self) -> Option<Self::Item> {
         match self.dict_iter.next() {
             Some((py_key, py_value)) => {
-                let key = match StringMapping::new_key(py_key) {
+                let key = match StringMapping::new_key(&py_key) {
                     Ok(key) => key,
                     Err(e) => return Some(Err(e)),
                 };
-                let value = match StringMapping::new_value(py_value) {
+                let value = match StringMapping::new_value(&py_value) {
                     Ok(value) => value,
                     Err(e) => return Some(Err(e)),
                 };
@@ -552,22 +558,22 @@ impl<'py> Iterator for StringMappingGenericIterator<'py> {
 }
 
 pub struct AttributesGenericIterator<'py> {
-    object: &'py PyAny,
-    // PyO3 should export this type upstream
-    attributes_iterator: <&'py PyList as IntoIterator>::IntoIter,
+    object: Bound<'py, PyAny>,
+    attributes_iterator: BoundListIterator<'py>,
 }
 
 impl<'py> AttributesGenericIterator<'py> {
-    pub fn new(py_any: &'py PyAny) -> ValResult<Self> {
+    pub fn new(py_any: &Bound<'py, PyAny>) -> ValResult<Self> {
+        let attributes_iterator = py_any.dir().into_iter();
         Ok(Self {
-            object: py_any,
-            attributes_iterator: py_any.dir().into_iter(),
+            object: py_any.clone(),
+            attributes_iterator,
         })
     }
 }
 
 impl<'py> Iterator for AttributesGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         // loop until we find an attribute who's name does not start with underscore,
@@ -588,7 +594,7 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
                 // I think that's better than including static methods in the yielded attributes,
                 // if someone really wants fields, they can use an explicit field, or a function to modify input
                 #[cfg(not(PyPy))]
-                if !is_bound && !PyFunction::is_type_of(attr) {
+                if !is_bound && !attr.is_instance_of::<PyFunction>() {
                     return Some(Ok((name, attr)));
                 }
                 // MASSIVE HACK! PyFunction doesn't exist for PyPy,
@@ -639,11 +645,11 @@ impl From<JsonArray> for GenericIterator {
     }
 }
 
-impl From<&PyAny> for GenericIterator {
-    fn from(obj: &PyAny) -> Self {
+impl From<&Bound<'_, PyAny>> for GenericIterator {
+    fn from(obj: &Bound<'_, PyAny>) -> Self {
         let py_iter = GenericPyIterator {
-            obj: obj.to_object(obj.py()),
-            iter: obj.iter().unwrap().into_py(obj.py()),
+            obj: obj.clone().into(),
+            iter: obj.iter().unwrap().into(),
             index: 0,
         };
         Self::PyIterator(py_iter)
@@ -658,8 +664,10 @@ pub struct GenericPyIterator {
 }
 
 impl GenericPyIterator {
-    pub fn next<'a>(&'a mut self, py: Python<'a>) -> PyResult<Option<(&'a PyAny, usize)>> {
-        match self.iter.as_ref(py).next() {
+    pub fn next<'py>(&mut self, py: Python<'py>) -> PyResult<Option<(Bound<'py, PyAny>, usize)>> {
+        // TODO: .to_owned() is a workaround for PyO3 not allowing `.next()` to be called on
+        // the reference
+        match self.iter.bind(py).to_owned().next() {
             Some(Ok(next)) => {
                 let a = (next, self.index);
                 self.index += 1;
@@ -709,13 +717,13 @@ impl GenericJsonIterator {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct PyArgs<'a> {
-    pub args: Option<&'a PyTuple>,
-    pub kwargs: Option<&'a PyDict>,
+pub struct PyArgs<'py> {
+    pub args: Option<Bound<'py, PyTuple>>,
+    pub kwargs: Option<Bound<'py, PyDict>>,
 }
 
-impl<'a> PyArgs<'a> {
-    pub fn new(args: Option<&'a PyTuple>, kwargs: Option<&'a PyDict>) -> Self {
+impl<'py> PyArgs<'py> {
+    pub fn new(args: Option<Bound<'py, PyTuple>>, kwargs: Option<Bound<'py, PyDict>>) -> Self {
         Self { args, kwargs }
     }
 }
@@ -736,7 +744,7 @@ impl<'a> JsonArgs<'a> {
 pub enum GenericArguments<'a> {
     Py(PyArgs<'a>),
     Json(JsonArgs<'a>),
-    StringMapping(&'a PyDict),
+    StringMapping(Bound<'a, PyDict>),
 }
 
 impl<'a> From<PyArgs<'a>> for GenericArguments<'a> {
@@ -754,7 +762,7 @@ impl<'a> From<JsonArgs<'a>> for GenericArguments<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherString<'a> {
     Cow(Cow<'a, str>),
-    Py(&'a PyString),
+    Py(Bound<'a, PyString>),
 }
 
 impl<'a> EitherString<'a> {
@@ -765,10 +773,10 @@ impl<'a> EitherString<'a> {
         }
     }
 
-    pub fn as_py_string(&'a self, py: Python<'a>) -> &'a PyString {
+    pub fn as_py_string(&'a self, py: Python<'a>) -> Bound<'a, PyString> {
         match self {
-            Self::Cow(cow) => PyString::new(py, cow),
-            Self::Py(py_string) => py_string,
+            Self::Cow(cow) => PyString::new_bound(py, cow),
+            Self::Py(py_string) => py_string.clone(),
         }
     }
 }
@@ -785,8 +793,8 @@ impl<'a> From<String> for EitherString<'a> {
     }
 }
 
-impl<'a> From<&'a PyString> for EitherString<'a> {
-    fn from(date: &'a PyString) -> Self {
+impl<'a> From<Bound<'a, PyString>> for EitherString<'a> {
+    fn from(date: Bound<'a, PyString>) -> Self {
         Self::Py(date)
     }
 }
@@ -797,33 +805,36 @@ impl<'a> IntoPy<PyObject> for EitherString<'a> {
     }
 }
 
-pub fn py_string_str(py_str: &PyString) -> ValResult<&str> {
-    py_str
-        .to_str()
-        .map_err(|_| ValError::new_custom_input(ErrorTypeDefaults::StringUnicode, InputValue::Python(py_str.into())))
+pub fn py_string_str<'a>(py_str: &'a Bound<'_, PyString>) -> ValResult<&'a str> {
+    py_str.to_str().map_err(|_| {
+        ValError::new_custom_input(
+            ErrorTypeDefaults::StringUnicode,
+            InputValue::Python(py_str.clone().into()),
+        )
+    })
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherBytes<'a> {
     Cow(Cow<'a, [u8]>),
-    Py(&'a PyBytes),
+    Py(Bound<'a, PyBytes>),
 }
 
 impl<'a> From<Vec<u8>> for EitherBytes<'a> {
-    fn from(date: Vec<u8>) -> Self {
-        Self::Cow(Cow::Owned(date))
+    fn from(bytes: Vec<u8>) -> Self {
+        Self::Cow(Cow::Owned(bytes))
     }
 }
 
 impl<'a> From<&'a [u8]> for EitherBytes<'a> {
-    fn from(date: &'a [u8]) -> Self {
-        Self::Cow(Cow::Borrowed(date))
+    fn from(bytes: &'a [u8]) -> Self {
+        Self::Cow(Cow::Borrowed(bytes))
     }
 }
 
-impl<'a> From<&'a PyBytes> for EitherBytes<'a> {
-    fn from(date: &'a PyBytes) -> Self {
-        Self::Py(date)
+impl<'a> From<&'_ Bound<'a, PyBytes>> for EitherBytes<'a> {
+    fn from(bytes: &'_ Bound<'a, PyBytes>) -> Self {
+        Self::Py(bytes.clone())
     }
 }
 
@@ -846,7 +857,7 @@ impl<'a> EitherBytes<'a> {
 impl<'a> IntoPy<PyObject> for EitherBytes<'a> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            EitherBytes::Cow(bytes) => PyBytes::new(py, &bytes).into_py(py),
+            EitherBytes::Cow(bytes) => PyBytes::new_bound(py, &bytes).into_py(py),
             EitherBytes::Py(py_bytes) => py_bytes.into_py(py),
         }
     }
@@ -857,11 +868,11 @@ pub enum EitherInt<'a> {
     I64(i64),
     U64(u64),
     BigInt(BigInt),
-    Py(&'a PyAny),
+    Py(Bound<'a, PyAny>),
 }
 
 impl<'a> EitherInt<'a> {
-    pub fn upcast(py_any: &'a PyAny) -> ValResult<Self> {
+    pub fn upcast(py_any: &Bound<'a, PyAny>) -> ValResult<Self> {
         // Safety: we know that py_any is a python int
         if let Some(int_64) = extract_i64(py_any) {
             Ok(Self::I64(int_64))
@@ -875,21 +886,18 @@ impl<'a> EitherInt<'a> {
             EitherInt::I64(i) => Ok(i),
             EitherInt::U64(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
-                Err(_) => Err(ValError::new(
-                    ErrorTypeDefaults::IntParsingSize,
-                    u.into_py(py).into_ref(py),
-                )),
+                Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsingSize, u.into_py(py).bind(py))),
             },
             EitherInt::BigInt(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
                 Err(e) => Err(ValError::new(
                     ErrorTypeDefaults::IntParsingSize,
-                    e.into_original().into_py(py).into_ref(py),
+                    e.into_original().into_py(py).bind(py),
                 )),
             },
             EitherInt::Py(i) => i
                 .extract()
-                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, i)),
+                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, &i)),
         }
     }
 
@@ -903,7 +911,7 @@ impl<'a> EitherInt<'a> {
             EitherInt::BigInt(b) => Ok(Int::Big(b.clone())),
             EitherInt::Py(i) => i
                 .extract()
-                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, *i)),
+                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, i)),
         }
     }
 
@@ -945,16 +953,16 @@ impl<'a> IntoPy<PyObject> for EitherInt<'a> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub enum EitherFloat<'a> {
     F64(f64),
-    Py(&'a PyFloat),
+    Py(Bound<'a, PyFloat>),
 }
 
 impl<'a> EitherFloat<'a> {
-    pub fn as_f64(self) -> f64 {
+    pub fn as_f64(&self) -> f64 {
         match self {
-            EitherFloat::F64(f) => f,
+            EitherFloat::F64(f) => *f,
             EitherFloat::Py(f) => f.value(),
         }
     }
@@ -1019,8 +1027,8 @@ impl<'a> Rem for &'a Int {
     }
 }
 
-impl<'a> FromPyObject<'a> for Int {
-    fn extract(obj: &'a PyAny) -> PyResult<Self> {
+impl FromPyObject<'_> for Int {
+    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Some(i) = extract_i64(obj) {
             Ok(Int::I64(i))
         } else if let Ok(b) = obj.extract::<BigInt>() {
diff --git a/src/input/shared.rs b/src/input/shared.rs
index c81dff1e8..8771d4c01 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,5 +1,6 @@
+use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
-use pyo3::{intern, Py, PyAny, Python, ToPyObject};
+use pyo3::{intern, Py, PyAny, Python};
 
 use num_bigint::BigInt;
 
@@ -8,15 +9,15 @@ use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use super::{EitherFloat, EitherInt, Input};
 static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
 
-pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
+pub fn get_enum_meta_object(py: Python) -> &Bound<'_, PyAny> {
     ENUM_META_OBJECT
         .get_or_init(py, || {
-            py.import(intern!(py, "enum"))
+            py.import_bound(intern!(py, "enum"))
                 .and_then(|enum_module| enum_module.getattr(intern!(py, "EnumMeta")))
                 .unwrap()
-                .to_object(py)
+                .into()
         })
-        .clone()
+        .bind(py)
 }
 
 pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool> {
@@ -142,13 +143,14 @@ pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<Eith
     }
 }
 
-pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a PyAny) -> ValResult<EitherInt<'a>> {
+pub fn decimal_as_int<'a>(input: &'a impl Input<'a>, decimal: &Bound<'a, PyAny>) -> ValResult<EitherInt<'a>> {
+    let py = decimal.py();
     if !decimal.call_method0(intern!(py, "is_finite"))?.extract::<bool>()? {
         return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
     }
     let (numerator, denominator) = decimal
         .call_method0(intern!(py, "as_integer_ratio"))?
-        .extract::<(&PyAny, &PyAny)>()?;
+        .extract::<(Bound<'_, PyAny>, Bound<'_, PyAny>)>()?;
     if denominator.extract::<i64>().map_or(true, |d| d != 1) {
         return Err(ValError::new(ErrorTypeDefaults::IntFromFloat, input));
     }
diff --git a/src/lib.rs b/src/lib.rs
index de4a6d9bd..93fd91252 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,7 +39,12 @@ pub use validators::{validate_core_schema, PySome, SchemaValidator};
 use crate::input::Input;
 
 #[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=true))]
-pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool, cache_strings: bool) -> PyResult<PyObject> {
+pub fn from_json<'py>(
+    py: Python<'py>,
+    data: &Bound<'_, PyAny>,
+    allow_inf_nan: bool,
+    cache_strings: bool,
+) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
         .validate_bytes(false)
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
@@ -68,7 +73,7 @@ fn get_pydantic_version(py: Python<'_>) -> Option<&'static str> {
 
     PYDANTIC_VERSION
         .get_or_init(py, || {
-            py.import("pydantic")
+            py.import_bound("pydantic")
                 .and_then(|pydantic| pydantic.getattr("__version__")?.extract())
                 .ok()
         })
@@ -84,7 +89,7 @@ pub fn build_info() -> String {
 }
 
 #[pymodule]
-fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
+fn _pydantic_core(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("__version__", get_pydantic_core_version())?;
     m.add("build_profile", env!("PROFILE"))?;
     m.add("build_info", build_info())?;
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index d4fba403f..3a92a447c 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -52,22 +52,23 @@ impl fmt::Display for LookupKey {
 }
 
 impl LookupKey {
-    pub fn from_py(py: Python, value: &PyAny, alt_alias: Option<&str>) -> PyResult<Self> {
+    pub fn from_py(py: Python, value: &Bound<'_, PyAny>, alt_alias: Option<&str>) -> PyResult<Self> {
         if let Ok(alias_py) = value.downcast::<PyString>() {
-            let alias: &str = alias_py.extract()?;
+            let alias: String = alias_py.extract()?;
+            let path1 = LookupPath::from_str(py, &alias, Some(alias_py.clone()));
             match alt_alias {
                 Some(alt_alias) => Ok(Self::Choice {
                     key1: alias.to_string(),
-                    py_key1: alias_py.into_py(py),
-                    path1: LookupPath::from_str(py, alias, Some(alias_py)),
+                    py_key1: alias_py.clone().into(),
+                    path1,
                     key2: alt_alias.to_string(),
-                    py_key2: PyString::new(py, alt_alias).into(),
+                    py_key2: PyString::new_bound(py, alt_alias).into(),
                     path2: LookupPath::from_str(py, alt_alias, None),
                 }),
-                None => Ok(Self::simple(py, alias, Some(alias_py))),
+                None => Ok(Self::simple(py, &alias, Some(alias_py.clone()))),
             }
         } else {
-            let list: &PyList = value.downcast()?;
+            let list = value.downcast::<PyList>()?;
             let first = match list.get_item(0) {
                 Ok(v) => v,
                 Err(_) => return py_schema_err!("Lookup paths should have at least one element"),
@@ -76,7 +77,9 @@ impl LookupKey {
                 // list of strings rather than list of lists
                 vec![LookupPath::from_list(list)?]
             } else {
-                list.iter().map(LookupPath::from_list).collect::<PyResult<_>>()?
+                list.iter()
+                    .map(|elem| LookupPath::from_list(&elem))
+                    .collect::<PyResult<_>>()?
             };
 
             if let Some(alt_alias) = alt_alias {
@@ -90,10 +93,10 @@ impl LookupKey {
         Self::simple(py, key, None)
     }
 
-    fn simple(py: Python, key: &str, opt_py_key: Option<&PyString>) -> Self {
-        let py_key = match opt_py_key {
-            Some(py_key) => py_key,
-            None => PyString::new(py, key),
+    fn simple(py: Python, key: &str, opt_py_key: Option<Bound<'_, PyString>>) -> Self {
+        let py_key = match &opt_py_key {
+            Some(py_key) => py_key.clone(),
+            None => PyString::new_bound(py, key),
         };
         Self::Simple {
             key: key.to_string(),
@@ -102,10 +105,10 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_dict_item<'data, 's>(
+    pub fn py_get_dict_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Bound<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
                 Some(value) => Ok(Some((path, value))),
@@ -128,7 +131,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -139,22 +142,22 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_string_mapping_item<'data, 's>(
+    pub fn py_get_string_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'data>)>> {
+        dict: &Bound<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'py>)>> {
         if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
-            let value = StringMapping::new_value(py_any)?;
+            let value = StringMapping::new_value(&py_any)?;
             Ok(Some((path, value)))
         } else {
             Ok(None)
         }
     }
 
-    pub fn py_get_mapping_item<'data, 's>(
+    pub fn py_get_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyMapping,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Bound<'py, PyMapping>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Ok(value) => Ok(Some((path, value))),
@@ -177,7 +180,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -188,11 +191,11 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_attr<'data, 's>(
+    pub fn py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Bound<'py, PyAny>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self._py_get_attr(obj, kwargs) {
             Ok(v) => Ok(v),
             Err(err) => {
@@ -205,11 +208,11 @@ impl LookupKey {
         }
     }
 
-    pub fn _py_get_attr<'data, 's>(
+    pub fn _py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Bound<'py, PyAny>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         if let Some(dict) = kwargs {
             if let Ok(Some(item)) = self.py_get_dict_item(dict) {
                 return Ok(Some(item));
@@ -238,9 +241,9 @@ impl LookupKey {
                 'outer: for path in path_choices {
                     // similar to above, but using `py_get_attrs`, we can't use try_fold because of the extra Err
                     // so we have to loop manually
-                    let mut v = obj;
+                    let mut v = obj.clone();
                     for loc in path.iter() {
-                        v = match loc.py_get_attrs(v) {
+                        v = match loc.py_get_attrs(&v) {
                             Ok(Some(v)) => v,
                             Ok(None) => {
                                 continue 'outer;
@@ -340,20 +343,20 @@ impl fmt::Display for LookupPath {
 }
 
 impl LookupPath {
-    fn from_str(py: Python, key: &str, py_key: Option<&PyString>) -> Self {
+    fn from_str(py: Python, key: &str, py_key: Option<Bound<'_, PyString>>) -> Self {
         let py_key = match py_key {
             Some(py_key) => py_key,
-            None => PyString::new(py, key),
+            None => PyString::new_bound(py, key),
         };
         Self(vec![PathItem::S(key.to_string(), py_key.into())])
     }
 
-    fn from_list(obj: &PyAny) -> PyResult<LookupPath> {
+    fn from_list(obj: &Bound<'_, PyAny>) -> PyResult<LookupPath> {
         let v = obj
-            .extract::<&PyList>()?
+            .downcast::<PyList>()?
             .iter()
             .enumerate()
-            .map(|(index, obj)| PathItem::from_py(index, obj))
+            .map(|(index, obj)| PathItem::from_py(index, &obj))
             .collect::<PyResult<Vec<PathItem>>>()?;
 
         if v.is_empty() {
@@ -419,10 +422,10 @@ impl ToPyObject for PathItem {
 }
 
 impl PathItem {
-    pub fn from_py(index: usize, obj: &PyAny) -> PyResult<Self> {
+    pub fn from_py(index: usize, obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Ok(py_str_key) = obj.downcast::<PyString>() {
             let str_key = py_str_key.to_str()?.to_string();
-            Ok(Self::S(str_key, py_str_key.into()))
+            Ok(Self::S(str_key, py_str_key.clone().into()))
         } else if let Ok(usize_key) = obj.extract::<usize>() {
             if index == 0 {
                 py_err!(PyTypeError; "The first item in an alias path should be a string")
@@ -440,7 +443,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_item<'a>(&self, py_any: &'a PyAny) -> Option<&'a PyAny> {
+    pub fn py_get_item<'py>(&self, py_any: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
         // we definitely don't want to index strings, so explicitly omit this case
         if py_any.downcast::<PyString>().is_ok() {
             None
@@ -457,7 +460,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_attrs<'a>(&self, obj: &'a PyAny) -> PyResult<Option<&'a PyAny>> {
+    pub fn py_get_attrs<'py>(&self, obj: &Bound<'py, PyAny>) -> PyResult<Option<Bound<'py, PyAny>>> {
         match self {
             Self::S(_, py_key) => {
                 // if obj is a dict, we want to use get_item, not getattr
@@ -500,11 +503,11 @@ impl PathItem {
 
 /// wrapper around `getattr` that returns `Ok(None)` for attribute errors, but returns other errors
 /// We don't check `try_from_attributes` because that check was performed on the top level object before we got here
-fn py_get_attrs<'a>(obj: &'a PyAny, attr_name: &Py<PyString>) -> PyResult<Option<&'a PyAny>> {
+fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyResult<Option<Bound<'py, PyAny>>> {
     match obj.getattr(attr_name.extract::<&PyString>(obj.py())?) {
         Ok(attr) => Ok(Some(attr)),
         Err(err) => {
-            if err.get_type(obj.py()).is_subclass_of::<PyAttributeError>()? {
+            if err.get_type_bound(obj.py()).is_subclass_of::<PyAttributeError>()? {
                 Ok(None)
             } else {
                 Err(err)
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 43e284fdd..25c5d32e8 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -19,15 +19,15 @@ pub(super) struct ComputedFields(Vec<ComputedField>);
 
 impl ComputedFields {
     pub fn new(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<Option<Self>> {
         let py = schema.py();
-        if let Some(computed_fields) = schema.get_as::<&PyList>(intern!(py, "computed_fields"))? {
+        if let Some(computed_fields) = schema.get_as::<Bound<'_, PyList>>(intern!(py, "computed_fields"))? {
             let computed_fields = computed_fields
                 .iter()
-                .map(|field| ComputedField::new(field, config, definitions))
+                .map(|field| ComputedField::new(&field, config, definitions))
                 .collect::<PyResult<Vec<_>>>()?;
             Ok(Some(Self(computed_fields)))
         } else {
@@ -41,11 +41,11 @@ impl ComputedFields {
 
     pub fn to_python(
         &self,
-        model: &PyAny,
-        output_dict: &PyDict,
+        model: &Bound<'_, PyAny>,
+        output_dict: &Bound<'_, PyDict>,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         if extra.round_trip {
@@ -60,11 +60,11 @@ impl ComputedFields {
 
     pub fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        model: &PyAny,
+        model: &Bound<'_, PyAny>,
         map: &mut S::SerializeMap,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         if extra.round_trip {
@@ -72,7 +72,7 @@ impl ComputedFields {
             return Ok(());
         }
         for computed_field in &self.0 {
-            let property_name_py = computed_field.property_name_py.as_ref(model.py());
+            let property_name_py = computed_field.property_name_py.bind(model.py());
             let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
             if extra.exclude_none && value.is_none() {
                 continue;
@@ -84,8 +84,8 @@ impl ComputedFields {
                 let cfs = ComputedFieldSerializer {
                     model,
                     computed_field,
-                    include: next_include,
-                    exclude: next_exclude,
+                    include: next_include.as_ref(),
+                    exclude: next_exclude.as_ref(),
                     extra,
                 };
                 let key = match extra.by_alias {
@@ -110,17 +110,19 @@ struct ComputedField {
 
 impl ComputedField {
     pub fn new(
-        schema: &PyAny,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyAny>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<Self> {
         let py = schema.py();
-        let schema: &PyDict = schema.downcast()?;
-        let property_name: &PyString = schema.get_as_req(intern!(py, "property_name"))?;
+        let schema: &Bound<'_, PyDict> = schema.downcast()?;
+        let property_name: Bound<'_, PyString> = schema.get_as_req(intern!(py, "property_name"))?;
         let return_schema = schema.get_as_req(intern!(py, "return_schema"))?;
-        let serializer = CombinedSerializer::build(return_schema, config, definitions)
+        let serializer = CombinedSerializer::build(&return_schema, config, definitions)
             .map_err(|e| py_schema_error_type!("Computed field `{}`:\n  {}", property_name, e))?;
-        let alias_py: &PyString = schema.get_as(intern!(py, "alias"))?.unwrap_or(property_name);
+        let alias_py = schema
+            .get_as(intern!(py, "alias"))?
+            .unwrap_or_else(|| property_name.clone());
         Ok(Self {
             property_name: property_name.extract()?,
             property_name_py: property_name.into_py(py),
@@ -132,27 +134,27 @@ impl ComputedField {
 
     fn to_python(
         &self,
-        model: &PyAny,
-        output_dict: &PyDict,
+        model: &Bound<'_, PyAny>,
+        output_dict: &Bound<'_, PyDict>,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         let py = model.py();
-        let property_name_py = self.property_name_py.as_ref(py);
+        let property_name_py = self.property_name_py.bind(py);
 
         if let Some((next_include, next_exclude)) = filter.key_filter(property_name_py, include, exclude)? {
             let next_value = model.getattr(property_name_py)?;
 
             let value = self
                 .serializer
-                .to_python(next_value, next_include, next_exclude, extra)?;
+                .to_python(&next_value, next_include.as_ref(), next_exclude.as_ref(), extra)?;
             if extra.exclude_none && value.is_none(py) {
                 return Ok(());
             }
             let key = match extra.by_alias {
-                true => self.alias_py.as_ref(py),
+                true => self.alias_py.bind(py),
                 false => property_name_py,
             };
             output_dict.set_item(key, value)?;
@@ -162,10 +164,10 @@ impl ComputedField {
 }
 
 pub(crate) struct ComputedFieldSerializer<'py> {
-    model: &'py PyAny,
+    model: &'py Bound<'py, PyAny>,
     computed_field: &'py ComputedField,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
@@ -182,10 +184,10 @@ impl_py_gc_traverse!(ComputedFieldSerializer<'_> { computed_field });
 impl<'py> Serialize for ComputedFieldSerializer<'py> {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let py = self.model.py();
-        let property_name_py = self.computed_field.property_name_py.as_ref(py);
+        let property_name_py = self.computed_field.property_name_py.bind(py);
         let next_value = self.model.getattr(property_name_py).map_err(py_err_se_err)?;
         let s = PydanticSerializer::new(
-            next_value,
+            &next_value,
             &self.computed_field.serializer,
             self.include,
             self.exclude,
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 422ee4162..2863d68d9 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -2,9 +2,9 @@ use std::borrow::Cow;
 use std::str::{from_utf8, FromStr, Utf8Error};
 
 use base64::Engine;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDict};
-use pyo3::{intern, PyNativeType};
+use pyo3::types::{PyDelta, PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -23,7 +23,7 @@ pub(crate) struct SerializationConfig {
 }
 
 impl SerializationConfig {
-    pub fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let timedelta_mode = TimedeltaMode::from_config(config)?;
         let bytes_mode = BytesMode::from_config(config)?;
         let inf_nan_mode = InfNanMode::from_config(config)?;
@@ -44,7 +44,7 @@ impl SerializationConfig {
 }
 
 pub trait FromConfig {
-    fn from_config(config: Option<&PyDict>) -> PyResult<Self>
+    fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self>
     where
         Self: Sized;
 }
@@ -72,12 +72,12 @@ macro_rules! serialization_mode {
         }
 
         impl FromConfig for $name {
-            fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
+            fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
                 let Some(config_dict) = config else {
                     return Ok(Self::default());
                 };
-                let raw_mode = config_dict.get_as::<&str>(intern!(config_dict.py(), $config_key))?;
-                raw_mode.map_or_else(|| Ok(Self::default()), Self::from_str)
+                let raw_mode = config_dict.get_as::<Bound<'_, PyString>>(intern!(config_dict.py(), $config_key))?;
+                raw_mode.map_or_else(|| Ok(Self::default()), |raw| Self::from_str(&raw.to_cow()?))
             }
         }
 
@@ -107,7 +107,7 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
-    fn total_seconds(py_timedelta: &PyDelta) -> PyResult<&PyAny> {
+    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
 
@@ -121,7 +121,7 @@ impl TimedeltaMode {
                 // convert to int via a py timedelta not duration since we know this this case the input would have
                 // been a py timedelta
                 let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds = Self::total_seconds(py_timedelta)?;
+                let seconds = Self::total_seconds(&py_timedelta)?;
                 Ok(seconds.into_py(py))
             }
         }
@@ -135,7 +135,7 @@ impl TimedeltaMode {
             }
             Self::Float => {
                 let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(py_timedelta)?.extract()?;
+                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
         }
@@ -154,7 +154,7 @@ impl TimedeltaMode {
             }
             Self::Float => {
                 let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
-                let seconds = Self::total_seconds(py_timedelta).map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
                 let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
@@ -163,7 +163,7 @@ impl TimedeltaMode {
 }
 
 impl BytesMode {
-    pub fn bytes_to_string<'py>(&self, py: Python, bytes: &'py [u8]) -> PyResult<Cow<'py, str>> {
+    pub fn bytes_to_string<'a>(&self, py: Python, bytes: &'a [u8]) -> PyResult<Cow<'a, str>> {
         match self {
             Self::Utf8 => from_utf8(bytes)
                 .map_err(|err| utf8_py_error(py, err, bytes))
@@ -190,15 +190,14 @@ impl BytesMode {
 }
 
 pub fn utf8_py_error(py: Python, err: Utf8Error, data: &[u8]) -> PyErr {
-    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8(py, data, err) {
-        Ok(decode_err) => PyErr::from_value(decode_err),
+    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8_bound(py, data, err) {
+        Ok(decode_err) => PyErr::from_value_bound(decode_err.into_any()),
         Err(err) => err,
     }
 }
 
 impl FromPyObject<'_> for InfNanMode {
-    fn extract(ob: &'_ PyAny) -> PyResult<Self> {
-        let s = ob.extract::<&str>()?;
-        Self::from_str(s)
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
+        Self::from_str(ob.downcast::<PyString>()?.to_str()?)
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 3cff3f370..4067892cf 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -44,8 +44,8 @@ impl SerializationState {
         exclude_none: bool,
         round_trip: bool,
         serialize_unknown: bool,
-        fallback: Option<&'py PyAny>,
-        context: Option<&'py PyAny>,
+        fallback: Option<&'py Bound<'py, PyAny>>,
+        context: Option<&'py Bound<'py, PyAny>>,
     ) -> Extra<'py> {
         Extra::new(
             py,
@@ -88,11 +88,11 @@ pub(crate) struct Extra<'a> {
     // data representing the current model field
     // that is being serialized, if this is a model serializer
     // it will be None otherwise
-    pub model: Option<&'a PyAny>,
+    pub model: Option<&'a Bound<'a, PyAny>>,
     pub field_name: Option<&'a str>,
     pub serialize_unknown: bool,
-    pub fallback: Option<&'a PyAny>,
-    pub context: Option<&'a PyAny>,
+    pub fallback: Option<&'a Bound<'a, PyAny>>,
+    pub context: Option<&'a Bound<'a, PyAny>>,
 }
 
 impl<'a> Extra<'a> {
@@ -109,8 +109,8 @@ impl<'a> Extra<'a> {
         config: &'a SerializationConfig,
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
-        fallback: Option<&'a PyAny>,
-        context: Option<&'a PyAny>,
+        fallback: Option<&'a Bound<'a, PyAny>>,
+        context: Option<&'a Bound<'a, PyAny>>,
     ) -> Self {
         Self {
             mode,
@@ -139,7 +139,7 @@ impl<'a> Extra<'a> {
         // See how validation has &mut ValidationState passed around; we should aim to refactor
         // to match that.
         self: &'x mut &'y Self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         def_ref_id: usize,
     ) -> PyResult<RecursionGuard<'x, &'y Self>> {
         RecursionGuard::new(self, value.as_ptr() as usize, def_ref_id).map_err(|e| match e {
@@ -148,7 +148,7 @@ impl<'a> Extra<'a> {
         })
     }
 
-    pub fn serialize_infer<'py>(&'py self, value: &'py PyAny) -> super::infer::SerializeInfer<'py> {
+    pub fn serialize_infer<'py>(&'py self, value: &'py Bound<'py, PyAny>) -> super::infer::SerializeInfer<'py> {
         super::infer::SerializeInfer::new(value, None, None, self)
     }
 }
@@ -203,11 +203,11 @@ impl ExtraOwned {
             config: extra.config.clone(),
             rec_guard: extra.rec_guard.clone(),
             check: extra.check,
-            model: extra.model.map(Into::into),
+            model: extra.model.map(|model| model.clone().into()),
             field_name: extra.field_name.map(ToString::to_string),
             serialize_unknown: extra.serialize_unknown,
-            fallback: extra.fallback.map(Into::into),
-            context: extra.context.map(Into::into),
+            fallback: extra.fallback.map(|fallback| fallback.clone().into()),
+            context: extra.context.map(|context| context.clone().into()),
         }
     }
 
@@ -224,11 +224,11 @@ impl ExtraOwned {
             config: &self.config,
             rec_guard: &self.rec_guard,
             check: self.check,
-            model: self.model.as_ref().map(|m| m.as_ref(py)),
+            model: self.model.as_ref().map(|m| m.bind(py)),
             field_name: self.field_name.as_deref(),
             serialize_unknown: self.serialize_unknown,
-            fallback: self.fallback.as_ref().map(|m| m.as_ref(py)),
-            context: self.context.as_ref().map(|m| m.as_ref(py)),
+            fallback: self.fallback.as_ref().map(|m| m.bind(py)),
+            context: self.context.as_ref().map(|m| m.bind(py)),
         }
     }
 }
@@ -299,7 +299,7 @@ impl CollectWarnings {
         }
     }
 
-    pub fn on_fallback_py(&self, field_type: &str, value: &PyAny, extra: &Extra) -> PyResult<()> {
+    pub fn on_fallback_py(&self, field_type: &str, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<()> {
         // special case for None as it's very common e.g. as a default value
         if value.is_none() {
             Ok(())
@@ -314,7 +314,7 @@ impl CollectWarnings {
     pub fn on_fallback_ser<S: serde::ser::Serializer>(
         &self,
         field_type: &str,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         // special case for None as it's very common e.g. as a default value
@@ -331,9 +331,12 @@ impl CollectWarnings {
         }
     }
 
-    fn fallback_warning(&self, field_type: &str, value: &PyAny) {
+    fn fallback_warning(&self, field_type: &str, value: &Bound<'_, PyAny>) {
         if self.active {
-            let type_name = value.get_type().name().unwrap_or("<unknown python object>");
+            let type_name = value
+                .get_type()
+                .qualname()
+                .unwrap_or_else(|_| "<unknown python object>".to_owned());
             self.add_warning(format!(
                 "Expected `{field_type}` but got `{type_name}` - serialized value may not be as expected"
             ));
@@ -354,8 +357,8 @@ impl CollectWarnings {
             match *self.warnings.borrow() {
                 Some(ref warnings) => {
                     let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
-                    let user_warning_type = py.import("builtins")?.getattr("UserWarning")?;
-                    PyErr::warn(py, user_warning_type, &message, 0)
+                    let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
+                    PyErr::warn_bound(py, &user_warning_type, &message, 0)
                 }
                 _ => Ok(()),
             }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 4d192d344..f2dc50eb7 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -39,7 +39,9 @@ impl SerField {
         serializer: Option<CombinedSerializer>,
         required: bool,
     ) -> Self {
-        let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
+        let alias_py = alias
+            .as_ref()
+            .map(|alias| PyString::new_bound(py, alias.as_str()).into());
         Self {
             key_py,
             alias,
@@ -49,13 +51,13 @@ impl SerField {
         }
     }
 
-    pub fn get_key_py<'py>(&'py self, py: Python<'py>, extra: &Extra) -> &'py PyAny {
+    pub fn get_key_py<'py>(&'py self, py: Python<'py>, extra: &Extra) -> &Bound<'py, PyAny> {
         if extra.by_alias {
             if let Some(ref alias_py) = self.alias_py {
-                return alias_py.as_ref(py);
+                return alias_py.bind(py);
             }
         }
-        self.key_py.as_ref(py)
+        self.key_py.bind(py)
     }
 
     pub fn get_key_json<'a>(&'a self, key_str: &'a str, extra: &Extra) -> Cow<'a, str> {
@@ -68,7 +70,7 @@ impl SerField {
     }
 }
 
-fn exclude_default(value: &PyAny, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
+fn exclude_default(value: &Bound<'_, PyAny>, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
     if extra.exclude_defaults {
         if let Some(default) = serializer.get_default(value.py())? {
             if value.eq(default)? {
@@ -128,10 +130,10 @@ impl GeneralFieldsSerializer {
         }
     }
 
-    fn extract_dicts<'a>(&self, value: &'a PyAny) -> Option<(&'a PyDict, Option<&'a PyDict>)> {
+    fn extract_dicts<'a>(&self, value: &Bound<'a, PyAny>) -> Option<(Bound<'a, PyDict>, Option<Bound<'a, PyDict>>)> {
         match self.mode {
             FieldsMode::ModelExtra => {
-                if let Ok((main_dict, extra_dict)) = value.extract::<(&PyDict, &PyDict)>() {
+                if let Ok((main_dict, extra_dict)) = value.extract() {
                     Some((main_dict, Some(extra_dict)))
                 } else {
                     None
@@ -139,7 +141,7 @@ impl GeneralFieldsSerializer {
             }
             _ => {
                 if let Ok(main_dict) = value.downcast::<PyDict>() {
-                    Some((main_dict, None))
+                    Some((main_dict.clone(), None))
                 } else {
                     None
                 }
@@ -150,19 +152,19 @@ impl GeneralFieldsSerializer {
     pub(crate) fn main_to_python<'py>(
         &self,
         py: Python<'py>,
-        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        main_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         extra: Extra,
-    ) -> PyResult<&'py PyDict> {
-        let output_dict = PyDict::new(py);
+    ) -> PyResult<Bound<'py, PyDict>> {
+        let output_dict = PyDict::new_bound(py);
         let mut used_req_fields: usize = 0;
 
         // NOTE! we maintain the order of the input dict assuming that's right
         for result in main_iter {
             let (key, value) = result?;
-            let key_str = key_str(key)?;
-            let op_field = self.fields.get(key_str);
+            let key_str = key_str(&key)?;
+            let op_field = self.fields.get(key_str.as_ref());
             if extra.exclude_none && value.is_none() {
                 if let Some(field) = op_field {
                     if field.required {
@@ -172,14 +174,19 @@ impl GeneralFieldsSerializer {
                 continue;
             }
             let field_extra = Extra {
-                field_name: Some(key_str),
+                field_name: Some(&key_str),
                 ..extra
             };
-            if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
+            if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
                 if let Some(field) = op_field {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &field_extra, serializer)? {
-                            let value = serializer.to_python(value, next_include, next_exclude, &field_extra)?;
+                        if !exclude_default(&value, &field_extra, serializer)? {
+                            let value = serializer.to_python(
+                                &value,
+                                next_include.as_ref(),
+                                next_exclude.as_ref(),
+                                &field_extra,
+                            )?;
                             let output_key = field.get_key_py(output_dict.py(), &field_extra);
                             output_dict.set_item(output_key, value)?;
                         }
@@ -190,8 +197,10 @@ impl GeneralFieldsSerializer {
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
                     let value = match &self.extra_serializer {
-                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, &field_extra)?,
-                        None => infer_to_python(value, next_include, next_exclude, &field_extra)?,
+                        Some(serializer) => {
+                            serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?
+                        }
+                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
@@ -214,11 +223,11 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn main_serde_serialize<'py, S: serde::ser::Serializer>(
         &self,
-        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+        main_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
         expected_len: usize,
         serializer: S,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         extra: Extra,
     ) -> Result<S::SerializeMap, S::Error> {
         // NOTE! As above, we maintain the order of the input dict assuming that's right
@@ -230,26 +239,31 @@ impl GeneralFieldsSerializer {
             if extra.exclude_none && value.is_none() {
                 continue;
             }
-            let key_str = key_str(key).map_err(py_err_se_err)?;
+            let key_str = key_str(&key).map_err(py_err_se_err)?;
             let field_extra = Extra {
-                field_name: Some(key_str),
+                field_name: Some(&key_str),
                 ..extra
             };
 
-            let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+            let filter = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
             if let Some((next_include, next_exclude)) = filter {
-                if let Some(field) = self.fields.get(key_str) {
+                if let Some(field) = self.fields.get(key_str.as_ref()) {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &field_extra, serializer).map_err(py_err_se_err)? {
-                            let s =
-                                PydanticSerializer::new(value, serializer, next_include, next_exclude, &field_extra);
-                            let output_key = field.get_key_json(key_str, &field_extra);
+                        if !exclude_default(&value, &field_extra, serializer).map_err(py_err_se_err)? {
+                            let s = PydanticSerializer::new(
+                                &value,
+                                serializer,
+                                next_include.as_ref(),
+                                next_exclude.as_ref(),
+                                &field_extra,
+                            );
+                            let output_key = field.get_key_json(&key_str, &field_extra);
                             map.serialize_entry(&output_key, &s)?;
                         }
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
-                    let output_key = infer_json_key(key, &field_extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, &field_extra);
+                    let output_key = infer_json_key(&key, &field_extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra);
                     map.serialize_entry(&output_key, &s)?;
                 }
                 // no error case here since unions (which need the error case) use `to_python(..., mode='json')`
@@ -260,10 +274,10 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn add_computed_fields_python(
         &self,
-        model: Option<&PyAny>,
-        output_dict: &PyDict,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        model: Option<&Bound<'_, PyAny>>,
+        output_dict: &Bound<'_, PyDict>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         if let Some(ref computed_fields) = self.computed_fields {
@@ -277,10 +291,10 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn add_computed_fields_json<S: serde::ser::Serializer>(
         &self,
-        model: Option<&PyAny>,
+        model: Option<&Bound<'_, PyAny>>,
         map: &mut S::SerializeMap,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         if let Some(ref computed_fields) = self.computed_fields {
@@ -304,9 +318,9 @@ impl_py_gc_traverse!(GeneralFieldsSerializer {
 impl TypeSerializer for GeneralFieldsSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -322,7 +336,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
             return infer_to_python(value, include, exclude, &td_extra);
         };
 
-        let output_dict = self.main_to_python(py, dict_items(main_dict), include, exclude, td_extra)?;
+        let output_dict = self.main_to_python(py, dict_items(&main_dict), include, exclude, td_extra)?;
 
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
@@ -330,29 +344,31 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 if extra.exclude_none && value.is_none() {
                     continue;
                 }
-                if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
+                if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
                     let value = match &self.extra_serializer {
-                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, extra)?,
-                        None => infer_to_python(value, next_include, next_exclude, extra)?,
+                        Some(serializer) => {
+                            serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?
+                        }
+                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 }
             }
         }
-        self.add_computed_fields_python(model, output_dict, include, exclude, extra)?;
+        self.add_computed_fields_python(model, &output_dict, include, exclude, extra)?;
         Ok(output_dict.into_py(py))
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, "fields")
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
@@ -374,7 +390,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // NOTE! As above, we maintain the order of the input dict assuming that's right
         // we don't both with `used_fields` here because on unions, `to_python(..., mode='json')` is used
         let mut map = self.main_serde_serialize(
-            dict_items(main_dict),
+            dict_items(&main_dict),
             expected_len,
             serializer,
             include,
@@ -388,10 +404,10 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 if extra.exclude_none && value.is_none() {
                     continue;
                 }
-                let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+                let filter = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = filter {
-                    let output_key = infer_json_key(key, extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, extra);
+                    let output_key = infer_json_key(&key, extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), extra);
                     map.serialize_entry(&output_key, &s)?;
                 }
             }
@@ -406,11 +422,13 @@ impl TypeSerializer for GeneralFieldsSerializer {
     }
 }
 
-fn key_str(key: &PyAny) -> PyResult<&str> {
-    key.downcast::<PyString>()?.to_str()
+fn key_str<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<Cow<'a, str>> {
+    key.downcast::<PyString>()?.to_cow()
 }
 
-fn dict_items(main_dict: &PyDict) -> impl Iterator<Item = PyResult<(&PyAny, &PyAny)>> {
+fn dict_items<'py>(
+    main_dict: &'_ Bound<'py, PyDict>,
+) -> impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> {
     // Collect items before iterating to prevent panic on dict mutation.
     // Use a SmallVec to avoid heap allocation for models with a reasonable number of fields.
     let main_items: SmallVec<[_; 16]> = main_dict.iter().collect();
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index 0efec56e8..4af04bb6c 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -15,48 +15,53 @@ pub(crate) struct SchemaFilter<T> {
     exclude: Option<AHashSet<T>>,
 }
 
-fn map_negative_index(value: &PyAny, len: Option<usize>) -> PyResult<&PyAny> {
+fn map_negative_index<'py>(value: &Bound<'py, PyAny>, len: Option<usize>) -> PyResult<Bound<'py, PyAny>> {
     let py = value.py();
     match len {
         Some(len) => Ok(value
             .call_method1(intern!(py, "__mod__"), (len,))
-            .map_or_else(|_| value, |v| v)),
+            .unwrap_or_else(|_| value.clone())),
         None => {
             // check that it's not negative
-            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_true()?;
+            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_truthy()?;
             if negative {
                 Err(PyValueError::new_err(
                     "Negative indices cannot be used to exclude items on unsized iterables",
                 ))
             } else {
-                Ok(value)
+                Ok(value.clone())
             }
         }
     }
 }
 
-fn map_negative_indices(include_or_exclude: &PyAny, len: Option<usize>) -> PyResult<&PyAny> {
+fn map_negative_indices<'py>(
+    include_or_exclude: &Bound<'py, PyAny>,
+    len: Option<usize>,
+) -> PyResult<Bound<'py, PyAny>> {
     let py = include_or_exclude.py();
     if let Ok(exclude_dict) = include_or_exclude.downcast::<PyDict>() {
-        let out = PyDict::new(py);
-        for (k, v) in exclude_dict {
-            out.set_item(map_negative_index(k, len)?, v)?;
+        let out = PyDict::new_bound(py);
+        for (k, v) in exclude_dict.iter() {
+            out.set_item(map_negative_index(&k, len)?, v)?;
         }
-        Ok(out)
+        Ok(out.into_any())
     } else if let Ok(exclude_set) = include_or_exclude.downcast::<PySet>() {
         let mut values = Vec::with_capacity(exclude_set.len());
-        for v in exclude_set {
-            values.push(map_negative_index(v, len)?);
+        for v in exclude_set.iter() {
+            values.push(map_negative_index(&v, len)?);
         }
-        Ok(PySet::new(py, values)?)
+        Ok(PySet::new_bound(py, &values)?.into_any())
     } else {
         // return as is and deal with the error later
-        Ok(include_or_exclude)
+        Ok(include_or_exclude.clone())
     }
 }
 
+type NextFilters<'py> = Option<(Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>)>;
+
 impl SchemaFilter<usize> {
-    pub fn from_schema(schema: &PyDict) -> PyResult<Self> {
+    pub fn from_schema(schema: &Bound<'_, PyDict>) -> PyResult<Self> {
         let py = schema.py();
         match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
             Some(ser) => {
@@ -90,33 +95,33 @@ impl SchemaFilter<usize> {
     pub fn index_filter<'py>(
         &self,
         index: usize,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         len: Option<usize>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+    ) -> PyResult<NextFilters<'py>> {
         let include = include.map(|v| map_negative_indices(v, len)).transpose()?;
         let exclude = exclude.map(|v| map_negative_indices(v, len)).transpose()?;
-        self.filter(index, index, include, exclude)
+        self.filter(index, index, include.as_ref(), exclude.as_ref())
     }
 }
 
 impl SchemaFilter<isize> {
-    pub fn from_set_hash(include: Option<&PyAny>, exclude: Option<&PyAny>) -> PyResult<Self> {
+    pub fn from_set_hash(include: Option<&Bound<'_, PyAny>>, exclude: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
         let include = Self::build_set_hashes(include)?;
         let exclude = Self::build_set_hashes(exclude)?;
         Ok(Self { include, exclude })
     }
 
-    fn build_set_hashes(v: Option<&PyAny>) -> PyResult<Option<AHashSet<isize>>> {
+    fn build_set_hashes(v: Option<&Bound<'_, PyAny>>) -> PyResult<Option<AHashSet<isize>>> {
         match v {
             Some(value) => {
                 if value.is_none() {
                     Ok(None)
                 } else {
-                    let py_set: &PySet = value.downcast()?;
+                    let py_set = value.downcast::<PySet>()?;
                     let mut set: AHashSet<isize> = AHashSet::with_capacity(py_set.len());
 
-                    for item in py_set {
+                    for item in py_set.iter() {
                         set.insert(item.hash()?);
                     }
                     Ok(Some(set))
@@ -128,10 +133,10 @@ impl SchemaFilter<isize> {
 
     pub fn key_filter<'py>(
         &self,
-        key: &PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+        key: &Bound<'_, PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
         let hash = key.hash()?;
         self.filter(key, hash, include, exclude)
     }
@@ -150,17 +155,17 @@ trait FilterLogic<T: Eq + Copy> {
         &self,
         py_key: impl ToPyObject + Copy,
         int_key: T,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
-        let mut next_exclude: Option<&PyAny> = None;
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
+        let mut next_exclude = None;
         if let Some(exclude) = exclude {
             if exclude.is_none() {
                 // Do nothing; place this check at the top for performance in the common case
             } else if let Ok(exclude_dict) = exclude.downcast::<PyDict>() {
                 let op_exc_value = merge_all_value(exclude_dict, py_key)?;
                 if let Some(exc_value) = op_exc_value {
-                    if is_ellipsis_like(exc_value) {
+                    if is_ellipsis_like(&exc_value) {
                         // if the index is in exclude, and the exclude value is `None`, we want to omit this index/item
                         return Ok(None);
                     }
@@ -190,7 +195,7 @@ trait FilterLogic<T: Eq + Copy> {
 
                 if let Some(inc_value) = op_inc_value {
                     // if the index is in include, we definitely want to include this index
-                    return if is_ellipsis_like(inc_value) {
+                    return if is_ellipsis_like(&inc_value) {
                         Ok(Some((None, next_exclude)))
                     } else {
                         Ok(Some((Some(inc_value), next_exclude)))
@@ -262,10 +267,10 @@ impl AnyFilter {
 
     pub fn key_filter<'py>(
         &self,
-        key: &PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+        key: &Bound<'_, PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
         // just use 0 for the int_key, it's always ignored in the implementation here
         self.filter(key, 0, include, exclude)
     }
@@ -273,25 +278,25 @@ impl AnyFilter {
     pub fn index_filter<'py>(
         &self,
         index: usize,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         len: Option<usize>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+    ) -> PyResult<NextFilters<'py>> {
         let include = include.map(|v| map_negative_indices(v, len)).transpose()?;
         let exclude = exclude.map(|v| map_negative_indices(v, len)).transpose()?;
-        self.filter(index, index, include, exclude)
+        self.filter(index, index, include.as_ref(), exclude.as_ref())
     }
 }
 
 /// if a `__contains__` method exists, call it with the key and `__all__`, and return the result
 /// if it doesn't exist, or calling it fails (e.g. it's not a function), return `None`
-fn check_contains(obj: &PyAny, py_key: impl ToPyObject + Copy) -> PyResult<Option<bool>> {
+fn check_contains(obj: &Bound<'_, PyAny>, py_key: impl ToPyObject + Copy) -> PyResult<Option<bool>> {
     let py = obj.py();
     match obj.getattr(intern!(py, "__contains__")) {
         Ok(contains_method) => {
             if let Ok(result) = contains_method.call1((py_key.to_object(py),)) {
                 Ok(Some(
-                    result.is_true()? || contains_method.call1((intern!(py, "__all__"),))?.is_true()?,
+                    result.is_truthy()? || contains_method.call1((intern!(py, "__all__"),))?.is_truthy()?,
                 ))
             } else {
                 Ok(None)
@@ -315,8 +320,8 @@ where
 }
 
 /// detect both ellipsis and `True` to be compatible with pydantic V1
-fn is_ellipsis_like(v: &PyAny) -> bool {
-    v.is_ellipsis()
+fn is_ellipsis_like(v: &Bound<'_, PyAny>) -> bool {
+    v.is(&v.py().Ellipsis())
         || match v.downcast::<PyBool>() {
             Ok(b) => b.is_true(),
             Err(_) => false,
@@ -324,33 +329,36 @@ fn is_ellipsis_like(v: &PyAny) -> bool {
 }
 
 /// lookup the dict, for the key and "__all__" key, and merge them following the same rules as pydantic V1
-fn merge_all_value(dict: &PyDict, py_key: impl ToPyObject + Copy) -> PyResult<Option<&PyAny>> {
+fn merge_all_value<'py>(
+    dict: &Bound<'py, PyDict>,
+    py_key: impl ToPyObject + Copy,
+) -> PyResult<Option<Bound<'py, PyAny>>> {
     let op_item_value = dict.get_item(py_key)?;
     let op_all_value = dict.get_item(intern!(dict.py(), "__all__"))?;
 
     match (op_item_value, op_all_value) {
         (Some(item_value), Some(all_value)) => {
-            if is_ellipsis_like(item_value) || is_ellipsis_like(all_value) {
-                Ok(op_item_value)
+            if is_ellipsis_like(&item_value) || is_ellipsis_like(&all_value) {
+                Ok(Some(item_value))
             } else {
-                let item_dict = as_dict(item_value)?;
-                let item_dict_merged = merge_dicts(item_dict, all_value)?;
-                Ok(Some(item_dict_merged))
+                let item_dict = as_dict(&item_value)?;
+                let item_dict_merged = merge_dicts(&item_dict, &all_value)?;
+                Ok(Some(item_dict_merged.into_any()))
             }
         }
-        (Some(_), None) => Ok(op_item_value),
-        (None, Some(_)) => Ok(op_all_value),
+        (op_item_value @ Some(_), None) => Ok(op_item_value),
+        (None, op_all_value @ Some(_)) => Ok(op_all_value),
         (None, None) => Ok(None),
     }
 }
 
-fn as_dict(value: &PyAny) -> PyResult<&PyDict> {
+fn as_dict<'py>(value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
     if let Ok(dict) = value.downcast::<PyDict>() {
         dict.copy()
     } else if let Ok(set) = value.downcast::<PySet>() {
         let py = value.py();
-        let dict = PyDict::new(py);
-        for item in set {
+        let dict = PyDict::new_bound(py);
+        for item in set.iter() {
             dict.set_item(item, py.Ellipsis())?;
         }
         Ok(dict)
@@ -361,26 +369,26 @@ fn as_dict(value: &PyAny) -> PyResult<&PyDict> {
     }
 }
 
-fn merge_dicts<'py>(item_dict: &'py PyDict, all_value: &'py PyAny) -> PyResult<&'py PyDict> {
+fn merge_dicts<'py>(item_dict: &Bound<'py, PyDict>, all_value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
     let item_dict = item_dict.copy()?;
     if let Ok(all_dict) = all_value.downcast::<PyDict>() {
-        for (all_key, all_value) in all_dict {
-            if let Some(item_value) = item_dict.get_item(all_key)? {
-                if is_ellipsis_like(item_value) {
+        for (all_key, all_value) in all_dict.iter() {
+            if let Some(item_value) = item_dict.get_item(&all_key)? {
+                if is_ellipsis_like(&item_value) {
                     continue;
                 }
-                let item_value_dict = as_dict(item_value)?;
+                let item_value_dict = as_dict(&item_value)?;
                 // if the all value is an ellipsis, we don't overwrite the item value
-                if !is_ellipsis_like(all_value) {
-                    item_dict.set_item(all_key, merge_dicts(item_value_dict, all_value)?)?;
+                if !is_ellipsis_like(&all_value) {
+                    item_dict.set_item(all_key, merge_dicts(&item_value_dict, &all_value)?)?;
                 }
             } else {
                 item_dict.set_item(all_key, all_value)?;
             }
         }
     } else if let Ok(set) = all_value.downcast::<PySet>() {
-        for item in set {
-            if !item_dict.contains(item)? {
+        for item in set.iter() {
+            if !item_dict.contains(&item)? {
                 item_dict.set_item(item, set.py().Ellipsis())?;
             }
         }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 98ffc72b2..8be6bfd22 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -3,9 +3,8 @@ use std::borrow::Cow;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{
-    PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTime, PyTuple,
-};
+use pyo3::pybacked::PyBackedStr;
+use pyo3::types::{PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTuple};
 
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
@@ -23,9 +22,9 @@ use super::shared::{any_dataclass_iter, PydanticSerializer, TypeSerializer};
 use super::SchemaSerializer;
 
 pub(crate) fn infer_to_python(
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> PyResult<PyObject> {
     infer_to_python_known(extra.ob_type_lookup.get_type(value), value, include, exclude, extra)
@@ -37,9 +36,9 @@ const INFER_DEF_REF_ID: usize = usize::MAX;
 
 pub(crate) fn infer_to_python_known(
     ob_type: ObType,
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     mut extra: &Extra,
 ) -> PyResult<PyObject> {
     let py = value.py();
@@ -62,14 +61,14 @@ pub(crate) fn infer_to_python_known(
             value
                 .downcast::<$t>()?
                 .iter()
-                .map(|v| infer_to_python(v, None, None, extra))
+                .map(|v| infer_to_python(&v, None, None, extra))
                 .collect::<PyResult<Vec<PyObject>>>()?
         };
     }
 
     macro_rules! serialize_seq_filter {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast()?;
+            let py_seq = value.downcast::<$t>()?;
             let mut items = Vec::with_capacity(py_seq.len());
             let filter = AnyFilter::new();
             let len = value.len().ok();
@@ -77,7 +76,12 @@ pub(crate) fn infer_to_python_known(
             for (index, element) in py_seq.iter().enumerate() {
                 let op_next = filter.index_filter(index, include, exclude, len)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    items.push(infer_to_python(element, next_include, next_exclude, extra)?);
+                    items.push(infer_to_python(
+                        &element,
+                        next_include.as_ref(),
+                        next_exclude.as_ref(),
+                        extra,
+                    )?);
                 }
             }
             items
@@ -116,19 +120,19 @@ pub(crate) fn infer_to_python_known(
             ObType::Float | ObType::FloatSubclass => {
                 let v = value.extract::<f64>()?;
                 if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
-                    return Ok(py.None());
+                    return Ok(py.None().into_py(py));
                 }
                 v.into_py(py)
             }
             ObType::Decimal => value.to_string().into_py(py),
-            ObType::StrSubclass => value.extract::<&str>()?.into_py(py),
+            ObType::StrSubclass => value.downcast::<PyString>()?.to_str()?.into_py(py),
             ObType::Bytes => extra
                 .config
                 .bytes_mode
                 .bytes_to_string(py, value.downcast::<PyBytes>()?.as_bytes())
                 .map(|s| s.into_py(py))?,
             ObType::Bytearray => {
-                let py_byte_array: &PyByteArray = value.downcast()?;
+                let py_byte_array = value.downcast::<PyByteArray>()?;
                 // Safety: the GIL is held while bytes_to_string is running; it doesn't run
                 // arbitrary Python code, so py_byte_array cannot be mutated.
                 let bytes = unsafe { py_byte_array.as_bytes() };
@@ -140,39 +144,36 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Dict => {
-                let dict: &PyDict = value.downcast()?;
+                let dict = value.downcast::<PyDict>()?;
                 serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, |k| {
-                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Datetime => {
-                let py_dt: &PyDateTime = value.downcast()?;
-                let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt)?;
+                let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(value.downcast()?)?;
                 iso_dt.into_py(py)
             }
             ObType::Date => {
-                let py_date: &PyDate = value.downcast()?;
-                let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date)?;
+                let iso_date = super::type_serializers::datetime_etc::date_to_string(value.downcast()?)?;
                 iso_date.into_py(py)
             }
             ObType::Time => {
-                let py_time: &PyTime = value.downcast()?;
-                let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time)?;
+                let iso_time = super::type_serializers::datetime_etc::time_to_string(value.downcast()?)?;
                 iso_time.into_py(py)
             }
             ObType::Timedelta => {
@@ -191,22 +192,21 @@ pub(crate) fn infer_to_python_known(
                 py_url.__str__().into_py(py)
             }
             ObType::Uuid => {
-                let py_uuid: &PyAny = value.downcast()?;
-                let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid)?;
+                let uuid = super::type_serializers::uuid::uuid_to_string(value)?;
                 uuid.into_py(py)
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
             ObType::Dataclass => {
                 serialize_pairs_python(py, any_dataclass_iter(value)?.0, include, exclude, extra, |k| {
-                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Enum => {
                 let v = value.getattr(intern!(py, "value"))?;
-                infer_to_python(v, include, exclude, extra)?.into_py(py)
+                infer_to_python(&v, include, exclude, extra)?.into_py(py)
             }
             ObType::Generator => {
-                let py_seq: &PyIterator = value.downcast()?;
+                let py_seq = value.downcast::<PyIterator>()?;
                 let mut items = Vec::new();
                 let filter = AnyFilter::new();
 
@@ -214,17 +214,22 @@ pub(crate) fn infer_to_python_known(
                     let element = r?;
                     let op_next = filter.index_filter(index, include, exclude, None)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        items.push(infer_to_python(element, next_include, next_exclude, extra)?);
+                        items.push(infer_to_python(
+                            &element,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        )?);
                     }
                 }
-                PyList::new(py, items).into_py(py)
+                PyList::new_bound(py, items).into_py(py)
             }
             ObType::Path => value.str()?.into_py(py),
             ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
-                    let next_result = infer_to_python(next_value, include, exclude, extra);
+                    let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 } else if extra.serialize_unknown {
                     serialize_unknown(value).into_py(py)
@@ -236,22 +241,22 @@ pub(crate) fn infer_to_python_known(
         _ => match ob_type {
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyTuple::new(py, elements).into_py(py)
+                PyTuple::new_bound(py, elements).into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PySet::new(py, &elements)?.into_py(py)
+                PySet::new_bound(py, &elements)?.into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyFrozenSet::new(py, &elements)?.into_py(py)
+                PyFrozenSet::new_bound(py, &elements)?.into_py(py)
             }
             ObType::Dict => {
-                let dict: &PyDict = value.downcast()?;
+                let dict = value.downcast::<PyDict>()?;
                 serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, Ok)?
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
@@ -270,7 +275,7 @@ pub(crate) fn infer_to_python_known(
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
-                    let next_result = infer_to_python(next_value, include, exclude, extra);
+                    let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 }
                 value.into_py(py)
@@ -282,17 +287,17 @@ pub(crate) fn infer_to_python_known(
 }
 
 pub(crate) struct SerializeInfer<'py> {
-    value: &'py PyAny,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    value: &'py Bound<'py, PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
 impl<'py> SerializeInfer<'py> {
     pub(crate) fn new(
-        value: &'py PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        value: &'py Bound<'py, PyAny>,
+        include: Option<&'py Bound<'py, PyAny>>,
+        exclude: Option<&'py Bound<'py, PyAny>>,
         extra: &'py Extra,
     ) -> Self {
         Self {
@@ -312,10 +317,10 @@ impl<'py> Serialize for SerializeInfer<'py> {
 }
 
 pub(crate) fn infer_serialize<S: Serializer>(
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     infer_serialize_known(
@@ -330,10 +335,10 @@ pub(crate) fn infer_serialize<S: Serializer>(
 
 pub(crate) fn infer_serialize_known<S: Serializer>(
     ob_type: ObType,
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     mut extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     let extra_serialize_unknown = extra.serialize_unknown;
@@ -360,10 +365,10 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
 
     macro_rules! serialize_seq {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<$t>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(Some(py_seq.len()))?;
-            for element in py_seq {
-                let item_serializer = SerializeInfer::new(element, include, exclude, extra);
+            for element in py_seq.iter() {
+                let item_serializer = SerializeInfer::new(&element, include, exclude, extra);
                 seq.serialize_element(&item_serializer)?
             }
             seq.end()
@@ -372,7 +377,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
 
     macro_rules! serialize_seq_filter {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<$t>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(Some(py_seq.len()))?;
             let filter = AnyFilter::new();
             let len = value.len().ok();
@@ -382,7 +387,8 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                     .index_filter(index, include, exclude, len)
                     .map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    let item_serializer = SerializeInfer::new(element, next_include, next_exclude, extra);
+                    let item_serializer =
+                        SerializeInfer::new(&element, next_include.as_ref(), next_exclude.as_ref(), extra);
                     seq.serialize_element(&item_serializer)?
                 }
             }
@@ -397,15 +403,15 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Float | ObType::FloatSubclass => serialize!(f64),
         ObType::Decimal => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
-            let py_str: &PyString = value.downcast().map_err(py_err_se_err)?;
+            let py_str = value.downcast::<PyString>().map_err(py_err_se_err)?;
             super::type_serializers::string::serialize_py_str(py_str, serializer)
         }
         ObType::Bytes => {
-            let py_bytes: &PyBytes = value.downcast().map_err(py_err_se_err)?;
+            let py_bytes = value.downcast::<PyBytes>().map_err(py_err_se_err)?;
             extra.config.bytes_mode.serialize_bytes(py_bytes.as_bytes(), serializer)
         }
         ObType::Bytearray => {
-            let py_byte_array: &PyByteArray = value.downcast().map_err(py_err_se_err)?;
+            let py_byte_array = value.downcast::<PyByteArray>().map_err(py_err_se_err)?;
             // Safety: the GIL is held while serialize_bytes is running; it doesn't run
             // arbitrary Python code, so py_byte_array cannot be mutated.
             extra
@@ -422,17 +428,17 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Set => serialize_seq!(PySet),
         ObType::Frozenset => serialize_seq!(PyFrozenSet),
         ObType::Datetime => {
-            let py_dt: &PyDateTime = value.downcast().map_err(py_err_se_err)?;
+            let py_dt = value.downcast().map_err(py_err_se_err)?;
             let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_dt)
         }
         ObType::Date => {
-            let py_date: &PyDate = value.downcast().map_err(py_err_se_err)?;
+            let py_date = value.downcast().map_err(py_err_se_err)?;
             let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_date)
         }
         ObType::Time => {
-            let py_time: &PyTime = value.downcast().map_err(py_err_se_err)?;
+            let py_time = value.downcast().map_err(py_err_se_err)?;
             let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_time)
         }
@@ -480,16 +486,15 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             serialize_pairs_json(pairs_iter, fields_dict.len(), serializer, include, exclude, extra)
         }
         ObType::Uuid => {
-            let py_uuid: &PyAny = value.downcast().map_err(py_err_se_err)?;
-            let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid).map_err(py_err_se_err)?;
+            let uuid = super::type_serializers::uuid::uuid_to_string(value).map_err(py_err_se_err)?;
             serializer.serialize_str(&uuid)
         }
         ObType::Enum => {
             let v = value.getattr(intern!(value.py(), "value")).map_err(py_err_se_err)?;
-            infer_serialize(v, serializer, include, exclude, extra)
+            infer_serialize(&v, serializer, include, exclude, extra)
         }
         ObType::Generator => {
-            let py_seq: &PyIterator = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<PyIterator>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(None)?;
             let filter = AnyFilter::new();
             for (index, r) in py_seq.iter().map_err(py_err_se_err)?.enumerate() {
@@ -498,30 +503,31 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                     .index_filter(index, include, exclude, None)
                     .map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    let item_serializer = SerializeInfer::new(element, next_include, next_exclude, extra);
+                    let item_serializer =
+                        SerializeInfer::new(&element, next_include.as_ref(), next_exclude.as_ref(), extra);
                     seq.serialize_element(&item_serializer)?;
                 }
             }
             seq.end()
         }
         ObType::Path => {
-            let s = value.str().map_err(py_err_se_err)?.to_str().map_err(py_err_se_err)?;
-            serializer.serialize_str(s)
+            let s: PyBackedStr = value
+                .str()
+                .and_then(|value_str| value_str.extract())
+                .map_err(py_err_se_err)?;
+            serializer.serialize_str(&s)
         }
         ObType::Pattern => {
-            let s = value
+            let s: PyBackedStr = value
                 .getattr(intern!(value.py(), "pattern"))
-                .map_err(py_err_se_err)?
-                .str()
-                .map_err(py_err_se_err)?
-                .to_str()
+                .and_then(|pattern| pattern.str()?.extract())
                 .map_err(py_err_se_err)?;
-            serializer.serialize_str(s)
+            serializer.serialize_str(&s)
         }
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_value = fallback.call1((value,)).map_err(py_err_se_err)?;
-                let next_result = infer_serialize(next_value, serializer, include, exclude, extra);
+                let next_result = infer_serialize(&next_value, serializer, include, exclude, extra);
                 return next_result;
             } else if extra.serialize_unknown {
                 serializer.serialize_str(&serialize_unknown(value))
@@ -529,7 +535,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 let msg = format!(
                     "{}Unable to serialize unknown type: {}",
                     SERIALIZATION_ERR_MARKER,
-                    safe_repr(value.get_type()),
+                    safe_repr(&value.get_type()),
                 );
                 return Err(S::Error::custom(msg));
             }
@@ -538,29 +544,33 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
     ser_result
 }
 
-fn unknown_type_error(value: &PyAny) -> PyErr {
+fn unknown_type_error(value: &Bound<'_, PyAny>) -> PyErr {
     PydanticSerializationError::new_err(format!(
         "Unable to serialize unknown type: {}",
-        safe_repr(value.get_type())
+        safe_repr(&value.get_type())
     ))
 }
 
-fn serialize_unknown(value: &PyAny) -> Cow<str> {
+fn serialize_unknown<'py>(value: &Bound<'py, PyAny>) -> Cow<'py, str> {
     if let Ok(s) = value.str() {
-        s.to_string_lossy()
-    } else if let Ok(name) = value.get_type().name() {
+        s.to_string_lossy().into_owned().into()
+    } else if let Ok(name) = value.get_type().qualname() {
         format!("<Unserializable {name} object>").into()
     } else {
         "<Unserializable object>".into()
     }
 }
 
-pub(crate) fn infer_json_key<'py>(key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+pub(crate) fn infer_json_key<'a>(key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
     let ob_type = extra.ob_type_lookup.get_type(key);
     infer_json_key_known(ob_type, key, extra)
 }
 
-pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+pub(crate) fn infer_json_key_known<'a>(
+    ob_type: ObType,
+    key: &'a Bound<'_, PyAny>,
+    extra: &Extra,
+) -> PyResult<Cow<'a, str>> {
     match ob_type {
         ObType::None => super::type_serializers::simple::none_json_key(),
         ObType::Int | ObType::IntSubclass | ObType::Float | ObType::FloatSubclass => {
@@ -569,15 +579,17 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         ObType::Decimal => Ok(Cow::Owned(key.to_string())),
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
         ObType::Str | ObType::StrSubclass => {
-            let py_str: &PyString = key.downcast()?;
-            Ok(Cow::Borrowed(py_str.to_str()?))
+            let py_str = key.downcast::<PyString>()?;
+            Ok(Cow::Owned(py_str.to_str()?.to_string()))
         }
         ObType::Bytes => extra
             .config
             .bytes_mode
-            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes()),
+            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes())
+            // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
+            .map(|s| Cow::Owned(s.into_owned())),
         ObType::Bytearray => {
-            let py_byte_array: &PyByteArray = key.downcast()?;
+            let py_byte_array = key.downcast::<PyByteArray>()?;
             // Safety: the GIL is held while serialize_bytes is running; it doesn't run
             // arbitrary Python code, so py_byte_array cannot be mutated during the call.
             //
@@ -589,23 +601,19 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
                 .map(|cow| Cow::Owned(cow.into_owned()))
         }
         ObType::Datetime => {
-            let py_dt: &PyDateTime = key.downcast()?;
-            let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt)?;
+            let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_dt))
         }
         ObType::Date => {
-            let py_date: &PyDate = key.downcast()?;
-            let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date)?;
+            let iso_date = super::type_serializers::datetime_etc::date_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_date))
         }
         ObType::Time => {
-            let py_time: &PyTime = key.downcast()?;
-            let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time)?;
+            let iso_time = super::type_serializers::datetime_etc::time_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_time))
         }
         ObType::Uuid => {
-            let py_uuid: &PyAny = key.downcast()?;
-            let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid)?;
+            let uuid = super::type_serializers::uuid::uuid_to_string(key)?;
             Ok(Cow::Owned(uuid))
         }
         ObType::Timedelta => {
@@ -622,8 +630,8 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         }
         ObType::Tuple => {
             let mut key_build = super::type_serializers::tuple::KeyBuilder::new();
-            for element in key.downcast::<PyTuple>()? {
-                key_build.push(&infer_json_key(element, extra)?);
+            for element in key.downcast::<PyTuple>()?.iter_borrowed() {
+                key_build.push(&infer_json_key(&element, extra)?);
             }
             Ok(Cow::Owned(key_build.finish()))
         }
@@ -638,16 +646,22 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         }
         ObType::Enum => {
             let k = key.getattr(intern!(key.py(), "value"))?;
-            infer_json_key(k, extra)
+            infer_json_key(&k, extra).map(|cow| Cow::Owned(cow.into_owned()))
         }
-        ObType::Path => Ok(key.str()?.to_string_lossy()),
-        ObType::Pattern => Ok(key.getattr(intern!(key.py(), "pattern"))?.str()?.to_string_lossy()),
+        ObType::Path => {
+            // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
+            Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
+        }
+        ObType::Pattern => Ok(Cow::Owned(
+            key.getattr(intern!(key.py(), "pattern"))?
+                .str()?
+                .to_string_lossy()
+                .into_owned(),
+        )),
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_key = fallback.call1((key,))?;
-                // totally unnecessary step to placate rust's lifetime rules
-                let next_key = next_key.to_object(key.py()).into_ref(key.py());
-                infer_json_key(next_key, extra)
+                infer_json_key(&next_key, extra).map(|cow| Cow::Owned(cow.into_owned()))
             } else if extra.serialize_unknown {
                 Ok(serialize_unknown(key))
             } else {
@@ -659,21 +673,21 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
 
 fn serialize_pairs_python<'py>(
     py: Python,
-    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    pairs_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
-    key_transform: impl Fn(&'py PyAny) -> PyResult<&'py PyAny>,
+    key_transform: impl Fn(Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>>,
 ) -> PyResult<PyObject> {
-    let new_dict = PyDict::new(py);
+    let new_dict = PyDict::new_bound(py);
     let filter = AnyFilter::new();
 
     for result in pairs_iter {
         let (k, v) = result?;
-        let op_next = filter.key_filter(k, include, exclude)?;
+        let op_next = filter.key_filter(&k, include, exclude)?;
         if let Some((next_include, next_exclude)) = op_next {
             let k = key_transform(k)?;
-            let v = infer_to_python(v, next_include, next_exclude, extra)?;
+            let v = infer_to_python(&v, next_include.as_ref(), next_exclude.as_ref(), extra)?;
             new_dict.set_item(k, v)?;
         }
     }
@@ -681,11 +695,11 @@ fn serialize_pairs_python<'py>(
 }
 
 fn serialize_pairs_json<'py, S: Serializer>(
-    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+    pairs_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
     iter_size: usize,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     let mut map = serializer.serialize_map(Some(iter_size))?;
@@ -694,10 +708,10 @@ fn serialize_pairs_json<'py, S: Serializer>(
     for result in pairs_iter {
         let (key, value) = result.map_err(py_err_se_err)?;
 
-        let op_next = filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+        let op_next = filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
         if let Some((next_include, next_exclude)) = op_next {
-            let key = infer_json_key(key, extra).map_err(py_err_se_err)?;
-            let value_serializer = SerializeInfer::new(value, next_include, next_exclude, extra);
+            let key = infer_json_key(&key, extra).map_err(py_err_se_err)?;
+            let value_serializer = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), extra);
             map.serialize_entry(&key, &value_serializer)?;
         }
     }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 3ed47a0a8..aef5be702 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -54,8 +54,8 @@ impl SchemaSerializer {
         round_trip: bool,
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
-        fallback: Option<&'a PyAny>,
-        context: Option<&'a PyAny>,
+        fallback: Option<&'a Bound<'a, PyAny>>,
+        context: Option<&'a Bound<'a, PyAny>>,
     ) -> Extra<'b> {
         Extra::new(
             py,
@@ -78,7 +78,7 @@ impl SchemaSerializer {
 #[pymethods]
 impl SchemaSerializer {
     #[new]
-    pub fn py_new(py: Python, schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(schema: Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
         let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
         Ok(Self {
@@ -86,9 +86,9 @@ impl SchemaSerializer {
             definitions: definitions_builder.finish()?,
             expected_json_size: AtomicUsize::new(1024),
             config: SerializationConfig::from_config(config)?,
-            py_schema: schema.into_py(py),
+            py_schema: schema.into(),
             py_config: match config {
-                Some(c) if !c.is_empty() => Some(c.into_py(py)),
+                Some(c) if !c.is_empty() => Some(c.clone().into()),
                 _ => None,
             },
         })
@@ -101,18 +101,18 @@ impl SchemaSerializer {
     pub fn to_python(
         &self,
         py: Python,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         mode: Option<&str>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         by_alias: bool,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
         warnings: bool,
-        fallback: Option<&PyAny>,
-        context: Option<&PyAny>,
+        fallback: Option<&Bound<'_, PyAny>>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
         let warnings = CollectWarnings::new(warnings);
@@ -143,18 +143,18 @@ impl SchemaSerializer {
     pub fn to_json(
         &self,
         py: Python,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         indent: Option<usize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         by_alias: bool,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
         warnings: bool,
-        fallback: Option<&PyAny>,
-        context: Option<&PyAny>,
+        fallback: Option<&Bound<'_, PyAny>>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let warnings = CollectWarnings::new(warnings);
         let rec_guard = SerRecursionState::default();
@@ -185,11 +185,11 @@ impl SchemaSerializer {
         warnings.final_check(py)?;
 
         self.expected_json_size.store(bytes.len(), Ordering::Relaxed);
-        let py_bytes = PyBytes::new(py, &bytes);
+        let py_bytes = PyBytes::new_bound(py, &bytes);
         Ok(py_bytes.into())
     }
 
-    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
         // Enables support for `pickle` serialization.
         let py = slf.py();
         let cls = slf.get_type().into();
@@ -222,10 +222,10 @@ impl SchemaSerializer {
     inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_json(
     py: Python,
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     indent: Option<usize>,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
@@ -233,8 +233,8 @@ pub fn to_json(
     bytes_mode: &str,
     inf_nan_mode: &str,
     serialize_unknown: bool,
-    fallback: Option<&PyAny>,
-    context: Option<&PyAny>,
+    fallback: Option<&Bound<'_, PyAny>>,
+    context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
@@ -250,7 +250,7 @@ pub fn to_json(
     let serializer = type_serializers::any::AnySerializer.into();
     let bytes = to_json_bytes(value, &serializer, include, exclude, &extra, indent, 1024)?;
     state.final_check(py)?;
-    let py_bytes = PyBytes::new(py, &bytes);
+    let py_bytes = PyBytes::new_bound(py, &bytes);
     Ok(py_bytes.into())
 }
 
@@ -260,9 +260,9 @@ pub fn to_json(
     timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_jsonable_python(
     py: Python,
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
@@ -270,8 +270,8 @@ pub fn to_jsonable_python(
     bytes_mode: &str,
     inf_nan_mode: &str,
     serialize_unknown: bool,
-    fallback: Option<&PyAny>,
-    context: Option<&PyAny>,
+    fallback: Option<&Bound<'_, PyAny>>,
+    context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 924de001b..1eaa090a8 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -1,10 +1,10 @@
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PySet, PyString, PyTime, PyTuple, PyType,
+    PyNone, PySet, PyString, PyTime, PyTuple, PyType,
 };
-use pyo3::{intern, AsPyPointer, PyTypeInfo};
+use pyo3::{intern, PyTypeInfo};
 
 use strum::Display;
 use strum_macros::EnumString;
@@ -62,13 +62,18 @@ pub enum IsType {
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
         Self {
-            none: py.None().as_ref(py).get_type_ptr() as usize,
+            none: PyNone::type_object_raw(py) as usize,
             int: PyInt::type_object_raw(py) as usize,
             bool: PyBool::type_object_raw(py) as usize,
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().to_object(py),
+            decimal_object: py
+                .import_bound("decimal")
+                .unwrap()
+                .getattr("Decimal")
+                .unwrap()
+                .to_object(py),
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -81,16 +86,21 @@ impl ObTypeLookup {
             timedelta: PyDelta::type_object_raw(py) as usize,
             url: PyUrl::type_object_raw(py) as usize,
             multi_host_url: PyMultiHostUrl::type_object_raw(py) as usize,
-            enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().to_object(py),
+            enum_object: py.import_bound("enum").unwrap().getattr("Enum").unwrap().to_object(py),
             generator_object: py
-                .import("types")
+                .import_bound("types")
                 .unwrap()
                 .getattr("GeneratorType")
                 .unwrap()
                 .to_object(py),
-            path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().to_object(py),
-            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().to_object(py),
-            uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
+            path_object: py
+                .import_bound("pathlib")
+                .unwrap()
+                .getattr("Path")
+                .unwrap()
+                .to_object(py),
+            pattern_object: py.import_bound("re").unwrap().getattr("Pattern").unwrap().to_object(py),
+            uuid_object: py.import_bound("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
         }
     }
 
@@ -98,8 +108,8 @@ impl ObTypeLookup {
         TYPE_LOOKUP.get_or_init(py, || Self::new(py))
     }
 
-    pub fn is_type(&self, value: &PyAny, expected_ob_type: ObType) -> IsType {
-        match self.ob_type_is_expected(Some(value), value.get_type(), &expected_ob_type) {
+    pub fn is_type(&self, value: &Bound<'_, PyAny>, expected_ob_type: ObType) -> IsType {
+        match self.ob_type_is_expected(Some(value), &value.get_type(), &expected_ob_type) {
             IsType::False => {
                 if expected_ob_type == self.fallback_isinstance(value) {
                     IsType::Subclass
@@ -111,7 +121,12 @@ impl ObTypeLookup {
         }
     }
 
-    fn ob_type_is_expected(&self, op_value: Option<&PyAny>, py_type: &PyType, expected_ob_type: &ObType) -> IsType {
+    fn ob_type_is_expected(
+        &self,
+        op_value: Option<&Bound<'_, PyAny>>,
+        py_type: &Bound<'_, PyType>,
+        expected_ob_type: &ObType,
+    ) -> IsType {
         let type_ptr = py_type.as_ptr();
         let ob_type = type_ptr as usize;
         let ans = match expected_ob_type {
@@ -166,7 +181,7 @@ impl ObTypeLookup {
             // it's not null
             match get_base_type(py_type) {
                 // as below, we don't want to tests for dataclass etc. again, so we pass None as op_value
-                Some(base_type) => match self.ob_type_is_expected(None, base_type, expected_ob_type) {
+                Some(base_type) => match self.ob_type_is_expected(None, &base_type, expected_ob_type) {
                     IsType::False => IsType::False,
                     _ => IsType::Subclass,
                 },
@@ -175,14 +190,14 @@ impl ObTypeLookup {
         }
     }
 
-    pub fn get_type(&self, value: &PyAny) -> ObType {
-        match self.lookup_by_ob_type(Some(value), value.get_type()) {
+    pub fn get_type(&self, value: &Bound<'_, PyAny>) -> ObType {
+        match self.lookup_by_ob_type(Some(value), &value.get_type()) {
             ObType::Unknown => self.fallback_isinstance(value),
             ob_type => ob_type,
         }
     }
 
-    fn lookup_by_ob_type(&self, op_value: Option<&PyAny>, py_type: &PyType) -> ObType {
+    fn lookup_by_ob_type(&self, op_value: Option<&Bound<'_, PyAny>>, py_type: &Bound<'_, PyType>) -> ObType {
         let ob_type = py_type.as_ptr() as usize;
         // this should be pretty fast, but still order is a bit important, so the most common types should come first
         // thus we don't follow the order of ObType
@@ -253,18 +268,18 @@ impl ObTypeLookup {
             // if `ob_type` didn't match any member of self, we try again with the next base type pointer
             match get_base_type(py_type) {
                 // we don't want to tests for dataclass etc. again, so we pass None as op_value
-                Some(base_type) => self.lookup_by_ob_type(None, base_type),
+                Some(base_type) => self.lookup_by_ob_type(None, &base_type),
                 None => ObType::Unknown,
             }
         }
     }
 
-    fn is_enum(&self, op_value: Option<&PyAny>, py_type: &PyType) -> bool {
+    fn is_enum(&self, op_value: Option<&Bound<'_, PyAny>>, py_type: &Bound<'_, PyType>) -> bool {
         // only test on the type itself, not base types
         if op_value.is_some() {
-            let enum_meta_type = self.enum_object.as_ref(py_type.py()).get_type();
+            let enum_meta_type = self.enum_object.bind(py_type.py()).get_type();
             let meta_type = py_type.get_type();
-            meta_type.is(enum_meta_type)
+            meta_type.is(&enum_meta_type)
         } else {
             false
         }
@@ -279,53 +294,53 @@ impl ObTypeLookup {
     /// In addition, some types have inheritance set as a bitflag on the type object:
     /// https://github.com/python/cpython/blob/v3.12.0rc1/Include/object.h#L546-L553
     /// Hence they come first
-    fn fallback_isinstance(&self, value: &PyAny) -> ObType {
+    fn fallback_isinstance(&self, value: &Bound<'_, PyAny>) -> ObType {
         let py = value.py();
-        if PyInt::is_type_of(value) {
+        if value.is_instance_of::<PyInt>() {
             ObType::IntSubclass
-        } else if PyString::is_type_of(value) {
+        } else if value.is_instance_of::<PyString>() {
             ObType::StrSubclass
-        } else if PyBytes::is_type_of(value) {
+        } else if value.is_instance_of::<PyBytes>() {
             ObType::Bytes
-        } else if PyList::is_type_of(value) {
+        } else if value.is_instance_of::<PyList>() {
             ObType::List
-        } else if PyTuple::is_type_of(value) {
+        } else if value.is_instance_of::<PyTuple>() {
             ObType::Tuple
-        } else if PyDict::is_type_of(value) {
+        } else if value.is_instance_of::<PyDict>() {
             ObType::Dict
-        } else if PyBool::is_type_of(value) {
+        } else if value.is_instance_of::<PyBool>() {
             ObType::Bool
-        } else if PyFloat::is_type_of(value) {
+        } else if value.is_instance_of::<PyFloat>() {
             ObType::FloatSubclass
-        } else if PyByteArray::is_type_of(value) {
+        } else if value.is_instance_of::<PyByteArray>() {
             ObType::Bytearray
-        } else if PySet::is_type_of(value) {
+        } else if value.is_instance_of::<PySet>() {
             ObType::Set
-        } else if PyFrozenSet::is_type_of(value) {
+        } else if value.is_instance_of::<PyFrozenSet>() {
             ObType::Frozenset
-        } else if PyDateTime::is_type_of(value) {
+        } else if value.is_instance_of::<PyDateTime>() {
             ObType::Datetime
-        } else if PyDate::is_type_of(value) {
+        } else if value.is_instance_of::<PyDate>() {
             ObType::Date
-        } else if PyTime::is_type_of(value) {
+        } else if value.is_instance_of::<PyTime>() {
             ObType::Time
-        } else if PyDelta::is_type_of(value) {
+        } else if value.is_instance_of::<PyDelta>() {
             ObType::Timedelta
-        } else if PyUrl::is_type_of(value) {
+        } else if value.is_instance_of::<PyUrl>() {
             ObType::Url
-        } else if PyMultiHostUrl::is_type_of(value) {
+        } else if value.is_instance_of::<PyMultiHostUrl>() {
             ObType::MultiHostUrl
-        } else if value.is_instance(self.decimal_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.decimal_object.bind(py)).unwrap_or(false) {
             ObType::Decimal
-        } else if value.is_instance(self.uuid_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.uuid_object.bind(py)).unwrap_or(false) {
             ObType::Uuid
-        } else if value.is_instance(self.enum_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.enum_object.bind(py)).unwrap_or(false) {
             ObType::Enum
-        } else if value.is_instance(self.generator_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.generator_object.bind(py)).unwrap_or(false) {
             ObType::Generator
-        } else if value.is_instance(self.path_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.path_object.bind(py)).unwrap_or(false) {
             ObType::Path
-        } else if value.is_instance(self.pattern_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.pattern_object.bind(py)).unwrap_or(false) {
             ObType::Pattern
         } else {
             ObType::Unknown
@@ -333,7 +348,7 @@ impl ObTypeLookup {
     }
 }
 
-fn is_dataclass(op_value: Option<&PyAny>) -> bool {
+fn is_dataclass(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value
             .hasattr(intern!(value.py(), "__dataclass_fields__"))
@@ -344,7 +359,7 @@ fn is_dataclass(op_value: Option<&PyAny>) -> bool {
     }
 }
 
-fn is_pydantic_serializable(op_value: Option<&PyAny>) -> bool {
+fn is_pydantic_serializable(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value
             .hasattr(intern!(value.py(), "__pydantic_serializer__"))
@@ -355,7 +370,7 @@ fn is_pydantic_serializable(op_value: Option<&PyAny>) -> bool {
     }
 }
 
-fn is_generator(op_value: Option<&PyAny>) -> bool {
+fn is_generator(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value.downcast::<PyIterator>().is_ok()
     } else {
@@ -432,8 +447,12 @@ impl PartialEq for ObType {
     }
 }
 
-fn get_base_type(py_type: &PyType) -> Option<&PyType> {
+fn get_base_type<'py>(py_type: &Bound<'py, PyType>) -> Option<Bound<'py, PyType>> {
     let base_type_ptr = unsafe { (*py_type.as_type_ptr()).tp_base };
     // Safety: `base_type_ptr` must be a valid pointer to a Python type object, or null.
-    unsafe { py_type.py().from_borrowed_ptr_or_opt(base_type_ptr.cast()) }
+    if base_type_ptr.is_null() {
+        None
+    } else {
+        Some(unsafe { PyType::from_borrowed_type_ptr(py_type.py(), base_type_ptr) })
+    }
 }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 7cfe6ce6e..3607df6d6 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -2,8 +2,8 @@ use std::borrow::Cow;
 use std::fmt::Debug;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
@@ -27,8 +27,8 @@ pub(crate) trait BuildSerializer: Sized {
     const EXPECTED_TYPE: &'static str;
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer>;
 }
@@ -50,8 +50,8 @@ macro_rules! combined_serializer {
         impl CombinedSerializer {
             fn find_serializer(
                 lookup_type: &str,
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>
             ) -> PyResult<CombinedSerializer> {
                 match lookup_type {
@@ -146,16 +146,16 @@ combined_serializer! {
 
 impl CombinedSerializer {
     fn _build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let type_key = intern!(py, "type");
 
-        if let Some(ser_schema) = schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
-            let op_ser_type: Option<&str> = ser_schema.get_as(type_key)?;
-            match op_ser_type {
+        if let Some(ser_schema) = schema.get_as::<Bound<'_, PyDict>>(intern!(py, "serialization"))? {
+            let op_ser_type: Option<Bound<'_, PyString>> = ser_schema.get_as(type_key)?;
+            match op_ser_type.as_ref().map(|py_str| py_str.to_str()).transpose()? {
                 Some("function-plain") => {
                     // `function-plain` is a special case, not included in `find_serializer` since it means
                     // something different in `schema.type`
@@ -185,15 +185,15 @@ impl CombinedSerializer {
                 Some(ser_type) => {
                     // otherwise if `schema.serialization.type` is defined, use that with `find_serializer`
                     // instead of `schema.type`. In this case it's an error if a serializer isn't found.
-                    return Self::find_serializer(ser_type, ser_schema, config, definitions);
+                    return Self::find_serializer(ser_type, &ser_schema, config, definitions);
                 }
                 // if `schema.serialization.type` is None, fall back to `schema.type`
                 None => (),
             };
         }
 
-        let type_: &str = schema.get_as_req(type_key)?;
-        Self::find_serializer(type_, schema, config, definitions)
+        let type_: Bound<'_, PyString> = schema.get_as_req(type_key)?;
+        Self::find_serializer(type_.to_str()?, schema, config, definitions)
     }
 }
 
@@ -202,8 +202,8 @@ impl BuildSerializer for CombinedSerializer {
     const EXPECTED_TYPE: &'static str = "";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Self::_build(schema, config, definitions)
@@ -257,20 +257,20 @@ impl PyGcTraverse for CombinedSerializer {
 pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject>;
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>>;
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>>;
 
-    fn _invalid_as_json_key<'py>(
+    fn _invalid_as_json_key<'a>(
         &self,
-        key: &'py PyAny,
+        key: &'a Bound<'_, PyAny>,
         extra: &Extra,
         expected_type: &'static str,
-    ) -> PyResult<Cow<'py, str>> {
+    ) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact | IsType::Subclass => py_err!(PyTypeError; "`{}` not valid as object key", expected_type),
             IsType::False => {
@@ -282,10 +282,10 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error>;
 
@@ -302,19 +302,19 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
 }
 
 pub(crate) struct PydanticSerializer<'py> {
-    value: &'py PyAny,
+    value: &'py Bound<'py, PyAny>,
     serializer: &'py CombinedSerializer,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
 impl<'py> PydanticSerializer<'py> {
     pub(crate) fn new(
-        value: &'py PyAny,
+        value: &'py Bound<'py, PyAny>,
         serializer: &'py CombinedSerializer,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&'py Bound<'py, PyAny>>,
+        exclude: Option<&'py Bound<'py, PyAny>>,
         extra: &'py Extra<'py>,
     ) -> Self {
         Self {
@@ -336,10 +336,10 @@ impl<'py> Serialize for PydanticSerializer<'py> {
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn to_json_bytes(
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: &CombinedSerializer,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
     indent: Option<usize>,
     expected_json_size: usize,
@@ -364,18 +364,25 @@ pub(crate) fn to_json_bytes(
     Ok(bytes)
 }
 
-pub(super) fn any_dataclass_iter<'py>(
-    dataclass: &'py PyAny,
-) -> PyResult<(impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'py, &PyDict)> {
+pub(super) fn any_dataclass_iter<'a, 'py>(
+    dataclass: &'a Bound<'py, PyAny>,
+) -> PyResult<(
+    impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a,
+    Bound<'py, PyDict>,
+)>
+where
+    'py: 'a,
+{
     let py = dataclass.py();
-    let fields: &PyDict = dataclass.getattr(intern!(py, "__dataclass_fields__"))?.downcast()?;
+    let fields = dataclass
+        .getattr(intern!(py, "__dataclass_fields__"))?
+        .downcast_into::<PyDict>()?;
     let field_type_marker = get_field_marker(py)?;
 
-    let next = move |(field_name, field): (&'py PyAny, &'py PyAny)| -> PyResult<Option<(&'py PyAny, &'py PyAny)>> {
+    let next = move |(field_name, field): (Bound<'py, PyAny>, Bound<'py, PyAny>)| -> PyResult<Option<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> {
         let field_type = field.getattr(intern!(py, "_field_type"))?;
-        if field_type.is(field_type_marker) {
-            let field_name: &PyString = field_name.downcast()?;
-            let value = dataclass.getattr(field_name)?;
+        if field_type.is(&field_type_marker) {
+            let value = dataclass.getattr(field_name.downcast::<PyString>()?)?;
             Ok(Some((field_name, value)))
         } else {
             Ok(None)
@@ -388,9 +395,9 @@ pub(super) fn any_dataclass_iter<'py>(
 static DC_FIELD_MARKER: GILOnceCell<PyObject> = GILOnceCell::new();
 
 /// needed to match the logic from dataclasses.fields `tuple(f for f in fields.values() if f._field_type is _FIELD)`
-fn get_field_marker(py: Python<'_>) -> PyResult<&PyAny> {
+fn get_field_marker(py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
     let field_type_marker_obj = DC_FIELD_MARKER.get_or_try_init(py, || {
-        py.import("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
+        py.import_bound("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
     })?;
-    Ok(field_type_marker_obj.as_ref(py))
+    Ok(field_type_marker_obj.bind(py).clone())
 }
diff --git a/src/serializers/type_serializers/any.rs b/src/serializers/type_serializers/any.rs
index f8815f3ef..179e2885d 100644
--- a/src/serializers/type_serializers/any.rs
+++ b/src/serializers/type_serializers/any.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for AnySerializer {
     const EXPECTED_TYPE: &'static str = "any";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -31,24 +31,24 @@ impl_py_gc_traverse!(AnySerializer {});
 impl TypeSerializer for AnySerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         infer_to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         infer_json_key(key, extra)
     }
 
     fn serde_serialize<S: Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         infer_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/bytes.rs b/src/serializers/type_serializers/bytes.rs
index bd354aa75..4fc53e224 100644
--- a/src/serializers/type_serializers/bytes.rs
+++ b/src/serializers/type_serializers/bytes.rs
@@ -20,8 +20,8 @@ impl BuildSerializer for BytesSerializer {
     const EXPECTED_TYPE: &'static str = "bytes";
 
     fn build(
-        _schema: &PyDict,
-        config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let bytes_mode = BytesMode::from_config(config)?;
@@ -34,9 +34,9 @@ impl_py_gc_traverse!(BytesSerializer {});
 impl TypeSerializer for BytesSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -55,7 +55,7 @@ impl TypeSerializer for BytesSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match key.downcast::<PyBytes>() {
             Ok(py_bytes) => self.bytes_mode.bytes_to_string(key.py(), py_bytes.as_bytes()),
             Err(_) => {
@@ -67,10 +67,10 @@ impl TypeSerializer for BytesSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyBytes>() {
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 93548bcba..2c4954d4d 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -22,13 +22,13 @@ impl BuildSerializer for DataclassArgsBuilder {
     const EXPECTED_TYPE: &'static str = "dataclass-args";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let fields_list: &PyList = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_list: Bound<'_, PyList> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_list.len());
 
         let fields_mode = match ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)? {
@@ -37,16 +37,16 @@ impl BuildSerializer for DataclassArgsBuilder {
         };
 
         for (index, item) in fields_list.iter().enumerate() {
-            let field_info: &PyDict = item.downcast()?;
+            let field_info = item.downcast::<PyDict>()?;
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
 
-            let key_py: Py<PyString> = PyString::new(py, &name).into_py(py);
+            let key_py: Py<PyString> = PyString::new_bound(py, &name).into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(name, SerField::new(py, key_py, None, None, true));
             } else {
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
 
                 let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
@@ -72,8 +72,8 @@ impl BuildSerializer for DataclassSerializer {
     const EXPECTED_TYPE: &'static str = "dataclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -82,8 +82,8 @@ impl BuildSerializer for DataclassSerializer {
         let config = schema.get_as(intern!(py, "config"))?;
 
         let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config.as_ref(), definitions)?);
 
         let fields = schema
             .get_as_req::<&PyList>(intern!(py, "fields"))?
@@ -102,20 +102,20 @@ impl BuildSerializer for DataclassSerializer {
 }
 
 impl DataclassSerializer {
-    fn allow_value(&self, value: &PyAny, extra: &Extra) -> PyResult<bool> {
+    fn allow_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<bool> {
         match extra.check {
-            SerCheck::Strict => Ok(value.get_type().is(self.class.as_ref(value.py()))),
-            SerCheck::Lax => value.is_instance(self.class.as_ref(value.py())),
+            SerCheck::Strict => Ok(value.get_type().is(self.class.bind(value.py()))),
+            SerCheck::Lax => value.is_instance(self.class.bind(value.py())),
             SerCheck::None => value.hasattr(intern!(value.py(), "__dataclass_fields__")),
         }
     }
 
-    fn get_inner_value<'py>(&self, value: &'py PyAny) -> PyResult<&'py PyAny> {
+    fn get_inner_value<'py>(&self, value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         let py = value.py();
-        let dict = PyDict::new(py);
+        let dict = PyDict::new_bound(py);
 
         for field_name in &self.fields {
-            let field_name = field_name.as_ref(py);
+            let field_name = field_name.bind(py);
             dict.set_item(field_name, value.getattr(field_name)?)?;
         }
         Ok(dict)
@@ -127,9 +127,9 @@ impl_py_gc_traverse!(DataclassSerializer { class, serializer });
 impl TypeSerializer for DataclassSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let dc_extra = Extra {
@@ -147,11 +147,11 @@ impl TypeSerializer for DataclassSerializer {
                     dc_extra,
                 )?;
 
-                fields_serializer.add_computed_fields_python(Some(value), output_dict, include, exclude, extra)?;
+                fields_serializer.add_computed_fields_python(Some(value), &output_dict, include, exclude, extra)?;
                 Ok(output_dict.into_py(py))
             } else {
                 let inner_value = self.get_inner_value(value)?;
-                self.serializer.to_python(inner_value, include, exclude, &dc_extra)
+                self.serializer.to_python(&inner_value, include, exclude, &dc_extra)
             }
         } else {
             extra.warnings.on_fallback_py(self.get_name(), value, &dc_extra)?;
@@ -159,7 +159,7 @@ impl TypeSerializer for DataclassSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.allow_value(key, extra)? {
             infer_json_key_known(ObType::Dataclass, key, extra)
         } else {
@@ -170,10 +170,10 @@ impl TypeSerializer for DataclassSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let model = Some(value);
@@ -194,7 +194,7 @@ impl TypeSerializer for DataclassSerializer {
             } else {
                 let inner_value = self.get_inner_value(value).map_err(py_err_se_err)?;
                 self.serializer
-                    .serde_serialize(inner_value, serializer, include, exclude, extra)
+                    .serde_serialize(&inner_value, serializer, include, exclude, extra)
             }
         } else {
             extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
@@ -213,15 +213,14 @@ impl TypeSerializer for DataclassSerializer {
 
 fn known_dataclass_iter<'a, 'py>(
     fields: &'a [Py<PyString>],
-    dataclass: &'py PyAny,
-) -> impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'a
+    dataclass: &'a Bound<'py, PyAny>,
+) -> impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a
 where
     'py: 'a,
 {
     let py = dataclass.py();
     fields.iter().map(move |field| {
-        let field_ref = field.clone_ref(py).into_ref(py);
-        let value = dataclass.getattr(field_ref)?;
-        Ok((field_ref as &PyAny, value))
+        let value = dataclass.getattr(field)?;
+        Ok((field.bind(py).clone().into_any(), value))
     })
 }
diff --git a/src/serializers/type_serializers/datetime_etc.rs b/src/serializers/type_serializers/datetime_etc.rs
index f3b33208b..a042ae99b 100644
--- a/src/serializers/type_serializers/datetime_etc.rs
+++ b/src/serializers/type_serializers/datetime_etc.rs
@@ -12,19 +12,19 @@ use super::{
     SerMode, TypeSerializer,
 };
 
-pub(crate) fn datetime_to_string(py_dt: &PyDateTime) -> PyResult<String> {
+pub(crate) fn datetime_to_string(py_dt: &Bound<'_, PyDateTime>) -> PyResult<String> {
     pydatetime_as_datetime(py_dt).map(|dt| dt.to_string())
 }
 
-pub(crate) fn date_to_string(py_date: &PyDate) -> PyResult<String> {
+pub(crate) fn date_to_string(py_date: &Bound<'_, PyDate>) -> PyResult<String> {
     pydate_as_date(py_date).map(|dt| dt.to_string())
 }
 
-pub(crate) fn time_to_string(py_time: &PyTime) -> PyResult<String> {
+pub(crate) fn time_to_string(py_time: &Bound<'_, PyTime>) -> PyResult<String> {
     pytime_as_time(py_time, None).map(|dt| dt.to_string())
 }
 
-fn downcast_date_reject_datetime(py_date: &PyAny) -> PyResult<&PyDate> {
+fn downcast_date_reject_datetime<'a, 'py>(py_date: &'a Bound<'py, PyAny>) -> PyResult<&'a Bound<'py, PyDate>> {
     if let Ok(py_date) = py_date.downcast::<PyDate>() {
         // because `datetime` is a subclass of `date` we have to check that the value is not a
         // `datetime` to avoid lossy serialization
@@ -45,8 +45,8 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -58,9 +58,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -79,7 +79,7 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match $downcast(key) {
                     Ok(py_value) => Ok(Cow::Owned($convert_func(py_value)?)),
                     Err(_) => {
@@ -91,10 +91,10 @@ macro_rules! build_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match $downcast(value) {
@@ -121,8 +121,8 @@ macro_rules! build_serializer {
 build_serializer!(
     DatetimeSerializer,
     "datetime",
-    PyAny::downcast::<PyDateTime>,
+    PyAnyMethods::downcast::<PyDateTime>,
     datetime_to_string
 );
 build_serializer!(DateSerializer, "date", downcast_date_reject_datetime, date_to_string);
-build_serializer!(TimeSerializer, "time", PyAny::downcast::<PyTime>, time_to_string);
+build_serializer!(TimeSerializer, "time", PyAnyMethods::downcast::<PyTime>, time_to_string);
diff --git a/src/serializers/type_serializers/decimal.rs b/src/serializers/type_serializers/decimal.rs
index 674fd5577..6237f53cb 100644
--- a/src/serializers/type_serializers/decimal.rs
+++ b/src/serializers/type_serializers/decimal.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for DecimalSerializer {
     const EXPECTED_TYPE: &'static str = "decimal";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -31,9 +31,9 @@ impl_py_gc_traverse!(DecimalSerializer {});
 impl TypeSerializer for DecimalSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let _py = value.py();
@@ -46,7 +46,7 @@ impl TypeSerializer for DecimalSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Decimal) {
             IsType::Exact | IsType::Subclass => infer_json_key_known(ObType::Decimal, key, extra),
             IsType::False => {
@@ -58,10 +58,10 @@ impl TypeSerializer for DecimalSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::Decimal) {
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 3e2d48b19..071e50f8c 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedStr;
 use pyo3::types::{PyDict, PyList};
 
 use crate::definitions::DefinitionsBuilder;
@@ -18,24 +19,23 @@ impl BuildSerializer for DefinitionsSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "definitions";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
+        let schema_definitions: Bound<'_, PyList> = schema.get_as_req(intern!(py, "definitions"))?;
 
         for schema_definition in schema_definitions {
-            let reference = schema_definition
-                .extract::<&PyDict>()?
-                .get_as_req::<String>(intern!(py, "ref"))?;
-            let serializer = CombinedSerializer::build(schema_definition.downcast()?, config, definitions)?;
+            let schema = schema_definition.downcast()?;
+            let reference = schema.get_as_req::<String>(intern!(py, "ref"))?;
+            let serializer = CombinedSerializer::build(schema, config, definitions)?;
             definitions.add_definition(reference, serializer)?;
         }
 
-        let inner_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(inner_schema, config, definitions)
+        let inner_schema = schema.get_as_req(intern!(py, "schema"))?;
+        CombinedSerializer::build(&inner_schema, config, definitions)
     }
 }
 
@@ -67,12 +67,12 @@ impl BuildSerializer for DefinitionRefSerializer {
     const EXPECTED_TYPE: &'static str = "definition-ref";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
-        let definition = definitions.get_definition(schema_ref);
+        let schema_ref: PyBackedStr = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
+        let definition = definitions.get_definition(&schema_ref);
         Ok(Self {
             definition,
             retry_with_lax_check: RecursionSafeCache::new(),
@@ -86,9 +86,9 @@ impl_py_gc_traverse!(DefinitionRefSerializer {});
 impl TypeSerializer for DefinitionRefSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         mut extra: &Extra,
     ) -> PyResult<PyObject> {
         self.definition.read(|comb_serializer| {
@@ -98,16 +98,16 @@ impl TypeSerializer for DefinitionRefSerializer {
         })
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.definition.read(|s| s.unwrap().json_key(key, extra))
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         mut extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.definition.read(|comb_serializer| {
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index 89851752e..cf4458bd7 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -28,24 +28,24 @@ impl BuildSerializer for DictSerializer {
     const EXPECTED_TYPE: &'static str = "dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let key_serializer = match schema.get_as::<&PyDict>(intern!(py, "keys_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let key_serializer = match schema.get_as(intern!(py, "keys_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
-        let value_serializer = match schema.get_as::<&PyDict>(intern!(py, "values_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let value_serializer = match schema.get_as(intern!(py, "values_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
-        let filter = match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
+        let filter = match schema.get_as::<Bound<'_, PyDict>>(intern!(py, "serialization"))? {
             Some(ser) => {
                 let include = ser.get_item(intern!(py, "include"))?;
                 let exclude = ser.get_item(intern!(py, "exclude"))?;
-                SchemaFilter::from_set_hash(include, exclude)?
+                SchemaFilter::from_set_hash(include.as_ref(), exclude.as_ref())?
             }
             None => SchemaFilter::default(),
         };
@@ -73,9 +73,9 @@ impl_py_gc_traverse!(DictSerializer {
 impl TypeSerializer for DictSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -83,15 +83,16 @@ impl TypeSerializer for DictSerializer {
             Ok(py_dict) => {
                 let value_serializer = self.value_serializer.as_ref();
 
-                let new_dict = PyDict::new(py);
-                for (key, value) in py_dict {
-                    let op_next = self.filter.key_filter(key, include, exclude)?;
+                let new_dict = PyDict::new_bound(py);
+                for (key, value) in py_dict.iter() {
+                    let op_next = self.filter.key_filter(&key, include, exclude)?;
                     if let Some((next_include, next_exclude)) = op_next {
                         let key = match extra.mode {
-                            SerMode::Json => self.key_serializer.json_key(key, extra)?.into_py(py),
-                            _ => self.key_serializer.to_python(key, None, None, extra)?,
+                            SerMode::Json => self.key_serializer.json_key(&key, extra)?.into_py(py),
+                            _ => self.key_serializer.to_python(&key, None, None, extra)?,
                         };
-                        let value = value_serializer.to_python(value, next_include, next_exclude, extra)?;
+                        let value =
+                            value_serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?;
                         new_dict.set_item(key, value)?;
                     }
                 }
@@ -104,16 +105,16 @@ impl TypeSerializer for DictSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyDict>() {
@@ -122,12 +123,17 @@ impl TypeSerializer for DictSerializer {
                 let key_serializer = self.key_serializer.as_ref();
                 let value_serializer = self.value_serializer.as_ref();
 
-                for (key, value) in py_dict {
-                    let op_next = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+                for (key, value) in py_dict.iter() {
+                    let op_next = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let key = key_serializer.json_key(key, extra).map_err(py_err_se_err)?;
-                        let value_serialize =
-                            PydanticSerializer::new(value, value_serializer, next_include, next_exclude, extra);
+                        let key = key_serializer.json_key(&key, extra).map_err(py_err_se_err)?;
+                        let value_serialize = PydanticSerializer::new(
+                            &value,
+                            value_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         map.serialize_entry(&key, &value_serialize)?;
                     }
                 }
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 23dcacf1a..7abf28999 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -24,8 +24,8 @@ impl BuildSerializer for FloatSerializer {
     const EXPECTED_TYPE: &'static str = "float";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let inf_nan_mode = config
@@ -41,9 +41,9 @@ impl_py_gc_traverse!(FloatSerializer {});
 impl TypeSerializer for FloatSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -63,7 +63,7 @@ impl TypeSerializer for FloatSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Float) {
             IsType::Exact | IsType::Subclass => to_str_json_key(key),
             IsType::False => {
@@ -75,10 +75,10 @@ impl TypeSerializer for FloatSerializer {
 
     fn serde_serialize<S: Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.extract::<f64>() {
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index 2de5788e0..1991a2086 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -23,19 +23,19 @@ pub(super) enum WhenUsed {
 }
 
 impl WhenUsed {
-    pub fn new(schema: &PyDict, default: Self) -> PyResult<Self> {
-        let when_used = schema.get_as(intern!(schema.py(), "when_used"))?;
-        match when_used {
-            Some("always") => Ok(Self::Always),
-            Some("unless-none") => Ok(Self::UnlessNone),
-            Some("json") => Ok(Self::Json),
-            Some("json-unless-none") => Ok(Self::JsonUnlessNone),
-            Some(s) => py_schema_err!("Invalid value for `when_used`: {:?}", s),
+    pub fn new(schema: &Bound<'_, PyDict>, default: Self) -> PyResult<Self> {
+        let when_used = schema.get_as::<Bound<'_, PyString>>(intern!(schema.py(), "when_used"))?;
+        match when_used.as_ref().map(|s| s.to_str()) {
+            Some(Ok("always")) => Ok(Self::Always),
+            Some(Ok("unless-none")) => Ok(Self::UnlessNone),
+            Some(Ok("json")) => Ok(Self::Json),
+            Some(Ok("json-unless-none")) => Ok(Self::JsonUnlessNone),
+            Some(s) => py_schema_err!("Invalid value for `when_used`: {:?}", s?),
             None => Ok(default),
         }
     }
 
-    pub fn should_use(&self, value: &PyAny, extra: &Extra) -> bool {
+    pub fn should_use(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> bool {
         match self {
             Self::Always => true,
             Self::UnlessNone => !value.is_none(),
@@ -45,7 +45,7 @@ impl WhenUsed {
     }
 
     /// Equivalent to `self.should_use` when we already know we're in JSON mode
-    pub fn should_use_json(&self, value: &PyAny) -> bool {
+    pub fn should_use_json(&self, value: &Bound<'_, PyAny>) -> bool {
         match self {
             Self::Always | Self::Json => true,
             _ => !value.is_none(),
@@ -64,21 +64,22 @@ impl BuildSerializer for FormatSerializer {
     const EXPECTED_TYPE: &'static str = "format";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let formatting_string: &str = schema.get_as_req(intern!(py, "formatting_string"))?;
+        let formatting_string: Bound<'_, PyString> = schema.get_as_req(intern!(py, "formatting_string"))?;
+        let formatting_string = formatting_string.to_str()?;
         if formatting_string.is_empty() {
             ToStringSerializer::build(schema, config, definitions)
         } else {
             Ok(Self {
                 format_func: py
-                    .import(intern!(py, "builtins"))?
+                    .import_bound(intern!(py, "builtins"))?
                     .getattr(intern!(py, "format"))?
                     .into_py(py),
-                formatting_string: PyString::new(py, formatting_string).into_py(py),
+                formatting_string: PyString::new_bound(py, formatting_string).into(),
                 when_used: WhenUsed::new(schema, WhenUsed::JsonUnlessNone)?,
             }
             .into())
@@ -87,17 +88,17 @@ impl BuildSerializer for FormatSerializer {
 }
 
 impl FormatSerializer {
-    fn call(&self, value: &PyAny) -> Result<PyObject, String> {
+    fn call(&self, value: &Bound<'_, PyAny>) -> Result<PyObject, String> {
         let py = value.py();
         self.format_func
-            .call1(py, (value, self.formatting_string.as_ref(py)))
+            .call1(py, (value, &self.formatting_string))
             .map_err(|e| {
                 format!(
                     "Error calling `format(value, {})`: {}",
                     self.formatting_string
-                        .as_ref(py)
+                        .bind(py)
                         .repr()
-                        .unwrap_or_else(|_| intern!(py, "???")),
+                        .unwrap_or_else(|_| intern!(py, "???").clone()),
                     e
                 )
             })
@@ -109,9 +110,9 @@ impl_py_gc_traverse!(FormatSerializer { format_func });
 impl TypeSerializer for FormatSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if self.when_used.should_use(value, extra) {
@@ -121,11 +122,14 @@ impl TypeSerializer for FormatSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
         if self.when_used.should_use_json(key) {
-            let v = self.call(key).map_err(PydanticSerializationError::new_err)?;
-            let py_str: &PyString = v.into_ref(key.py()).downcast()?;
-            Ok(Cow::Borrowed(py_str.to_str()?))
+            let py_str = self
+                .call(key)
+                .map_err(PydanticSerializationError::new_err)?
+                .into_bound(key.py())
+                .downcast_into::<PyString>()?;
+            Ok(Cow::Owned(py_str.to_str()?.to_owned()))
         } else {
             none_json_key()
         }
@@ -133,16 +137,16 @@ impl TypeSerializer for FormatSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         _extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if self.when_used.should_use_json(value) {
             match self.call(value) {
                 Ok(v) => {
-                    let py_str: &PyString = v.downcast(value.py()).map_err(py_err_se_err)?;
+                    let py_str = v.bind(value.py()).downcast().map_err(py_err_se_err)?;
                     serialize_py_str(py_str, serializer)
                 }
                 Err(e) => Err(S::Error::custom(e)),
@@ -166,8 +170,8 @@ impl BuildSerializer for ToStringSerializer {
     const EXPECTED_TYPE: &'static str = "to-string";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {
@@ -182,9 +186,9 @@ impl_py_gc_traverse!(ToStringSerializer {});
 impl TypeSerializer for ToStringSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if self.when_used.should_use(value, extra) {
@@ -194,9 +198,9 @@ impl TypeSerializer for ToStringSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
         if self.when_used.should_use_json(key) {
-            Ok(key.str()?.to_string_lossy())
+            Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
         } else {
             none_json_key()
         }
@@ -204,15 +208,15 @@ impl TypeSerializer for ToStringSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         _extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if self.when_used.should_use_json(value) {
             let s = value.str().map_err(py_err_se_err)?;
-            serialize_py_str(s, serializer)
+            serialize_py_str(&s, serializer)
         } else {
             serializer.serialize_none()
         }
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 170009383..415db806a 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -28,14 +28,14 @@ impl BuildSerializer for FunctionBeforeSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-before";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         // `before` schemas will obviously have type from `schema` since the validator is called second
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -44,8 +44,8 @@ pub struct FunctionAfterSerializerBuilder;
 impl BuildSerializer for FunctionAfterSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-after";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -54,7 +54,7 @@ impl BuildSerializer for FunctionAfterSerializerBuilder {
         // be used for serialization. For convenience, the default is to assume the wrapped schema
         // should be used; the user/lib can override the serializer if necessary.
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -63,8 +63,8 @@ pub struct FunctionPlainSerializerBuilder;
 impl BuildSerializer for FunctionPlainSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-plain";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         super::any::AnySerializer::build(schema, config, definitions)
@@ -84,8 +84,8 @@ pub struct FunctionPlainSerializer {
     info_arg: bool,
 }
 
-fn destructure_function_schema(schema: &PyDict) -> PyResult<(bool, bool, &PyAny)> {
-    let function: &PyAny = schema.get_as_req(intern!(schema.py(), "function"))?;
+fn destructure_function_schema<'py>(schema: &Bound<'py, PyDict>) -> PyResult<(bool, bool, Bound<'py, PyAny>)> {
+    let function = schema.get_as_req(intern!(schema.py(), "function"))?;
     let is_field_serializer: bool = schema
         .get_as(intern!(schema.py(), "is_field_serializer"))?
         .unwrap_or(false);
@@ -99,28 +99,28 @@ impl BuildSerializer for FunctionPlainSerializer {
     /// NOTE! `schema` here is the actual `CoreSchema`, not `schema.serialization` as in the other builders
     /// (done this way to match `FunctionWrapSerializer` which requires the full schema)
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let ser_schema: &PyDict = schema.get_as_req(intern!(py, "serialization"))?;
+        let ser_schema = schema.get_as_req(intern!(py, "serialization"))?;
 
-        let (is_field_serializer, info_arg, function) = destructure_function_schema(ser_schema)?;
-        let function_name = function_name(function)?;
+        let (is_field_serializer, info_arg, function) = destructure_function_schema(&ser_schema)?;
+        let function_name = function_name(&function)?;
 
-        let return_serializer = match ser_schema.get_as::<&PyDict>(intern!(py, "return_schema"))? {
-            Some(s) => Box::new(CombinedSerializer::build(s, config, definitions)?),
+        let return_serializer = match ser_schema.get_as(intern!(py, "return_schema"))? {
+            Some(s) => Box::new(CombinedSerializer::build(&s, config, definitions)?),
             None => Box::new(AnySerializer::build(schema, config, definitions)?),
         };
 
-        let when_used = WhenUsed::new(ser_schema, WhenUsed::Always)?;
+        let when_used = WhenUsed::new(&ser_schema, WhenUsed::Always)?;
         let fallback_serializer = match when_used {
             WhenUsed::Always => None,
             _ => {
                 let new_schema = copy_outer_schema(schema)?;
-                Some(Box::new(CombinedSerializer::build(new_schema, config, definitions)?))
+                Some(Box::new(CombinedSerializer::build(&new_schema, config, definitions)?))
             }
         };
 
@@ -142,9 +142,9 @@ impl BuildSerializer for FunctionPlainSerializer {
 impl FunctionPlainSerializer {
     fn call(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<(bool, PyObject)> {
         let py = value.py();
@@ -181,7 +181,7 @@ impl FunctionPlainSerializer {
 }
 
 fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyResult<()> {
-    let exception = err.value(py);
+    let exception = err.value_bound(py);
     if let Ok(ser_err) = exception.extract::<PydanticSerializationUnexpectedValue>() {
         if extra.check.enabled() {
             Err(err)
@@ -205,20 +205,18 @@ macro_rules! function_type_serializer {
         impl TypeSerializer for $name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
                 match self.call(value, include, exclude, extra) {
                     // None for include/exclude here, as filtering should be done
-                    Ok((true, v)) => self
-                        .return_serializer
-                        .to_python(v.into_ref(py), None, None, extra),
+                    Ok((true, v)) => self.return_serializer.to_python(v.bind(py), None, None, extra),
                     Ok((false, v)) => self
                         .get_fallback_serializer()
-                        .to_python(v.into_ref(py), None, None, extra),
+                        .to_python(v.bind(py), None, None, extra),
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra)?;
                         infer_to_python(value, include, exclude, extra)
@@ -226,11 +224,17 @@ macro_rules! function_type_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 let py = key.py();
                 match self.call(key, None, None, extra) {
-                    Ok((true, v)) => self.return_serializer.json_key(v.into_ref(py), extra),
-                    Ok((false, v)) => self.get_fallback_serializer().json_key(v.into_ref(py), extra),
+                    Ok((true, v)) => self
+                        .return_serializer
+                        .json_key(v.bind(py), extra)
+                        .map(|cow| Cow::Owned(cow.into_owned())),
+                    Ok((false, v)) => self
+                        .get_fallback_serializer()
+                        .json_key(v.bind(py), extra)
+                        .map(|cow| Cow::Owned(cow.into_owned())),
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra)?;
                         infer_json_key(key, extra)
@@ -240,22 +244,21 @@ macro_rules! function_type_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 let py = value.py();
                 match self.call(value, include, exclude, extra) {
                     // None for include/exclude here, as filtering should be done
-                    Ok((true, v)) => {
-                        self.return_serializer
-                            .serde_serialize(v.into_ref(py), serializer, None, None, extra)
-                    }
+                    Ok((true, v)) => self
+                        .return_serializer
+                        .serde_serialize(v.bind(py), serializer, None, None, extra),
                     Ok((false, v)) => {
                         self.get_fallback_serializer()
-                            .serde_serialize(v.into_ref(py), serializer, None, None, extra)
+                            .serde_serialize(v.bind(py), serializer, None, None, extra)
                     }
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra).map_err(py_err_se_err)?;
@@ -279,7 +282,7 @@ impl_py_gc_traverse!(FunctionPlainSerializer {
 
 function_type_serializer!(FunctionPlainSerializer);
 
-fn copy_outer_schema(schema: &PyDict) -> PyResult<&PyDict> {
+fn copy_outer_schema<'py>(schema: &Bound<'py, PyDict>) -> PyResult<Bound<'py, PyDict>> {
     let py = schema.py();
     // we copy the schema so we can modify it without affecting the original
     let schema_copy = schema.copy()?;
@@ -297,8 +300,8 @@ pub struct FunctionWrapSerializerBuilder;
 impl BuildSerializer for FunctionWrapSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-wrap";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -307,7 +310,7 @@ impl BuildSerializer for FunctionWrapSerializerBuilder {
         // schema should be used for serialization. For convenience, the default is to assume the
         // wrapped schema should be used; the user/lib can override the serializer if necessary.
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -329,27 +332,27 @@ impl BuildSerializer for FunctionWrapSerializer {
     /// NOTE! `schema` here is the actual `CoreSchema`, not `schema.serialization` as in the other builders
     /// (done this way since we need the `CoreSchema`)
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let ser_schema: &PyDict = schema.get_as_req(intern!(py, "serialization"))?;
+        let ser_schema = schema.get_as_req(intern!(py, "serialization"))?;
 
-        let (is_field_serializer, info_arg, function) = destructure_function_schema(ser_schema)?;
-        let function_name = function_name(function)?;
+        let (is_field_serializer, info_arg, function) = destructure_function_schema(&ser_schema)?;
+        let function_name = function_name(&function)?;
 
         // try to get `schema.serialization.schema`, otherwise use `schema` with `serialization` key removed
-        let inner_schema: &PyDict = if let Some(s) = ser_schema.get_as(intern!(py, "schema"))? {
+        let inner_schema = if let Some(s) = ser_schema.get_as(intern!(py, "schema"))? {
             s
         } else {
             copy_outer_schema(schema)?
         };
 
-        let serializer = CombinedSerializer::build(inner_schema, config, definitions)?;
+        let serializer = CombinedSerializer::build(&inner_schema, config, definitions)?;
 
-        let return_serializer = match ser_schema.get_as::<&PyDict>(intern!(py, "return_schema"))? {
-            Some(s) => CombinedSerializer::build(s, config, definitions)?,
+        let return_serializer = match ser_schema.get_as(intern!(py, "return_schema"))? {
+            Some(s) => CombinedSerializer::build(&s, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
 
@@ -360,7 +363,7 @@ impl BuildSerializer for FunctionWrapSerializer {
             function_name,
             name,
             return_serializer: Box::new(return_serializer),
-            when_used: WhenUsed::new(ser_schema, WhenUsed::Always)?,
+            when_used: WhenUsed::new(&ser_schema, WhenUsed::Always)?,
             is_field_serializer,
             info_arg,
         }
@@ -371,9 +374,9 @@ impl BuildSerializer for FunctionWrapSerializer {
 impl FunctionWrapSerializer {
     fn call(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<(bool, PyObject)> {
         let py = value.py();
@@ -430,8 +433,8 @@ impl SerializationCallable {
     pub fn new(
         py: Python,
         serializer: &CombinedSerializer,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Self {
         Self {
@@ -473,9 +476,14 @@ impl SerializationCallable {
 
 #[pymethods]
 impl SerializationCallable {
-    fn __call__(&mut self, py: Python, value: &PyAny, index_key: Option<&PyAny>) -> PyResult<Option<PyObject>> {
-        let include = self.include.as_ref().map(|o| o.as_ref(py));
-        let exclude = self.exclude.as_ref().map(|o| o.as_ref(py));
+    fn __call__(
+        &mut self,
+        py: Python,
+        value: &Bound<'_, PyAny>,
+        index_key: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<Option<PyObject>> {
+        let include = self.include.as_ref().map(|o| o.bind(py));
+        let exclude = self.exclude.as_ref().map(|o| o.bind(py));
         let extra = self.extra_owned.to_extra(py);
 
         if let Some(index_key) = index_key {
@@ -485,7 +493,9 @@ impl SerializationCallable {
                 self.filter.key_filter(index_key, include, exclude)?
             };
             if let Some((next_include, next_exclude)) = filter {
-                let v = self.serializer.to_python(value, next_include, next_exclude, &extra)?;
+                let v = self
+                    .serializer
+                    .to_python(value, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
                 extra.warnings.final_check(py)?;
                 Ok(Some(v))
             } else {
@@ -536,8 +546,8 @@ struct SerializationInfo {
 impl SerializationInfo {
     fn new(
         py: Python,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
         is_field_serializer: bool,
     ) -> PyResult<Self> {
@@ -546,7 +556,7 @@ impl SerializationInfo {
                 Some(field_name) => Ok(Self {
                     include: include.map(|i| i.into_py(py)),
                     exclude: exclude.map(|e| e.into_py(py)),
-                    context: extra.context.map(Into::into),
+                    context: extra.context.map(|c| c.into_py(py)),
                     _mode: extra.mode.clone(),
                     by_alias: extra.by_alias,
                     exclude_unset: extra.exclude_unset,
@@ -563,7 +573,7 @@ impl SerializationInfo {
             Ok(Self {
                 include: include.map(|i| i.into_py(py)),
                 exclude: exclude.map(|e| e.into_py(py)),
-                context: extra.context.map(Into::into),
+                context: extra.context.map(|c| c.into_py(py)),
                 _mode: extra.mode.clone(),
                 by_alias: extra.by_alias,
                 exclude_unset: extra.exclude_unset,
@@ -607,8 +617,8 @@ impl SerializationInfo {
     }
 
     #[getter]
-    fn __dict__<'py>(&'py self, py: Python<'py>) -> PyResult<&'py PyDict> {
-        let d = PyDict::new(py);
+    fn __dict__<'py>(&'py self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        let d = PyDict::new_bound(py);
         if let Some(ref include) = self.include {
             d.set_item("include", include)?;
         }
@@ -631,16 +641,16 @@ impl SerializationInfo {
         Ok(format!(
             "SerializationInfo(include={}, exclude={}, context={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={})",
             match self.include {
-                Some(ref include) => include.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref include) => include.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             match self.exclude {
-                Some(ref exclude) => exclude.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref exclude) => exclude.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             match self.context {
-                Some(ref context) => context.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref context) => context.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             self._mode,
             py_bool(self.by_alias),
@@ -655,9 +665,9 @@ impl SerializationInfo {
         self.__repr__(py)
     }
     #[getter]
-    fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<&'py PyString> {
+    fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyString>> {
         match self.field_name {
-            Some(ref field_name) => Ok(PyString::new(py, field_name)),
+            Some(ref field_name) => Ok(PyString::new_bound(py, field_name)),
             None => Err(PyAttributeError::new_err("No attribute named 'field_name'")),
         }
     }
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 4637bc44e..d7d211456 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -27,13 +27,13 @@ impl BuildSerializer for GeneratorSerializer {
     const EXPECTED_TYPE: &'static str = "generator";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         Ok(Self {
@@ -49,9 +49,9 @@ impl_py_gc_traverse!(GeneratorSerializer { item_serializer });
 impl TypeSerializer for GeneratorSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyIterator>() {
@@ -65,11 +65,16 @@ impl TypeSerializer for GeneratorSerializer {
                             Ok(len) => Vec::with_capacity(len),
                             Err(_) => Vec::new(),
                         };
-                        for (index, iter_result) in py_iter.enumerate() {
+                        for (index, iter_result) in py_iter.clone().enumerate() {
                             let element = iter_result?;
                             let op_next = self.filter.index_filter(index, include, exclude, None)?;
                             if let Some((next_include, next_exclude)) = op_next {
-                                items.push(item_serializer.to_python(element, next_include, next_exclude, extra)?);
+                                items.push(item_serializer.to_python(
+                                    &element,
+                                    next_include.as_ref(),
+                                    next_exclude.as_ref(),
+                                    extra,
+                                )?);
                             }
                         }
                         Ok(items.into_py(py))
@@ -94,16 +99,16 @@ impl TypeSerializer for GeneratorSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyIterator>() {
@@ -115,15 +120,20 @@ impl TypeSerializer for GeneratorSerializer {
                 let mut seq = serializer.serialize_seq(len)?;
                 let item_serializer = self.item_serializer.as_ref();
 
-                for (index, iter_result) in py_iter.enumerate() {
+                for (index, iter_result) in py_iter.clone().enumerate() {
                     let element = iter_result.map_err(py_err_se_err)?;
                     let op_next = self
                         .filter
                         .index_filter(index, include, exclude, None)
                         .map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, item_serializer, next_include, next_exclude, extra);
+                        let item_serialize = PydanticSerializer::new(
+                            &element,
+                            item_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         seq.serialize_element(&item_serialize)?;
                     }
                 }
@@ -157,22 +167,21 @@ pub(crate) struct SerializationIterator {
 
 impl SerializationIterator {
     pub fn new(
-        py_iter: &PyIterator,
+        py_iter: &Bound<'_, PyIterator>,
         item_serializer: CombinedSerializer,
         filter: SchemaFilter<usize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Self {
-        let py = py_iter.py();
         Self {
-            iterator: py_iter.into_py(py),
+            iterator: py_iter.clone().into(),
             index: 0,
             item_serializer,
             extra_owned: ExtraOwned::new(extra),
             filter,
-            include: include.map(|v| v.into_py(py)),
-            exclude: exclude.map(|v| v.into_py(py)),
+            include: include.map(|v| v.clone().into()),
+            exclude: exclude.map(|v| v.clone().into()),
         }
     }
 
@@ -211,12 +220,12 @@ impl SerializationIterator {
     }
 
     fn __next__(&mut self, py: Python) -> PyResult<Option<PyObject>> {
-        let iterator = self.iterator.as_ref(py);
-        let include = self.include.as_ref().map(|o| o.as_ref(py));
-        let exclude = self.exclude.as_ref().map(|o| o.as_ref(py));
+        let iterator = self.iterator.bind(py);
+        let include = self.include.as_ref().map(|o| o.bind(py));
+        let exclude = self.exclude.as_ref().map(|o| o.bind(py));
         let extra = self.extra_owned.to_extra(py);
 
-        for iter_result in iterator {
+        for iter_result in iterator.clone() {
             let element = iter_result?;
             let filter = self.filter.index_filter(self.index, include, exclude, None)?;
             self.index += 1;
@@ -224,7 +233,7 @@ impl SerializationIterator {
                 let v = self
                     .item_serializer
                     // TODO do we need error_on_fallback to be customizable?
-                    .to_python(element, next_include, next_exclude, &extra)?;
+                    .to_python(&element, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
                 extra.warnings.final_check(py)?;
                 return Ok(Some(v));
             }
@@ -233,7 +242,7 @@ impl SerializationIterator {
     }
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
-        let iterator = self.iterator.as_ref(py);
+        let iterator = self.iterator.bind(py);
         Ok(format!(
             "SerializationIterator(index={}, iterator={})",
             self.index,
diff --git a/src/serializers/type_serializers/json.rs b/src/serializers/type_serializers/json.rs
index cdca5c4fe..8bc87bb2c 100644
--- a/src/serializers/type_serializers/json.rs
+++ b/src/serializers/type_serializers/json.rs
@@ -25,14 +25,14 @@ impl BuildSerializer for JsonSerializer {
     const EXPECTED_TYPE: &'static str = "json";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let serializer = match schema.get_as::<&PyDict>(intern!(py, "schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let serializer = match schema.get_as(intern!(py, "schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         Ok(Self {
@@ -47,9 +47,9 @@ impl_py_gc_traverse!(JsonSerializer { serializer });
 impl TypeSerializer for JsonSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if extra.round_trip {
@@ -62,7 +62,7 @@ impl TypeSerializer for JsonSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if extra.round_trip {
             let bytes = to_json_bytes(key, &self.serializer, None, None, extra, None, 0)?;
             let py = key.py();
@@ -75,10 +75,10 @@ impl TypeSerializer for JsonSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if extra.round_trip {
diff --git a/src/serializers/type_serializers/json_or_python.rs b/src/serializers/type_serializers/json_or_python.rs
index 9234abcc7..ce9a9c8c9 100644
--- a/src/serializers/type_serializers/json_or_python.rs
+++ b/src/serializers/type_serializers/json_or_python.rs
@@ -19,16 +19,16 @@ impl BuildSerializer for JsonOrPythonSerializer {
     const EXPECTED_TYPE: &'static str = "json-or-python";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let json_schema: &PyDict = schema.get_as_req(intern!(py, "json_schema"))?;
-        let python_schema: &PyDict = schema.get_as_req(intern!(py, "python_schema"))?;
+        let json_schema = schema.get_as_req(intern!(py, "json_schema"))?;
+        let python_schema = schema.get_as_req(intern!(py, "python_schema"))?;
 
-        let json = CombinedSerializer::build(json_schema, config, definitions)?;
-        let python = CombinedSerializer::build(python_schema, config, definitions)?;
+        let json = CombinedSerializer::build(&json_schema, config, definitions)?;
+        let python = CombinedSerializer::build(&python_schema, config, definitions)?;
 
         let name = format!(
             "{}[json={}, python={}]",
@@ -50,24 +50,24 @@ impl_py_gc_traverse!(JsonOrPythonSerializer { json, python });
 impl TypeSerializer for JsonOrPythonSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         self.python.to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.json.json_key(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.json.serde_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index a71e3452a..44805f523 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/src/serializers/type_serializers/list.rs
@@ -26,13 +26,13 @@ impl BuildSerializer for ListSerializer {
     const EXPECTED_TYPE: &'static str = "list";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, item_serializer.get_name());
@@ -50,9 +50,9 @@ impl_py_gc_traverse!(ListSerializer { item_serializer });
 impl TypeSerializer for ListSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyList>() {
@@ -64,7 +64,12 @@ impl TypeSerializer for ListSerializer {
                 for (index, element) in py_list.iter().enumerate() {
                     let op_next = self.filter.index_filter(index, include, exclude, value.len().ok())?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        items.push(item_serializer.to_python(element, next_include, next_exclude, extra)?);
+                        items.push(item_serializer.to_python(
+                            &element,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        )?);
                     }
                 }
                 Ok(items.into_py(py))
@@ -76,16 +81,16 @@ impl TypeSerializer for ListSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyList>() {
@@ -99,8 +104,13 @@ impl TypeSerializer for ListSerializer {
                         .index_filter(index, include, exclude, Some(py_list.len()))
                         .map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, item_serializer, next_include, next_exclude, extra);
+                        let item_serialize = PydanticSerializer::new(
+                            &element,
+                            item_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         seq.serialize_element(&item_serialize)?;
                     }
                 }
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index d6b08afa5..d0b751e72 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -1,8 +1,8 @@
 use std::borrow::Cow;
 
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyDict, PyList, PyString};
-use pyo3::{intern, PyTypeInfo};
 
 use ahash::AHashSet;
 use serde::Serialize;
@@ -28,11 +28,11 @@ impl BuildSerializer for LiteralSerializer {
     const EXPECTED_TYPE: &'static str = "literal";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let expected: &PyList = schema.get_as_req(intern!(schema.py(), "expected"))?;
+        let expected: Bound<'_, PyList> = schema.get_as_req(intern!(schema.py(), "expected"))?;
 
         if expected.is_empty() {
             return py_schema_err!("`expected` should have length > 0");
@@ -40,13 +40,13 @@ impl BuildSerializer for LiteralSerializer {
         let mut expected_int = AHashSet::new();
         let mut expected_str = AHashSet::new();
         let py = expected.py();
-        let expected_py = PyList::empty(py);
+        let expected_py = PyList::empty_bound(py);
         let mut repr_args: Vec<String> = Vec::new();
         for item in expected {
             repr_args.push(item.repr()?.extract()?);
             if let Ok(bool) = item.downcast::<PyBool>() {
                 expected_py.append(bool)?;
-            } else if let Some(int) = extract_i64(item) {
+            } else if let Some(int) = extract_i64(&item) {
                 expected_int.insert(int);
             } else if let Ok(py_str) = item.downcast::<PyString>() {
                 expected_str.insert(py_str.to_str()?.to_string());
@@ -68,17 +68,17 @@ impl BuildSerializer for LiteralSerializer {
     }
 }
 
-enum OutputValue<'a> {
+enum OutputValue<'py> {
     OkInt(i64),
-    OkStr(&'a str),
+    OkStr(Bound<'py, PyString>),
     Ok,
     Fallback,
 }
 
 impl LiteralSerializer {
-    fn check<'a>(&self, value: &'a PyAny, extra: &Extra) -> PyResult<OutputValue<'a>> {
+    fn check<'py>(&self, value: &Bound<'py, PyAny>, extra: &Extra) -> PyResult<OutputValue<'py>> {
         if extra.check.enabled() {
-            if !self.expected_int.is_empty() && !PyBool::is_type_of(value) {
+            if !self.expected_int.is_empty() && !value.is_instance_of::<PyBool>() {
                 if let Some(int) = extract_i64(value) {
                     if self.expected_int.contains(&int) {
                         return Ok(OutputValue::OkInt(int));
@@ -89,13 +89,13 @@ impl LiteralSerializer {
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     let s = py_str.to_str()?;
                     if self.expected_str.contains(s) {
-                        return Ok(OutputValue::OkStr(s));
+                        return Ok(OutputValue::OkStr(py_str.clone()));
                     }
                 }
             }
 
             if let Some(ref expected_py) = self.expected_py {
-                if expected_py.as_ref(value.py()).contains(value)? {
+                if expected_py.bind(value.py()).contains(value)? {
                     return Ok(OutputValue::Ok);
                 }
             }
@@ -111,9 +111,9 @@ impl_py_gc_traverse!(LiteralSerializer { expected_py });
 impl TypeSerializer for LiteralSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -134,10 +134,10 @@ impl TypeSerializer for LiteralSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match self.check(key, extra)? {
             OutputValue::OkInt(int) => Ok(Cow::Owned(int.to_string())),
-            OutputValue::OkStr(s) => Ok(Cow::Borrowed(s)),
+            OutputValue::OkStr(s) => Ok(Cow::Owned(s.to_string_lossy().into_owned())),
             OutputValue::Ok => infer_json_key(key, extra),
             OutputValue::Fallback => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
@@ -148,15 +148,15 @@ impl TypeSerializer for LiteralSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match self.check(value, extra).map_err(py_err_se_err)? {
             OutputValue::OkInt(int) => int.serialize(serializer),
-            OutputValue::OkStr(s) => s.serialize(serializer),
+            OutputValue::OkStr(s) => s.to_string_lossy().serialize(serializer),
             OutputValue::Ok => infer_serialize(value, serializer, include, exclude, extra),
             OutputValue::Fallback => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 0d2d1d346..e40fa2f7f 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -25,8 +25,8 @@ impl BuildSerializer for ModelFieldsBuilder {
     const EXPECTED_TYPE: &'static str = "model-fields";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -36,21 +36,21 @@ impl BuildSerializer for ModelFieldsBuilder {
             false => FieldsMode::SimpleDict,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
         let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
-            (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(v.extract()?, config, definitions)?),
+            (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(&v.extract()?, config, definitions)?),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
         for (key, value) in fields_dict {
-            let key_py: &PyString = key.downcast()?;
+            let key_py = key.downcast_into::<PyString>()?;
             let key: String = key_py.extract()?;
-            let field_info: &PyDict = value.downcast()?;
+            let field_info = value.downcast()?;
 
-            let key_py: Py<PyString> = key_py.into_py(py);
+            let key_py: Py<PyString> = key_py.into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(key, SerField::new(py, key_py, None, None, true));
@@ -58,7 +58,7 @@ impl BuildSerializer for ModelFieldsBuilder {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
 
                 fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), true));
@@ -84,8 +84,8 @@ impl BuildSerializer for ModelSerializer {
     const EXPECTED_TYPE: &'static str = "model";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -93,31 +93,32 @@ impl BuildSerializer for ModelSerializer {
         // models ignore the parent config and always use the config from this model
         let config = schema.get_as(intern!(py, "config"))?;
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let class: Py<PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config.as_ref(), definitions)?);
         let root_model = schema.get_as(intern!(py, "root_model"))?.unwrap_or(false);
+        let name = class.bind(py).getattr(intern!(py, "__name__"))?.extract()?;
 
         Ok(Self {
-            class: class.into(),
+            class,
             serializer,
-            has_extra: has_extra(schema, config)?,
+            has_extra: has_extra(schema, config.as_ref())?,
             root_model,
-            name: class.getattr(intern!(py, "__name__"))?.extract()?,
+            name,
         }
         .into())
     }
 }
 
-fn has_extra(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+fn has_extra(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     let extra_behaviour = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
     Ok(matches!(extra_behaviour, ExtraBehavior::Allow))
 }
 
 impl ModelSerializer {
-    fn allow_value(&self, value: &PyAny, extra: &Extra) -> PyResult<bool> {
-        let class = self.class.as_ref(value.py());
+    fn allow_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<bool> {
+        let class = self.class.bind(value.py());
         match extra.check {
             SerCheck::Strict => Ok(value.get_type().is(class)),
             SerCheck::Lax => value.is_instance(class),
@@ -125,16 +126,18 @@ impl ModelSerializer {
         }
     }
 
-    fn get_inner_value<'py>(&self, model: &'py PyAny, extra: &Extra) -> PyResult<&'py PyAny> {
+    fn get_inner_value<'py>(&self, model: &Bound<'py, PyAny>, extra: &Extra) -> PyResult<Bound<'py, PyAny>> {
         let py = model.py();
-        let mut attrs: &PyDict = model.getattr(intern!(py, "__dict__"))?.downcast()?;
+        let mut attrs = model.getattr(intern!(py, "__dict__"))?.downcast_into::<PyDict>()?;
 
         if extra.exclude_unset {
-            let fields_set: &PySet = model.getattr(intern!(py, "__pydantic_fields_set__"))?.downcast()?;
+            let fields_set = model
+                .getattr(intern!(py, "__pydantic_fields_set__"))?
+                .downcast_into::<PySet>()?;
 
             let new_attrs = attrs.copy()?;
             for key in new_attrs.keys() {
-                if !fields_set.contains(key)? {
+                if !fields_set.contains(&key)? {
                     new_attrs.del_item(key)?;
                 }
             }
@@ -143,10 +146,10 @@ impl ModelSerializer {
 
         if self.has_extra {
             let model_extra = model.getattr(intern!(py, "__pydantic_extra__"))?;
-            let py_tuple = (attrs, model_extra).to_object(py);
-            Ok(py_tuple.into_ref(py))
+            let py_tuple = (attrs, model_extra).to_object(py).into_bound(py);
+            Ok(py_tuple)
         } else {
-            Ok(attrs)
+            Ok(attrs.into_any())
         }
     }
 }
@@ -156,9 +159,9 @@ impl_py_gc_traverse!(ModelSerializer { class, serializer });
 impl TypeSerializer for ModelSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let mut extra = Extra {
@@ -176,17 +179,17 @@ impl TypeSerializer for ModelSerializer {
                     original_err
                 }
             })?;
-            self.serializer.to_python(root, include, exclude, &extra)
+            self.serializer.to_python(&root, include, exclude, &extra)
         } else if self.allow_value(value, &extra)? {
             let inner_value = self.get_inner_value(value, &extra)?;
-            self.serializer.to_python(inner_value, include, exclude, &extra)
+            self.serializer.to_python(&inner_value, include, exclude, &extra)
         } else {
             extra.warnings.on_fallback_py(self.get_name(), value, &extra)?;
             infer_to_python(value, include, exclude, &extra)
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.allow_value(key, extra)? {
             infer_json_key_known(ObType::PydanticSerializable, key, extra)
         } else {
@@ -197,10 +200,10 @@ impl TypeSerializer for ModelSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let mut extra = Extra {
@@ -213,11 +216,11 @@ impl TypeSerializer for ModelSerializer {
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(root, serializer, include, exclude, &extra)
+                .serde_serialize(&root, serializer, include, exclude, &extra)
         } else if self.allow_value(value, &extra).map_err(py_err_se_err)? {
             let inner_value = self.get_inner_value(value, &extra).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(inner_value, serializer, include, exclude, &extra)
+                .serde_serialize(&inner_value, serializer, include, exclude, &extra)
         } else {
             extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &extra)?;
             infer_serialize(value, serializer, include, exclude, &extra)
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index 23349ec81..4abd56808 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/src/serializers/type_serializers/nullable.rs
@@ -18,13 +18,13 @@ impl BuildSerializer for NullableSerializer {
     const EXPECTED_TYPE: &'static str = "nullable";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let sub_schema = schema.get_as_req::<&PyDict>(intern!(schema.py(), "schema"))?;
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
         Ok(Self {
-            serializer: Box::new(CombinedSerializer::build(sub_schema, config, definitions)?),
+            serializer: Box::new(CombinedSerializer::build(&sub_schema, config, definitions)?),
         }
         .into())
     }
@@ -35,9 +35,9 @@ impl_py_gc_traverse!(NullableSerializer { serializer });
 impl TypeSerializer for NullableSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -48,7 +48,7 @@ impl TypeSerializer for NullableSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact => infer_json_key_known(ObType::None, key, extra),
             _ => self.serializer.json_key(key, extra),
@@ -57,10 +57,10 @@ impl TypeSerializer for NullableSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::None) {
diff --git a/src/serializers/type_serializers/other.rs b/src/serializers/type_serializers/other.rs
index b978353b4..8ca67f80d 100644
--- a/src/serializers/type_serializers/other.rs
+++ b/src/serializers/type_serializers/other.rs
@@ -15,17 +15,17 @@ impl BuildSerializer for ChainBuilder {
     const EXPECTED_TYPE: &'static str = "chain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let last_schema = schema
-            .get_as_req::<&PyList>(intern!(schema.py(), "steps"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(schema.py(), "steps"))?
             .iter()
             .last()
             .unwrap()
-            .downcast()?;
-        CombinedSerializer::build(last_schema, config, definitions)
+            .downcast_into()?;
+        CombinedSerializer::build(&last_schema, config, definitions)
     }
 }
 
@@ -35,12 +35,12 @@ impl BuildSerializer for CustomErrorBuilder {
     const EXPECTED_TYPE: &'static str = "custom-error";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let sub_schema: &PyDict = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        CombinedSerializer::build(sub_schema, config, definitions)
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        CombinedSerializer::build(&sub_schema, config, definitions)
     }
 }
 
@@ -50,13 +50,13 @@ impl BuildSerializer for CallBuilder {
     const EXPECTED_TYPE: &'static str = "call";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let return_schema = schema.get_as::<&PyDict>(intern!(schema.py(), "return_schema"))?;
+        let return_schema = schema.get_as(intern!(schema.py(), "return_schema"))?;
         match return_schema {
-            Some(return_schema) => CombinedSerializer::build(return_schema, config, definitions),
+            Some(return_schema) => CombinedSerializer::build(&return_schema, config, definitions),
             None => AnySerializer::build(schema, config, definitions),
         }
     }
@@ -68,12 +68,12 @@ impl BuildSerializer for LaxOrStrictBuilder {
     const EXPECTED_TYPE: &'static str = "lax-or-strict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let strict_schema: &PyDict = schema.get_as_req(intern!(schema.py(), "strict_schema"))?;
-        CombinedSerializer::build(strict_schema, config, definitions)
+        let strict_schema = schema.get_as_req(intern!(schema.py(), "strict_schema"))?;
+        CombinedSerializer::build(&strict_schema, config, definitions)
     }
 }
 
@@ -83,8 +83,8 @@ impl BuildSerializer for ArgumentsBuilder {
     const EXPECTED_TYPE: &'static str = "arguments";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         py_schema_err!("`arguments` validators require a custom serializer")
@@ -99,8 +99,8 @@ macro_rules! any_build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 AnySerializer::build(schema, config, definitions)
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index b105dc123..5e3d5ae29 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -27,13 +27,13 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 let py = schema.py();
-                let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-                    Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+                let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+                    Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
                     None => AnySerializer::build(schema, config, definitions)?,
                 };
                 let name = format!("{}[{}]", Self::EXPECTED_TYPE, item_serializer.get_name());
@@ -50,9 +50,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -62,11 +62,11 @@ macro_rules! build_serializer {
 
                         let mut items = Vec::with_capacity(py_set.len());
                         for element in py_set.iter() {
-                            items.push(item_serializer.to_python(element, include, exclude, extra)?);
+                            items.push(item_serializer.to_python(&element, include, exclude, extra)?);
                         }
                         match extra.mode {
-                            SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
-                            _ => Ok(<$py_type>::new(py, &items)?.into_py(py)),
+                            SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
+                            _ => Ok(<$py_type>::new_bound(py, &items)?.into_py(py)),
                         }
                     }
                     Err(_) => {
@@ -76,16 +76,16 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
             }
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.downcast::<$py_type>() {
@@ -95,7 +95,7 @@ macro_rules! build_serializer {
 
                         for value in py_set.iter() {
                             let item_serialize =
-                                PydanticSerializer::new(value, item_serializer, include, exclude, extra);
+                                PydanticSerializer::new(&value, item_serializer, include, exclude, extra);
                             seq.serialize_element(&item_serialize)?;
                         }
                         seq.end()
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index 65fbee146..e1d0f3c0b 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -20,8 +20,8 @@ impl BuildSerializer for NoneSerializer {
     const EXPECTED_TYPE: &'static str = "none";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -37,9 +37,9 @@ impl_py_gc_traverse!(NoneSerializer {});
 impl TypeSerializer for NoneSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -53,7 +53,7 @@ impl TypeSerializer for NoneSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact => none_json_key(),
             _ => {
@@ -65,10 +65,10 @@ impl TypeSerializer for NoneSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::None) {
@@ -94,8 +94,8 @@ macro_rules! build_simple_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -107,9 +107,9 @@ macro_rules! build_simple_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -132,7 +132,7 @@ macro_rules! build_simple_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match extra.ob_type_lookup.is_type(key, $ob_type) {
                     IsType::Exact | IsType::Subclass => $key_method(key),
                     IsType::False => {
@@ -144,10 +144,10 @@ macro_rules! build_simple_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.extract::<$rust_type>() {
@@ -172,14 +172,14 @@ macro_rules! build_simple_serializer {
     };
 }
 
-pub(crate) fn to_str_json_key(key: &PyAny) -> PyResult<Cow<str>> {
-    Ok(key.str()?.to_string_lossy())
+pub(crate) fn to_str_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+    Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
 }
 
 build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key, true);
 
-pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
-    let v = if key.is_true().unwrap_or(false) {
+pub(crate) fn bool_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+    let v = if key.is_truthy().unwrap_or(false) {
         "true"
     } else {
         "false"
diff --git a/src/serializers/type_serializers/string.rs b/src/serializers/type_serializers/string.rs
index 94405313b..48fba0e64 100644
--- a/src/serializers/type_serializers/string.rs
+++ b/src/serializers/type_serializers/string.rs
@@ -17,8 +17,8 @@ impl BuildSerializer for StrSerializer {
     const EXPECTED_TYPE: &'static str = "str";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -30,16 +30,16 @@ impl_py_gc_traverse!(StrSerializer {});
 impl TypeSerializer for StrSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::Str) {
             IsType::Exact => Ok(value.into_py(py)),
             IsType::Subclass => match extra.mode {
-                SerMode::Json => Ok(value.extract::<&str>()?.into_py(py)),
+                SerMode::Json => Ok(value.downcast::<PyString>()?.to_str()?.into_py(py)),
                 _ => Ok(value.into_py(py)),
             },
             IsType::False => {
@@ -49,9 +49,10 @@ impl TypeSerializer for StrSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if let Ok(py_str) = key.downcast::<PyString>() {
-            Ok(py_str.to_string_lossy())
+            // FIXME py cow to avoid the copy
+            Ok(Cow::Owned(py_str.to_string_lossy().into_owned()))
         } else {
             extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
             infer_json_key(key, extra)
@@ -60,10 +61,10 @@ impl TypeSerializer for StrSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyString>() {
@@ -80,7 +81,10 @@ impl TypeSerializer for StrSerializer {
     }
 }
 
-pub fn serialize_py_str<S: serde::ser::Serializer>(py_str: &PyString, serializer: S) -> Result<S::Ok, S::Error> {
+pub fn serialize_py_str<S: serde::ser::Serializer>(
+    py_str: &Bound<'_, PyString>,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
     let s = py_str.to_str().map_err(py_err_se_err)?;
     serializer.serialize_str(s)
 }
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index 042a8ffea..a28258e2a 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -21,8 +21,8 @@ impl BuildSerializer for TimeDeltaSerializer {
     const EXPECTED_TYPE: &'static str = "timedelta";
 
     fn build(
-        _schema: &PyDict,
-        config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let timedelta_mode = TimedeltaMode::from_config(config)?;
@@ -35,9 +35,9 @@ impl_py_gc_traverse!(TimeDeltaSerializer {});
 impl TypeSerializer for TimeDeltaSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match extra.mode {
@@ -52,7 +52,7 @@ impl TypeSerializer for TimeDeltaSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
             Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
             Err(_) => {
@@ -64,10 +64,10 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 5890288d6..3dd5b1ca9 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -29,12 +29,12 @@ impl BuildSerializer for TupleSerializer {
     const EXPECTED_TYPE: &'static str = "tuple";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
+        let items: Bound<'_, PyList> = schema.get_as_req(intern!(py, "items_schema"))?;
         let serializers: Vec<CombinedSerializer> = items
             .iter()
             .map(|item| CombinedSerializer::build(item.downcast()?, config, definitions))
@@ -62,9 +62,9 @@ impl_py_gc_traverse!(TupleSerializer { serializers });
 impl TypeSerializer for TupleSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyTuple>() {
@@ -77,13 +77,13 @@ impl TypeSerializer for TupleSerializer {
                 self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
                     entry
                         .serializer
-                        .to_python(entry.item, entry.include, entry.exclude, extra)
+                        .to_python(&entry.item, entry.include.as_ref(), entry.exclude.as_ref(), extra)
                         .map(|item| items.push(item))
                 })??;
 
                 match extra.mode {
-                    SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
-                    _ => Ok(PyTuple::new(py, items).into_py(py)),
+                    SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
+                    _ => Ok(PyTuple::new_bound(py, items).into_py(py)),
                 }
             }
             Err(_) => {
@@ -93,7 +93,7 @@ impl TypeSerializer for TupleSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match key.downcast::<PyTuple>() {
             Ok(py_tuple) => {
                 let mut key_builder = KeyBuilder::new();
@@ -101,7 +101,7 @@ impl TypeSerializer for TupleSerializer {
                 self.for_each_tuple_item_and_serializer(py_tuple, None, None, extra, |entry| {
                     entry
                         .serializer
-                        .json_key(entry.item, extra)
+                        .json_key(&entry.item, extra)
                         .map(|key| key_builder.push(&key))
                 })??;
 
@@ -116,25 +116,25 @@ impl TypeSerializer for TupleSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyTuple>() {
             Ok(py_tuple) => {
-                let py_tuple: &PyTuple = py_tuple.downcast().map_err(py_err_se_err)?;
+                let py_tuple = py_tuple.downcast::<PyTuple>().map_err(py_err_se_err)?;
 
                 let n_items = py_tuple.len();
                 let mut seq = serializer.serialize_seq(Some(n_items))?;
 
                 self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
                     seq.serialize_element(&PydanticSerializer::new(
-                        entry.item,
+                        &entry.item,
                         entry.serializer,
-                        entry.include,
-                        entry.exclude,
+                        entry.include.as_ref(),
+                        entry.exclude.as_ref(),
                         extra,
                     ))
                 })
@@ -159,9 +159,9 @@ impl TypeSerializer for TupleSerializer {
 }
 
 struct TupleSerializerEntry<'a, 'py> {
-    item: &'py PyAny,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    item: Bound<'py, PyAny>,
+    include: Option<Bound<'py, PyAny>>,
+    exclude: Option<Bound<'py, PyAny>>,
     serializer: &'a CombinedSerializer,
 }
 
@@ -174,9 +174,9 @@ impl TupleSerializer {
     /// levels of `Result`.
     fn for_each_tuple_item_and_serializer<E>(
         &self,
-        tuple: &PyTuple,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        tuple: &Bound<'_, PyTuple>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
         mut f: impl for<'a, 'py> FnMut(TupleSerializerEntry<'a, 'py>) -> Result<(), E>,
     ) -> PyResult<Result<(), E>> {
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index fbef3486a..90b448fb2 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for TypedDictBuilder {
     const EXPECTED_TYPE: &'static str = "typed-dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -32,23 +32,23 @@ impl BuildSerializer for TypedDictBuilder {
             _ => FieldsMode::SimpleDict,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
         let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
             (Some(v), FieldsMode::TypedDictAllow) => {
-                Some(CombinedSerializer::build(v.extract()?, config, definitions)?)
+                Some(CombinedSerializer::build(&v.extract()?, config, definitions)?)
             }
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
         for (key, value) in fields_dict {
-            let key_py: &PyString = key.downcast()?;
+            let key_py = key.downcast_into::<PyString>()?;
             let key: String = key_py.extract()?;
-            let field_info: &PyDict = value.downcast()?;
+            let field_info = value.downcast()?;
 
-            let key_py: Py<PyString> = key_py.into_py(py);
+            let key_py: Py<PyString> = key_py.into();
             let required = field_info.get_as(intern!(py, "required"))?.unwrap_or(total);
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
@@ -57,7 +57,7 @@ impl BuildSerializer for TypedDictBuilder {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
                 fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), required));
             }
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index f05e2220e..51fc07e8d 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -23,16 +23,16 @@ impl BuildSerializer for UnionSerializer {
     const EXPECTED_TYPE: &'static str = "union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let choices: Vec<CombinedSerializer> = schema
-            .get_as_req::<&PyList>(intern!(py, "choices"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(py, "choices"))?
             .iter()
             .map(|choice| {
-                let choice: &PyAny = match choice.downcast::<PyTuple>() {
+                let choice = match choice.downcast::<PyTuple>() {
                     Ok(py_tuple) => py_tuple.get_item(0)?,
                     Err(_) => choice,
                 };
@@ -70,9 +70,9 @@ impl_py_gc_traverse!(UnionSerializer { choices });
 impl TypeSerializer for UnionSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         // try the serializers in left to right order with error_on fallback=true
@@ -105,7 +105,7 @@ impl TypeSerializer for UnionSerializer {
         infer_to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
         for comb_serializer in &self.choices {
@@ -136,10 +136,10 @@ impl TypeSerializer for UnionSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let py = value.py();
@@ -147,7 +147,7 @@ impl TypeSerializer for UnionSerializer {
         new_extra.check = SerCheck::Strict;
         for comb_serializer in &self.choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                Ok(v) => return infer_serialize(v.as_ref(py), serializer, None, None, extra),
+                Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
                     true => (),
                     false => return Err(py_err_se_err(err)),
@@ -158,7 +158,7 @@ impl TypeSerializer for UnionSerializer {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                    Ok(v) => return infer_serialize(v.as_ref(py), serializer, None, None, extra),
+                    Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
                     Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
                         true => (),
                         false => return Err(py_err_se_err(err)),
@@ -186,11 +186,11 @@ impl BuildSerializer for TaggedUnionBuilder {
     const EXPECTED_TYPE: &'static str = "tagged-union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let schema_choices: &PyDict = schema.get_as_req(intern!(schema.py(), "choices"))?;
+        let schema_choices: Bound<'_, PyDict> = schema.get_as_req(intern!(schema.py(), "choices"))?;
         let mut choices: Vec<CombinedSerializer> = Vec::with_capacity(schema_choices.len());
 
         for (_, value) in schema_choices {
diff --git a/src/serializers/type_serializers/url.rs b/src/serializers/type_serializers/url.rs
index e4bbe3bdc..f7dccf017 100644
--- a/src/serializers/type_serializers/url.rs
+++ b/src/serializers/type_serializers/url.rs
@@ -21,8 +21,8 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -34,9 +34,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -52,7 +52,7 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match key.extract::<$extract>() {
                     Ok(py_url) => Ok(Cow::Owned(py_url.__str__().to_string())),
                     Err(_) => {
@@ -64,10 +64,10 @@ macro_rules! build_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.extract::<$extract>() {
diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index 5b66ad241..b2b6572a7 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -10,7 +10,7 @@ use super::{
     IsType, ObType, SerMode, TypeSerializer,
 };
 
-pub(crate) fn uuid_to_string(py_uuid: &PyAny) -> PyResult<String> {
+pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
     Ok(py_uuid.str()?.to_string())
 }
 
@@ -23,8 +23,8 @@ impl BuildSerializer for UuidSerializer {
     const EXPECTED_TYPE: &'static str = "uuid";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -34,9 +34,9 @@ impl BuildSerializer for UuidSerializer {
 impl TypeSerializer for UuidSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -52,7 +52,7 @@ impl TypeSerializer for UuidSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Uuid) {
             IsType::Exact | IsType::Subclass => {
                 let str = uuid_to_string(key)?;
@@ -67,10 +67,10 @@ impl TypeSerializer for UuidSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::Uuid) {
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index d20c273a1..0e50e10a2 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -20,15 +20,15 @@ impl BuildSerializer for WithDefaultSerializer {
     const EXPECTED_TYPE: &'static str = "default";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let default = DefaultType::new(schema)?;
 
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config, definitions)?);
 
         Ok(Self { default, serializer }.into())
     }
@@ -39,24 +39,24 @@ impl_py_gc_traverse!(WithDefaultSerializer { default, serializer });
 impl TypeSerializer for WithDefaultSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         self.serializer.to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.serializer.json_key(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.serializer
diff --git a/src/tools.rs b/src/tools.rs
index bdc41583c..a823311a0 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -6,39 +6,39 @@ use pyo3::types::{PyDict, PyString};
 use pyo3::{ffi, intern, FromPyObject};
 
 pub trait SchemaDict<'py> {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>;
 
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>;
 }
 
-impl<'py> SchemaDict<'py> for PyDict {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+impl<'py> SchemaDict<'py> for Bound<'py, PyDict> {
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
         match self.get_item(key)? {
-            Some(t) => Ok(Some(<T>::extract(t)?)),
+            Some(t) => t.extract().map(Some),
             None => Ok(None),
         }
     }
 
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
         match self.get_item(key)? {
-            Some(t) => <T>::extract(t),
+            Some(t) => t.extract(),
             None => py_err!(PyKeyError; "{}", key),
         }
     }
 }
 
-impl<'py> SchemaDict<'py> for Option<&PyDict> {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+impl<'py> SchemaDict<'py> for Option<&Bound<'py, PyDict>> {
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
@@ -49,7 +49,7 @@ impl<'py> SchemaDict<'py> for Option<&PyDict> {
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
@@ -82,27 +82,50 @@ macro_rules! py_err {
 }
 pub(crate) use py_err;
 
-pub fn function_name(f: &PyAny) -> PyResult<String> {
+pub fn function_name(f: &Bound<'_, PyAny>) -> PyResult<String> {
     match f.getattr(intern!(f.py(), "__name__")) {
         Ok(name) => name.extract(),
         _ => f.repr()?.extract(),
     }
 }
 
-pub fn safe_repr(v: &PyAny) -> Cow<str> {
+pub enum ReprOutput<'py> {
+    Python(Bound<'py, PyString>),
+    Fallback(String),
+}
+
+impl ReprOutput<'_> {
+    pub fn to_cow(&self) -> Cow<'_, str> {
+        match self {
+            ReprOutput::Python(s) => s.to_string_lossy(),
+            ReprOutput::Fallback(s) => s.into(),
+        }
+    }
+}
+
+impl std::fmt::Display for ReprOutput<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ReprOutput::Python(s) => write!(f, "{}", s.to_string_lossy()),
+            ReprOutput::Fallback(s) => write!(f, "{s}"),
+        }
+    }
+}
+
+pub fn safe_repr<'py>(v: &Bound<'py, PyAny>) -> ReprOutput<'py> {
     if let Ok(s) = v.repr() {
-        s.to_string_lossy()
-    } else if let Ok(name) = v.get_type().name() {
-        format!("<unprintable {name} object>").into()
+        ReprOutput::Python(s)
+    } else if let Ok(name) = v.get_type().qualname() {
+        ReprOutput::Fallback(format!("<unprintable {name} object>"))
     } else {
-        "<unprintable object>".into()
+        ReprOutput::Fallback("<unprintable object>".to_owned())
     }
 }
 
 /// Extract an i64 from a python object more quickly, see
 /// https://github.com/PyO3/pyo3/pull/3742#discussion_r1451763928
 #[cfg(not(any(target_pointer_width = "32", windows, PyPy)))]
-pub fn extract_i64(obj: &PyAny) -> Option<i64> {
+pub fn extract_i64(obj: &Bound<'_, PyAny>) -> Option<i64> {
     let val = unsafe { ffi::PyLong_AsLong(obj.as_ptr()) };
     if val == -1 && PyErr::occurred(obj.py()) {
         unsafe { ffi::PyErr_Clear() };
@@ -113,7 +136,7 @@ pub fn extract_i64(obj: &PyAny) -> Option<i64> {
 }
 
 #[cfg(any(target_pointer_width = "32", windows, PyPy))]
-pub fn extract_i64(v: &PyAny) -> Option<i64> {
+pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
     if v.is_instance_of::<pyo3::types::PyInt>() {
         v.extract().ok()
     } else {
diff --git a/src/url.rs b/src/url.rs
index b381e247d..6a6a921fe 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -5,8 +5,8 @@ use std::hash::{Hash, Hasher};
 
 use idna::punycode::decode_to_string;
 use pyo3::exceptions::PyValueError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::pyclass::CompareOp;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 use url::Url;
@@ -34,15 +34,15 @@ impl PyUrl {
 }
 
 fn build_schema_validator(py: Python, schema_type: &str) -> SchemaValidator {
-    let schema: &PyDict = PyDict::new(py);
+    let schema = PyDict::new_bound(py);
     schema.set_item("type", schema_type).unwrap();
-    SchemaValidator::py_new(py, schema, None).unwrap()
+    SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
 #[pymethods]
 impl PyUrl {
     #[new]
-    pub fn py_new(py: Python, url: &PyAny) -> PyResult<Self> {
+    pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
             .validate_python(py, url, None, None, None, None)?;
@@ -158,8 +158,8 @@ impl PyUrl {
     #[classmethod]
     #[pyo3(signature=(*, scheme, host, username=None, password=None, port=None, path=None, query=None, fragment=None))]
     #[allow(clippy::too_many_arguments)]
-    pub fn build<'a>(
-        cls: &'a PyType,
+    pub fn build<'py>(
+        cls: &Bound<'py, PyType>,
         scheme: &str,
         host: &str,
         username: Option<&str>,
@@ -168,7 +168,7 @@ impl PyUrl {
         path: Option<&str>,
         query: Option<&str>,
         fragment: Option<&str>,
-    ) -> PyResult<&'a PyAny> {
+    ) -> PyResult<Bound<'py, PyAny>> {
         let url_host = UrlHostParts {
             username: username.map(Into::into),
             password: password.map(Into::into),
@@ -218,7 +218,7 @@ static SCHEMA_DEFINITION_MULTI_HOST_URL: GILOnceCell<SchemaValidator> = GILOnceC
 #[pymethods]
 impl PyMultiHostUrl {
     #[new]
-    pub fn py_new(py: Python, url: &PyAny) -> PyResult<Self> {
+    pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
             .validate_python(py, url, None, None, None, None)?;
@@ -230,7 +230,7 @@ impl PyMultiHostUrl {
         self.ref_url.scheme()
     }
 
-    pub fn hosts<'py>(&self, py: Python<'py>) -> PyResult<Vec<&'py PyDict>> {
+    pub fn hosts<'py>(&self, py: Python<'py>) -> PyResult<Vec<Bound<'py, PyDict>>> {
         if let Some(extra_urls) = &self.extra_urls {
             let mut hosts = Vec::with_capacity(extra_urls.len() + 1);
             for url in extra_urls {
@@ -358,8 +358,8 @@ impl PyMultiHostUrl {
     #[classmethod]
     #[pyo3(signature=(*, scheme, hosts=None, path=None, query=None, fragment=None, host=None, username=None, password=None, port=None))]
     #[allow(clippy::too_many_arguments)]
-    pub fn build<'a>(
-        cls: &'a PyType,
+    pub fn build<'py>(
+        cls: &Bound<'py, PyType>,
         scheme: &str,
         hosts: Option<Vec<UrlHostParts>>,
         path: Option<&str>,
@@ -370,7 +370,7 @@ impl PyMultiHostUrl {
         username: Option<&str>,
         password: Option<&str>,
         port: Option<u16>,
-    ) -> PyResult<&'a PyAny> {
+    ) -> PyResult<Bound<'py, PyAny>> {
         let mut url =
             if hosts.is_some() && (host.is_some() || username.is_some() || password.is_some() || port.is_some()) {
                 return Err(PyValueError::new_err(
@@ -434,7 +434,7 @@ impl UrlHostParts {
 }
 
 impl FromPyObject<'_> for UrlHostParts {
-    fn extract(ob: &'_ PyAny) -> PyResult<Self> {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let dict = ob.downcast::<PyDict>()?;
         Ok(UrlHostParts {
@@ -464,13 +464,13 @@ impl fmt::Display for UrlHostParts {
     }
 }
 
-fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<&'a PyDict> {
-    let dict = PyDict::new(py);
+fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<Bound<'a, PyDict>> {
+    let dict = PyDict::new_bound(py);
     dict.set_item(
         "username",
         match lib_url.username() {
             "" => py.None(),
-            user => user.into_py(py),
+            user => user.to_object(py),
         },
     )?;
     dict.set_item("password", lib_url.password())?;
diff --git a/src/validators/any.rs b/src/validators/any.rs
index 244117a01..61a58a09c 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -16,8 +16,8 @@ impl BuildValidator for AnyValidator {
     const EXPECTED_TYPE: &'static str = "any";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 661aaf1e4..57c6e1fb7 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{GenericArguments, Input, ValidationMatch};
+use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
 use crate::tools::SchemaDict;
@@ -38,26 +38,29 @@ impl BuildValidator for ArgumentsValidator {
     const EXPECTED_TYPE: &'static str = "arguments";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
-        let arguments_schema: &PyList = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let arguments_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "arguments_schema"))?;
         let mut parameters: Vec<Parameter> = Vec::with_capacity(arguments_schema.len());
 
         let mut positional_params_count = 0;
         let mut had_default_arg = false;
 
         for (arg_index, arg) in arguments_schema.iter().enumerate() {
-            let arg: &PyDict = arg.downcast()?;
+            let arg = arg.downcast::<PyDict>()?;
 
             let name: String = arg.get_as_req(intern!(py, "name"))?;
-            let mode = arg
-                .get_as::<&str>(intern!(py, "mode"))?
+            let mode = arg.get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?;
+            let mode = mode
+                .as_ref()
+                .map(|py_str| py_str.to_str())
+                .transpose()?
                 .unwrap_or("positional_or_keyword");
             let positional = mode == "positional_only" || mode == "positional_or_keyword";
             if positional {
@@ -70,16 +73,16 @@ impl BuildValidator for ArgumentsValidator {
                 kw_lookup_key = match arg.get_item(intern!(py, "alias"))? {
                     Some(alias) => {
                         let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                        Some(LookupKey::from_py(py, alias, alt_alias)?)
+                        Some(LookupKey::from_py(py, &alias, alt_alias)?)
                     }
                     None => Some(LookupKey::from_string(py, &name)),
                 };
-                kwarg_key = Some(PyString::new(py, &name).into());
+                kwarg_key = Some(PyString::new_bound(py, &name).into());
             }
 
-            let schema: &PyAny = arg.get_as_req(intern!(py, "schema"))?;
+            let schema = arg.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Parameter '{}':\n  {}", name, err),
             };
@@ -112,11 +115,11 @@ impl BuildValidator for ArgumentsValidator {
             parameters,
             positional_params_count,
             var_args_validator: match schema.get_item(intern!(py, "var_args_schema"))? {
-                Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
+                Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
                 None => None,
             },
             var_kwargs_validator: match schema.get_item(intern!(py, "var_kwargs_schema"))? {
-                Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
+                Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
                 None => None,
             },
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
@@ -172,7 +175,7 @@ impl Validator for ArgumentsValidator {
         let args = input.validate_args()?;
 
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
-        let output_kwargs = PyDict::new(py);
+        let output_kwargs = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
@@ -181,15 +184,15 @@ impl Validator for ArgumentsValidator {
                 // go through arguments getting the value from args or kwargs and validating it
                 for (index, parameter) in self.parameters.iter().enumerate() {
                     let mut pos_value = None;
-                    if let Some(args) = $args.args {
+                    if let Some(args) = &$args.args {
                         if parameter.positional {
                             pos_value = $get_macro!(args, index);
                         }
                     }
                     let mut kw_value = None;
-                    if let Some(kwargs) = $args.kwargs {
+                    if let Some(kwargs) = &$args.kwargs {
                         if let Some(ref lookup_key) = parameter.kw_lookup_key {
-                            if let Some((lookup_path, value)) = lookup_key.$get_method(kwargs)? {
+                            if let Some((lookup_path, value)) = lookup_key.$get_method(&kwargs)? {
                                 used_kwargs.insert(lookup_path.first_key());
                                 kw_value = Some((lookup_path, value));
                             }
@@ -200,12 +203,12 @@ impl Validator for ArgumentsValidator {
                         (Some(_), Some((_, kw_value))) => {
                             errors.push(ValLineError::new_with_loc(
                                 ErrorTypeDefaults::MultipleArgumentValues,
-                                kw_value,
+                                kw_value.borrow_input(),
                                 parameter.name.clone(),
                             ));
                         }
                         (Some(pos_value), None) => {
-                            match parameter.validator.validate(py, pos_value, state)
+                            match parameter.validator.validate(py, pos_value.borrow_input(), state)
                             {
                                 Ok(value) => output_args.push(value),
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -215,7 +218,7 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, Some((lookup_path, kw_value))) => {
-                            match parameter.validator.validate(py, kw_value, state)
+                            match parameter.validator.validate(py, kw_value.borrow_input(), state)
                             {
                                 Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -257,7 +260,7 @@ impl Validator for ArgumentsValidator {
                     if len > self.positional_params_count {
                         if let Some(ref validator) = self.var_args_validator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                match validator.validate(py, item, state) {
+                                match validator.validate(py, item.borrow_input(), state) {
                                     Ok(value) => output_args.push(value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -273,7 +276,7 @@ impl Validator for ArgumentsValidator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                    item,
+                                    item.borrow_input(),
                                     index + self.positional_params_count,
                                 ));
                             }
@@ -289,7 +292,7 @@ impl Validator for ArgumentsValidator {
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
                                         errors.push(
-                                            err.with_outer_location(raw_key)
+                                            err.with_outer_location(raw_key.clone())
                                                 .with_type(ErrorTypeDefaults::InvalidKey),
                                         );
                                     }
@@ -299,11 +302,11 @@ impl Validator for ArgumentsValidator {
                             };
                             if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
                                 match self.var_kwargs_validator {
-                                    Some(ref validator) => match validator.validate(py, value, state) {
+                                    Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
                                         Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key));
+                                                errors.push(err.with_outer_location(raw_key.clone()));
                                             }
                                         }
                                         Err(err) => return Err(err),
@@ -312,8 +315,8 @@ impl Validator for ArgumentsValidator {
                                         if let ExtraBehavior::Forbid = self.extra {
                                             errors.push(ValLineError::new_with_loc(
                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                value,
-                                                raw_key,
+                                                value.borrow_input(),
+                                                raw_key.clone(),
                                             ));
                                         }
                                     }
@@ -331,7 +334,7 @@ impl Validator for ArgumentsValidator {
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            Ok((PyTuple::new(py, output_args), output_kwargs).to_object(py))
+            Ok((PyTuple::new_bound(py, output_args), output_kwargs).to_object(py))
         }
     }
 
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index b2bb35e5d..97729ed60 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -16,8 +16,8 @@ impl BuildValidator for BoolValidator {
     const EXPECTED_TYPE: &'static str = "bool";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 9dd07d7d3..16b41a05c 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -19,8 +19,8 @@ impl BuildValidator for BytesValidator {
     const EXPECTED_TYPE: &'static str = "bytes";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -106,7 +106,7 @@ impl Validator for BytesConstrainedValidator {
 }
 
 impl BytesConstrainedValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 32b76f582..b0d966811 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
 use pyo3::types::{PyDict, PyTuple};
 
 use crate::errors::ValResult;
@@ -23,22 +24,22 @@ impl BuildValidator for CallValidator {
     const EXPECTED_TYPE: &'static str = "call";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let arguments_schema: &PyAny = schema.get_as_req(intern!(py, "arguments_schema"))?;
-        let arguments_validator = Box::new(build_validator(arguments_schema, config, definitions)?);
+        let arguments_schema = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let arguments_validator = Box::new(build_validator(&arguments_schema, config, definitions)?);
 
         let return_schema = schema.get_item(intern!(py, "return_schema"))?;
         let return_validator = match return_schema {
-            Some(return_schema) => Some(Box::new(build_validator(return_schema, config, definitions)?)),
+            Some(return_schema) => Some(Box::new(build_validator(&return_schema, config, definitions)?)),
             None => None,
         };
-        let function: &PyAny = schema.get_as_req(intern!(py, "function"))?;
-        let function_name: &str = match schema.get_as(intern!(py, "function_name"))? {
+        let function: Bound<'_, PyAny> = schema.get_as_req(intern!(py, "function"))?;
+        let function_name: Py<PyString> = match schema.get_as(intern!(py, "function_name"))? {
             Some(name) => name,
             None => {
                 match function.getattr(intern!(py, "__name__")) {
@@ -48,12 +49,13 @@ impl BuildValidator for CallValidator {
                         if let Ok(func) = function.getattr(intern!(py, "func")) {
                             func.getattr(intern!(py, "__name__"))?.extract()?
                         } else {
-                            "<unknown>"
+                            intern!(py, "<unknown>").clone().into()
                         }
                     }
                 }
             }
         };
+        let function_name = function_name.bind(py);
         let name = format!("{}[{function_name}]", Self::EXPECTED_TYPE);
 
         Ok(Self {
@@ -79,12 +81,12 @@ impl Validator for CallValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let args = self.arguments_validator.validate(py, input, state)?;
+        let args = self.arguments_validator.validate(py, input, state)?.into_bound(py);
 
-        let return_value = if let Ok((args, kwargs)) = args.extract::<(&PyTuple, &PyDict)>(py) {
-            self.function.call(py, args, Some(kwargs))?
-        } else if let Ok(kwargs) = args.downcast::<PyDict>(py) {
-            self.function.call(py, (), Some(kwargs))?
+        let return_value = if let Ok((args, kwargs)) = args.extract::<(Bound<PyTuple>, Bound<PyDict>)>() {
+            self.function.call_bound(py, args, Some(&kwargs))?
+        } else if let Ok(kwargs) = args.downcast::<PyDict>() {
+            self.function.call_bound(py, (), Some(kwargs))?
         } else {
             let msg = "Arguments validator should return a tuple of (args, kwargs) or a dict of kwargs";
             return Err(PyTypeError::new_err(msg).into());
@@ -92,7 +94,7 @@ impl Validator for CallValidator {
 
         if let Some(return_validator) = &self.return_validator {
             return_validator
-                .validate(py, return_value.into_ref(py), state)
+                .validate(py, return_value.bind(py), state)
                 .map_err(|e| e.with_outer_location("return"))
         } else {
             Ok(return_value.to_object(py))
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index e05c99b12..90bc04957 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -14,8 +14,8 @@ impl BuildValidator for CallableValidator {
     const EXPECTED_TYPE: &'static str = "callable";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index 299801dea..0f368f477 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -20,14 +20,14 @@ impl BuildValidator for ChainValidator {
     const EXPECTED_TYPE: &'static str = "chain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let steps: Vec<CombinedValidator> = schema
-            .get_as_req::<&PyList>(intern!(schema.py(), "steps"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(schema.py(), "steps"))?
             .iter()
-            .map(|step| build_validator_steps(step, config, definitions))
+            .map(|step| build_validator_steps(&step, config, definitions))
             .collect::<PyResult<Vec<Vec<CombinedValidator>>>>()?
             .into_iter()
             .flatten()
@@ -54,9 +54,9 @@ impl BuildValidator for ChainValidator {
 
 // either a vec of the steps from a nested `ChainValidator`, or a length-1 vec containing the validator
 // to be flattened into `steps` above
-fn build_validator_steps<'a>(
-    step: &'a PyAny,
-    config: Option<&'a PyDict>,
+fn build_validator_steps(
+    step: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<Vec<CombinedValidator>> {
     let validator = build_validator(step, config, definitions)?;
@@ -80,7 +80,7 @@ impl Validator for ChainValidator {
         let first_step = steps_iter.next().unwrap();
         let value = first_step.validate(py, input, state)?;
 
-        steps_iter.try_fold(value, |v, step| step.validate(py, v.into_ref(py), state))
+        steps_iter.try_fold(value, |v, step| step.validate(py, v.bind(py), state))
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index ec0af567a..0febcdca3 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -19,8 +19,8 @@ pub enum CustomError {
 
 impl CustomError {
     pub fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<Option<Self>> {
         let py = schema.py();
@@ -69,13 +69,13 @@ impl BuildValidator for CustomErrorValidator {
     const EXPECTED_TYPE: &'static str = "custom-error";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let custom_error = CustomError::build(schema, config, definitions)?.unwrap();
-        let schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(schema, config, definitions)?);
+        let schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&schema, config, definitions)?);
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, validator.get_name());
         Ok(Self {
             validator,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index bfeac2115..648f53fdb 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -49,8 +49,8 @@ impl BuildValidator for DataclassArgsValidator {
     const EXPECTED_TYPE: &'static str = "dataclass-args";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -60,33 +60,33 @@ impl BuildValidator for DataclassArgsValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
-        let fields_schema: &PyList = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<Field> = Vec::with_capacity(fields_schema.len());
 
         let mut positional_count = 0;
 
         for field in fields_schema {
-            let field: &PyDict = field.downcast()?;
+            let field = field.downcast::<PyDict>()?;
 
-            let py_name: &PyString = field.get_as_req(intern!(py, "name"))?;
+            let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
             let name: String = py_name.extract()?;
 
             let lookup_key = match field.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, &name),
             };
 
-            let schema: &PyAny = field.get_as_req(intern!(py, "schema"))?;
+            let schema = field.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field '{}':\n  {}", name, err),
             };
@@ -149,7 +149,7 @@ impl Validator for DataclassArgsValidator {
     ) -> ValResult<PyObject> {
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
-        let output_dict = PyDict::new(py);
+        let output_dict = PyDict::new_bound(py);
         let mut init_only_args = self.init_only_count.map(Vec::with_capacity);
 
         let mut errors: Vec<ValLineError> = Vec::new();
@@ -157,13 +157,13 @@ impl Validator for DataclassArgsValidator {
 
         state.with_new_extra(
             Extra {
-                data: Some(output_dict),
+                data: Some(output_dict.clone()),
                 ..*state.extra()
             },
             |state| {
                 macro_rules! set_item {
                     ($field:ident, $value:expr) => {{
-                        let py_name = $field.py_name.as_ref(py);
+                        let py_name = $field.py_name.bind(py);
                         if $field.init_only {
                             if let Some(ref mut init_only_args) = init_only_args {
                                 init_only_args.push($value);
@@ -196,15 +196,15 @@ impl Validator for DataclassArgsValidator {
                             };
 
                             let mut pos_value = None;
-                            if let Some(args) = $args.args {
+                            if let Some(args) = &$args.args {
                                 if !field.kw_only {
                                     pos_value = $get_macro!(args, index);
                                 }
                             }
 
                             let mut kw_value = None;
-                            if let Some(kwargs) = $args.kwargs {
-                                if let Some((lookup_path, value)) = field.lookup_key.$get_method(kwargs)? {
+                            if let Some(kwargs) = &$args.kwargs {
+                                if let Some((lookup_path, value)) = field.lookup_key.$get_method(&kwargs)? {
                                     used_keys.insert(lookup_path.first_key());
                                     kw_value = Some((lookup_path, value));
                                 }
@@ -225,7 +225,7 @@ impl Validator for DataclassArgsValidator {
                                     );
                                 }
                                 // found a positional argument, validate it
-                                (Some(pos_value), None) => match field.validator.validate(py, pos_value, state) {
+                                (Some(pos_value), None) => match field.validator.validate(py, pos_value.borrow_input(), state) {
                                     Ok(value) => set_item!(field, value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -290,7 +290,7 @@ impl Validator for DataclassArgsValidator {
                                 {
                                     errors.push(ValLineError::new_with_loc(
                                         ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                        item,
+                                        item.borrow_input(),
                                         index + self.positional_count,
                                     ));
                                 }
@@ -309,20 +309,20 @@ impl Validator for DataclassArgsValidator {
                                                         errors.push(
                                                             ValLineError::new_with_loc(
                                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                                value,
-                                                                raw_key,
+                                                                value.borrow_input(),
+                                                                raw_key.clone(),
                                                             ),
                                                         );
                                                     }
                                                     ExtraBehavior::Ignore => {}
                                                     ExtraBehavior::Allow => {
                                                         if let Some(ref validator) = self.extras_validator {
-                                                            match validator.validate(py, value, state) {
+                                                            match validator.validate(py, value.borrow_input(), state) {
                                                                 Ok(value) => output_dict
                                                                     .set_item(either_str.as_py_string(py), value)?,
                                                                 Err(ValError::LineErrors(line_errors)) => {
                                                                     for err in line_errors {
-                                                                        errors.push(err.with_outer_location(raw_key));
+                                                                        errors.push(err.with_outer_location(raw_key.clone()));
                                                                     }
                                                                 }
                                                                 Err(err) => return Err(err),
@@ -337,7 +337,7 @@ impl Validator for DataclassArgsValidator {
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
                                                 errors.push(
-                                                    err.with_outer_location(raw_key)
+                                                    err.with_outer_location(raw_key.clone())
                                                         .with_type(ErrorTypeDefaults::InvalidKey),
                                                 );
                                             }
@@ -357,13 +357,13 @@ impl Validator for DataclassArgsValidator {
                         // StringMapping cannot pass positional args, so wrap the PyDict
                         // in a type with guaranteed empty args array for sake of the process
                         // macro
-                        struct StringMappingArgs<'a> {
-                            args: Option<&'a PyTuple>,
-                            kwargs: Option<&'a PyDict>,
+                        struct StringMappingArgs<'py> {
+                            args: Option<Bound<'py, PyTuple>>,
+                            kwargs: Option<Bound<'py, PyDict>>,
                         }
                         let a = StringMappingArgs {
                             args: None,
-                            kwargs: Some(a),
+                            kwargs: Some(a.clone()),
                         };
                         process!(a, py_get_string_mapping_item, py_get, py_slice);
                     }
@@ -373,7 +373,7 @@ impl Validator for DataclassArgsValidator {
         )?;
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
-                Ok((output_dict, PyTuple::new(py, init_only_args)).to_object(py))
+                Ok((output_dict, PyTuple::new_bound(py, init_only_args)).to_object(py))
             } else {
                 Ok((output_dict, py.None()).to_object(py))
             }
@@ -385,12 +385,12 @@ impl Validator for DataclassArgsValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let dict: &PyDict = obj.downcast()?;
+        let dict = obj.downcast::<PyDict>()?;
 
         let ok = |output: PyObject| {
             dict.set_item(field_name, output)?;
@@ -398,7 +398,7 @@ impl Validator for DataclassArgsValidator {
             // which doesn't make much sense in this context but we need to put something there
             // so that function validators that sit between DataclassValidator and DataclassArgsValidator
             // always get called the same shape of data.
-            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()]).into_py(py))
+            Ok(PyTuple::new_bound(py, vec![dict.to_object(py), py.None()]).into_py(py))
         };
 
         if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
@@ -413,13 +413,13 @@ impl Validator for DataclassArgsValidator {
             let data_dict = dict.copy()?;
             if let Err(err) = data_dict.del_item(field_name) {
                 // KeyError is fine here as the field might not be in the dict
-                if !err.get_type(py).is(PyType::new::<PyKeyError>(py)) {
+                if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
                     return Err(err.into());
                 }
             }
             match state.with_new_extra(
                 Extra {
-                    data: Some(data_dict),
+                    data: Some(data_dict.clone()),
                     ..*state.extra()
                 },
                 |state| field.validator.validate(py, field_value, state),
@@ -476,25 +476,26 @@ impl BuildValidator for DataclassValidator {
     const EXPECTED_TYPE: &'static str = "dataclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         // dataclasses ignore the parent config and always use the config from this dataclasses
         let config = schema.get_as(intern!(py, "config"))?;
+        let config = config.as_ref();
 
         let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
         let name = match schema.get_as_req::<String>(intern!(py, "cls_name")) {
             Ok(name) => name,
             Err(_) => class.getattr(intern!(py, "__name__"))?.extract()?,
         };
-        let sub_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        let validator = build_validator(sub_schema, config, definitions)?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let validator = build_validator(&sub_schema, config, definitions)?;
 
         let post_init = if schema.get_as::<bool>(intern!(py, "post_init"))?.unwrap_or(false) {
-            Some(PyString::new(py, "__post_init__").into_py(py))
+            Some(PyString::new_bound(py, "__post_init__").into())
         } else {
             None
         };
@@ -511,11 +512,12 @@ impl BuildValidator for DataclassValidator {
             class: class.into(),
             fields,
             post_init,
-            revalidate: Revalidate::from_str(schema_or_config_same(
-                schema,
-                config,
-                intern!(py, "revalidate_instances"),
-            )?)?,
+            revalidate: Revalidate::from_str(
+                schema_or_config_same::<Bound<'_, PyString>>(schema, config, intern!(py, "revalidate_instances"))?
+                    .as_ref()
+                    .map(|s| s.to_str())
+                    .transpose()?,
+            )?,
             name,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             slots: schema.get_as(intern!(py, "slots"))?.unwrap_or(false),
@@ -539,14 +541,14 @@ impl Validator for DataclassValidator {
         }
 
         // same logic as on models
-        let class = self.class.as_ref(py);
+        let class = self.class.bind(py);
         if let Some(py_input) = input.input_is_instance(class) {
             if self.revalidate.should_revalidate(py_input, class) {
-                let input_dict: &PyAny = self.dataclass_to_dict(py, py_input)?;
-                let val_output = self.validator.validate(py, input_dict, state)?;
-                let dc = create_class(self.class.as_ref(py))?;
-                self.set_dict_call(py, dc.as_ref(py), val_output, input)?;
-                Ok(dc)
+                let input_dict = self.dataclass_to_dict(py_input)?;
+                let val_output = self.validator.validate(py, input_dict.as_any(), state)?;
+                let dc = create_class(self.class.bind(py))?;
+                self.set_dict_call(py, &dc, val_output, input)?;
+                Ok(dc.into())
             } else {
                 Ok(input.to_object(py))
             }
@@ -561,31 +563,31 @@ impl Validator for DataclassValidator {
         } else {
             let val_output = self.validator.validate(py, input, state)?;
             state.floor_exactness(Exactness::Strict);
-            let dc = create_class(self.class.as_ref(py))?;
-            self.set_dict_call(py, dc.as_ref(py), val_output, input)?;
-            Ok(dc)
+            let dc = create_class(self.class.bind(py))?;
+            self.set_dict_call(py, &dc, val_output, input)?;
+            Ok(dc.into())
         }
     }
 
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
         }
 
-        let new_dict = self.dataclass_to_dict(py, obj)?;
+        let new_dict = self.dataclass_to_dict(obj)?;
 
         new_dict.set_item(field_name, field_value)?;
 
-        let val_assignment_result = self
-            .validator
-            .validate_assignment(py, new_dict, field_name, field_value, state)?;
+        let val_assignment_result =
+            self.validator
+                .validate_assignment(py, new_dict.as_any(), field_name, field_value, state)?;
 
         let (dc_dict, _): (&PyDict, PyObject) = val_assignment_result.extract(py)?;
 
@@ -611,7 +613,7 @@ impl DataclassValidator {
     fn validate_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        self_instance: &'s PyAny,
+        self_instance: &Bound<'_, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
@@ -625,11 +627,11 @@ impl DataclassValidator {
         Ok(self_instance.into_py(py))
     }
 
-    fn dataclass_to_dict<'py>(&self, py: Python<'py>, dc: &'py PyAny) -> PyResult<&'py PyDict> {
-        let dict = PyDict::new(py);
+    fn dataclass_to_dict<'py>(&self, dc: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
+        let py = dc.py();
+        let dict = PyDict::new_bound(py);
 
         for field_name in &self.fields {
-            let field_name = field_name.as_ref(py);
             dict.set_item(field_name, dc.getattr(field_name)?)?;
         }
         Ok(dict)
@@ -638,14 +640,14 @@ impl DataclassValidator {
     fn set_dict_call<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        dc: &PyAny,
+        dc: &Bound<'_, PyAny>,
         val_output: PyObject,
         input: &'data impl Input<'data>,
     ) -> ValResult<()> {
-        let (dc_dict, post_init_kwargs): (&PyAny, &PyAny) = val_output.extract(py)?;
+        let (dc_dict, post_init_kwargs): (Bound<'_, PyAny>, Bound<'_, PyAny>) = val_output.extract(py)?;
         if self.slots {
-            let dc_dict: &PyDict = dc_dict.downcast()?;
-            for (key, value) in dc_dict {
+            let dc_dict = dc_dict.downcast::<PyDict>()?;
+            for (key, value) in dc_dict.iter() {
                 force_setattr(py, dc, key, value)?;
             }
         } else {
@@ -653,12 +655,12 @@ impl DataclassValidator {
         }
 
         if let Some(ref post_init) = self.post_init {
-            let post_init = post_init.as_ref(py);
-            let r = if post_init_kwargs.is_none() {
+            let post_init = post_init.bind(py);
+            let r = if PyAnyMethods::is_none(&post_init_kwargs) {
                 dc.call_method0(post_init)
             } else {
                 let args = post_init_kwargs.downcast::<PyTuple>()?;
-                dc.call_method1(post_init, args)
+                dc.call_method1(post_init, args.as_gil_ref())
             };
             r.map_err(|e| convert_err(py, e, input))?;
         }
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 2329dcf2a..009878a62 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -24,8 +24,8 @@ impl BuildValidator for DateValidator {
     const EXPECTED_TYPE: &'static str = "date";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
@@ -158,7 +158,7 @@ struct DateConstraints {
 }
 
 impl DateConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: convert_pydate(schema, intern!(py, "le"))?,
@@ -175,8 +175,8 @@ impl DateConstraints {
     }
 }
 
-fn convert_pydate(schema: &PyDict, field: &PyString) -> PyResult<Option<Date>> {
-    match schema.get_as::<&PyDate>(field)? {
+fn convert_pydate(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Date>> {
+    match schema.get_as::<Bound<'_, PyDate>>(field)? {
         Some(date) => Ok(Some(EitherDate::Py(date).as_raw()?)),
         None => Ok(None),
     }
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 94dc7ba05..bd8944fb4 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -1,7 +1,7 @@
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
-use pyo3::types::{PyDateTime, PyDict, PyString};
+use pyo3::sync::GILOnceCell;
+use pyo3::types::{PyDict, PyString};
 use speedate::{DateTime, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
@@ -24,14 +24,14 @@ pub struct DateTimeValidator {
 }
 
 pub(crate) fn extract_microseconds_precision(
-    schema: &PyDict,
-    config: Option<&PyDict>,
+    schema: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
 ) -> PyResult<speedate::MicrosecondsPrecisionOverflowBehavior> {
     schema_or_config_same(schema, config, intern!(schema.py(), "microseconds_precision"))?
         .map_or(
             Ok(speedate::MicrosecondsPrecisionOverflowBehavior::Truncate),
             |v: &PyString| {
-                speedate::MicrosecondsPrecisionOverflowBehavior::try_from(String::extract(v).unwrap().as_str())
+                speedate::MicrosecondsPrecisionOverflowBehavior::try_from(v.extract::<String>().unwrap().as_str())
             },
         )
         .map_err(|_| {
@@ -43,8 +43,8 @@ impl BuildValidator for DateTimeValidator {
     const EXPECTED_TYPE: &'static str = "datetime";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
@@ -191,7 +191,7 @@ struct DateTimeConstraints {
 }
 
 impl DateTimeConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: py_datetime_as_datetime(schema, intern!(py, "le"))?,
@@ -209,8 +209,8 @@ impl DateTimeConstraints {
     }
 }
 
-fn py_datetime_as_datetime(schema: &PyDict, field: &PyString) -> PyResult<Option<DateTime>> {
-    match schema.get_as::<&PyDateTime>(field)? {
+fn py_datetime_as_datetime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<DateTime>> {
+    match schema.get_as(field)? {
         Some(dt) => Ok(Some(EitherDateTime::Py(dt).as_raw()?)),
         None => Ok(None),
     }
@@ -249,7 +249,7 @@ pub struct NowConstraint {
 static TIME_LOCALTIME: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_localtime(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("time")?.getattr("localtime")?.into_py(py))
+    Ok(py.import_bound("time")?.getattr("localtime")?.into_py(py))
 }
 
 impl NowConstraint {
@@ -261,19 +261,15 @@ impl NowConstraint {
             Ok(utc_offset)
         } else {
             let localtime = TIME_LOCALTIME.get_or_init(py, || get_localtime(py).unwrap());
-            localtime
-                .as_ref(py)
-                .call0()?
-                .getattr(intern!(py, "tm_gmtoff"))?
-                .extract()
+            localtime.bind(py).call0()?.getattr(intern!(py, "tm_gmtoff"))?.extract()
         }
     }
 
-    pub fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    pub fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
-        match schema.get_as(intern!(py, "now_op"))? {
+        match schema.get_as::<Bound<'_, PyString>>(intern!(py, "now_op"))? {
             Some(op) => Ok(Some(Self {
-                op: NowOp::from_str(op)?,
+                op: NowOp::from_str(op.to_str()?)?,
                 utc_offset: schema.get_as(intern!(py, "now_utc_offset"))?,
             })),
             None => Ok(None),
@@ -296,7 +292,7 @@ impl TZConstraint {
         }
     }
 
-    pub(super) fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    pub(super) fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let tz_constraint = match schema.get_item(intern!(py, "tz_constraint"))? {
             Some(c) => c,
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 85f81a38e..f4f292d76 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -16,17 +16,17 @@ use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationSta
 
 static DECIMAL_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
-pub fn get_decimal_type(py: Python) -> Py<PyType> {
+pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
     DECIMAL_TYPE
         .get_or_init(py, || {
-            py.import("decimal")
+            py.import_bound("decimal")
                 .and_then(|decimal_module| decimal_module.getattr("Decimal"))
                 .unwrap()
                 .extract::<&PyType>()
                 .unwrap()
                 .into()
         })
-        .clone()
+        .bind(py)
 }
 
 #[derive(Debug, Clone)]
@@ -46,8 +46,8 @@ pub struct DecimalValidator {
 impl BuildValidator for DecimalValidator {
     const EXPECTED_TYPE: &'static str = "decimal";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -83,12 +83,14 @@ impl_py_gc_traverse!(DecimalValidator {
     gt
 });
 
-fn extract_decimal_digits_info(decimal: &PyAny, normalized: bool, py: Python<'_>) -> ValResult<(u64, u64)> {
-    let mut normalized_decimal: Option<&PyAny> = None;
+fn extract_decimal_digits_info(decimal: &Bound<'_, PyAny>, normalized: bool) -> ValResult<(u64, u64)> {
+    let py = decimal.py();
+    let mut normalized_decimal: Option<Bound<'_, PyAny>> = None;
     if normalized {
-        normalized_decimal = Some(decimal.call_method0(intern!(py, "normalize")).unwrap_or(decimal));
+        normalized_decimal = decimal.call_method0(intern!(py, "normalize")).ok();
     }
-    let (_, digit_tuple, exponent): (&PyAny, &PyTuple, &PyAny) = normalized_decimal
+    let (_, digit_tuple, exponent): (Bound<'_, PyAny>, Bound<'_, PyTuple>, Bound<'_, PyAny>) = normalized_decimal
+        .as_ref()
         .unwrap_or(decimal)
         .call_method0(intern!(py, "as_tuple"))?
         .extract()?;
@@ -129,8 +131,8 @@ impl Validator for DecimalValidator {
             }
 
             if self.check_digits {
-                if let Ok((normalized_decimals, normalized_digits)) = extract_decimal_digits_info(decimal, true, py) {
-                    if let Ok((decimals, digits)) = extract_decimal_digits_info(decimal, false, py) {
+                if let Ok((normalized_decimals, normalized_digits)) = extract_decimal_digits_info(&decimal, true) {
+                    if let Ok((decimals, digits)) = extract_decimal_digits_info(&decimal, false) {
                         if let Some(max_digits) = self.max_digits {
                             if (digits > max_digits) & (normalized_digits > max_digits) {
                                 return Err(ValError::new(
@@ -181,20 +183,17 @@ impl Validator for DecimalValidator {
 
         if let Some(multiple_of) = &self.multiple_of {
             // fraction = (decimal / multiple_of) % 1
-            let fraction: &PyAny = unsafe {
-                let division = PyObject::from_owned_ptr_or_err(
-                    py,
-                    pyo3::ffi::PyNumber_TrueDivide(decimal.as_ptr(), multiple_of.as_ptr()),
-                )?;
+            let fraction = unsafe {
+                let division = decimal.div(multiple_of)?;
                 let one = 1.to_object(py);
-                py.from_owned_ptr_or_err(pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
+                Bound::from_owned_ptr_or_err(py, pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
             };
             let zero = 0.to_object(py);
             if !fraction.eq(&zero)? {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
                         multiple_of: multiple_of.to_string().into(),
-                        context: Some([("multiple_of", multiple_of)].into_py_dict(py).into()),
+                        context: Some([("multiple_of", multiple_of)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -217,7 +216,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThanEqual {
                         le: Number::String(le.to_string()),
-                        context: Some([("le", le)].into_py_dict(py).into()),
+                        context: Some([("le", le)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -228,7 +227,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThan {
                         lt: Number::String(lt.to_string()),
-                        context: Some([("lt", lt)].into_py_dict(py).into()),
+                        context: Some([("lt", lt)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -239,7 +238,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThanEqual {
                         ge: Number::String(ge.to_string()),
-                        context: Some([("ge", ge)].into_py_dict(py).into()),
+                        context: Some([("ge", ge)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -250,7 +249,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThan {
                         gt: Number::String(gt.to_string()),
-                        context: Some([("gt", gt)].into_py_dict(py).into()),
+                        context: Some([("gt", gt)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -265,33 +264,25 @@ impl Validator for DecimalValidator {
     }
 }
 
-pub(crate) fn create_decimal<'a>(arg: &'a PyAny, input: &'a impl Input<'a>, py: Python<'a>) -> ValResult<&'a PyAny> {
-    let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-    decimal_type_obj
-        .call1(py, (arg,))
-        .map_err(|e| {
-            let decimal_exception = match arg
-                .py()
-                .import("decimal")
-                .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
-            {
-                Ok(decimal_exception) => decimal_exception,
-                Err(e) => return ValError::InternalErr(e),
-            };
-            handle_decimal_new_error(arg.py(), input.as_error_value(), e, decimal_exception)
-        })
-        .map(|v| v.into_ref(py))
+pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &'a impl Input<'a>) -> ValResult<Bound<'a, PyAny>> {
+    let py = arg.py();
+    get_decimal_type(py).call1((arg,)).map_err(|e| {
+        let decimal_exception = match py
+            .import_bound("decimal")
+            .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
+        {
+            Ok(decimal_exception) => decimal_exception,
+            Err(e) => return ValError::InternalErr(e),
+        };
+        handle_decimal_new_error(input.as_error_value(), e, decimal_exception)
+    })
 }
 
-fn handle_decimal_new_error<'a>(
-    py: Python<'a>,
-    input: InputValue,
-    error: PyErr,
-    decimal_exception: &'a PyAny,
-) -> ValError {
+fn handle_decimal_new_error(input: InputValue, error: PyErr, decimal_exception: Bound<'_, PyAny>) -> ValError {
+    let py = decimal_exception.py();
     if error.matches(py, decimal_exception) {
         ValError::new_custom_input(ErrorTypeDefaults::DecimalParsing, input)
-    } else if error.matches(py, PyTypeError::type_object(py)) {
+    } else if error.matches(py, PyTypeError::type_object_bound(py)) {
         ValError::new_custom_input(ErrorTypeDefaults::DecimalType, input)
     } else {
         ValError::InternalErr(error)
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index e4bc270c2..6e9b05a6b 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -1,5 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
 use pyo3::types::{PyDict, PyList};
 
 use crate::definitions::DefinitionRef;
@@ -18,24 +19,24 @@ impl BuildValidator for DefinitionsValidatorBuilder {
     const EXPECTED_TYPE: &'static str = "definitions";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
+        let schema_definitions: Bound<'_, PyList> = schema.get_as_req(intern!(py, "definitions"))?;
 
         for schema_definition in schema_definitions {
             let reference = schema_definition
-                .extract::<&PyDict>()?
+                .extract::<Bound<'_, PyDict>>()?
                 .get_as_req::<String>(intern!(py, "ref"))?;
-            let validator = build_validator(schema_definition, config, definitions)?;
+            let validator = build_validator(&schema_definition, config, definitions)?;
             definitions.add_definition(reference, validator)?;
         }
 
-        let inner_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        build_validator(inner_schema, config, definitions)
+        let inner_schema = schema.get_as_req(intern!(py, "schema"))?;
+        build_validator(&inner_schema, config, definitions)
     }
 }
 
@@ -54,13 +55,13 @@ impl BuildValidator for DefinitionRefValidator {
     const EXPECTED_TYPE: &'static str = "definition-ref";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
+        let schema_ref: Bound<'_, PyString> = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
 
-        let definition = definitions.get_definition(schema_ref);
+        let definition = definitions.get_definition(schema_ref.to_str()?);
         Ok(Self::new(definition).into())
     }
 }
@@ -90,9 +91,9 @@ impl Validator for DefinitionRefValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 3f8ff820b..7f5337f9e 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -30,17 +30,17 @@ impl BuildValidator for DictValidator {
     const EXPECTED_TYPE: &'static str = "dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let key_validator = match schema.get_item(intern!(py, "keys_schema"))? {
-            Some(schema) => Box::new(build_validator(schema, config, definitions)?),
+            Some(schema) => Box::new(build_validator(&schema, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
         let value_validator = match schema.get_item(intern!(py, "values_schema"))? {
-            Some(d) => Box::new(build_validator(d, config, definitions)?),
+            Some(d) => Box::new(build_validator(&d, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
         let name = format!(
@@ -77,14 +77,14 @@ impl Validator for DictValidator {
         let dict = input.validate_dict(strict)?;
         match dict {
             GenericMapping::PyDict(py_dict) => {
-                self.validate_generic_mapping(py, input, DictGenericIterator::new(py_dict)?, state)
+                self.validate_generic_mapping(py, input, DictGenericIterator::new(&py_dict)?, state)
             }
             GenericMapping::PyMapping(mapping) => {
                 state.floor_exactness(super::Exactness::Lax);
-                self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
+                self.validate_generic_mapping(py, input, MappingGenericIterator::new(&mapping)?, state)
             }
             GenericMapping::StringMapping(dict) => {
-                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(dict)?, state)
+                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(&dict)?, state)
             }
             GenericMapping::PyGetAttr(_, _) => unreachable!(),
             GenericMapping::JsonObject(json_object) => {
@@ -111,7 +111,7 @@ impl DictValidator {
         >,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let output = PyDict::new(py);
+        let output = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::new();
 
         let key_validator = self.key_validator.as_ref();
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 9bb293964..a1d1f485f 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -16,8 +16,8 @@ pub struct FloatBuilder;
 impl BuildValidator for FloatBuilder {
     const EXPECTED_TYPE: &'static str = "float";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -48,8 +48,8 @@ impl BuildValidator for FloatValidator {
     const EXPECTED_TYPE: &'static str = "float";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -175,8 +175,8 @@ impl Validator for ConstrainedFloatValidator {
 impl BuildValidator for ConstrainedFloatValidator {
     const EXPECTED_TYPE: &'static str = "float";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index ceb60eb9d..1d3b602e0 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -41,10 +41,10 @@ impl Validator for FrozenSetValidator {
             _ => Exactness::Lax,
         };
         state.floor_exactness(exactness);
-        let f_set = PyFrozenSet::empty(py)?;
+        let f_set = PyFrozenSet::empty_bound(py)?;
         collection.validate_to_set(
             py,
-            f_set,
+            &f_set,
             input,
             self.max_length,
             "Frozenset",
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 51195fbe4..3cf298af2 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -26,11 +26,11 @@ struct FunctionInfo {
     pub info_arg: bool,
 }
 
-fn destructure_function_schema(schema: &PyDict) -> PyResult<FunctionInfo> {
-    let func_dict: &PyDict = schema.get_as_req(intern!(schema.py(), "function"))?;
-    let function: &PyAny = func_dict.get_as_req(intern!(schema.py(), "function"))?;
-    let func_type: &str = func_dict.get_as_req(intern!(schema.py(), "type"))?;
-    let info_arg = match func_type {
+fn destructure_function_schema(schema: &Bound<'_, PyDict>) -> PyResult<FunctionInfo> {
+    let func_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(schema.py(), "function"))?;
+    let function = func_dict.get_as_req(intern!(schema.py(), "function"))?;
+    let func_type: Bound<'_, PyString> = func_dict.get_as_req(intern!(schema.py(), "type"))?;
+    let info_arg = match func_type.to_str()? {
         "with-info" => true,
         "no-info" => false,
         _ => unreachable!(),
@@ -39,7 +39,7 @@ fn destructure_function_schema(schema: &PyDict) -> PyResult<FunctionInfo> {
         .get_as::<&PyString>(intern!(schema.py(), "field_name"))?
         .map(Into::into);
     Ok(FunctionInfo {
-        function: function.into(),
+        function,
         field_name,
         info_arg,
     })
@@ -50,24 +50,24 @@ macro_rules! impl_build {
         impl BuildValidator for $impl_name {
             const EXPECTED_TYPE: &'static str = $name;
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedValidator>,
             ) -> PyResult<CombinedValidator> {
                 let py = schema.py();
-                let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
+                let validator = build_validator(&schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
                 let func_info = destructure_function_schema(schema)?;
                 let name = format!(
                     "{}[{}(), {}]",
                     $name,
-                    function_name(func_info.function.as_ref(py))?,
+                    function_name(func_info.function.bind(py))?,
                     validator.get_name()
                 );
                 Ok(Self {
                     validator: Box::new(validator),
                     func: func_info.function,
                     config: match config {
-                        Some(c) => c.into(),
+                        Some(c) => c.clone().into(),
                         None => py.None(),
                     },
                     name,
@@ -80,46 +80,6 @@ macro_rules! impl_build {
     };
 }
 
-macro_rules! impl_validator {
-    ($name:ident) => {
-        impl_py_gc_traverse!($name {
-            validator,
-            func,
-            config
-        });
-
-        impl Validator for $name {
-            fn validate<'data>(
-                &self,
-                py: Python<'data>,
-                input: &'data impl Input<'data>,
-                state: &mut ValidationState<'_>,
-            ) -> ValResult<PyObject> {
-                let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
-                self._validate(validate, py, input, state)
-            }
-            fn validate_assignment<'data>(
-                &self,
-                py: Python<'data>,
-                obj: &'data PyAny,
-                field_name: &'data str,
-                field_value: &'data PyAny,
-                state: &mut ValidationState,
-            ) -> ValResult<PyObject> {
-                let validate = move |v, s: &mut ValidationState<'_>| {
-                    self.validator
-                        .validate_assignment(py, v, field_name, field_value, s)
-                };
-                self._validate(validate, py, obj, state)
-            }
-
-            fn get_name(&self) -> &str {
-                &self.name
-            }
-        }
-    };
-}
-
 #[derive(Debug)]
 pub struct FunctionBeforeValidator {
     validator: Box<CombinedValidator>,
@@ -135,7 +95,7 @@ impl_build!(FunctionBeforeValidator, "function-before");
 impl FunctionBeforeValidator {
     fn _validate<'s, 'data>(
         &'s self,
-        call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<PyObject>,
+        call: impl FnOnce(Bound<'data, PyAny>, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &'s mut ValidationState<'_>,
@@ -147,11 +107,44 @@ impl FunctionBeforeValidator {
             self.func.call1(py, (input.to_object(py),))
         };
         let value = r.map_err(|e| convert_err(py, e, input))?;
-        call(value.into_ref(py), state)
+        call(value.into_bound(py), state)
     }
 }
 
-impl_validator!(FunctionBeforeValidator);
+impl_py_gc_traverse!(FunctionBeforeValidator {
+    validator,
+    func,
+    config
+});
+
+impl Validator for FunctionBeforeValidator {
+    fn validate<'data>(
+        &self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        state: &mut ValidationState<'_>,
+    ) -> ValResult<PyObject> {
+        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, &v, s);
+        self._validate(validate, py, input, state)
+    }
+    fn validate_assignment<'data>(
+        &self,
+        py: Python<'data>,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
+        state: &mut ValidationState,
+    ) -> ValResult<PyObject> {
+        let validate = move |v, s: &mut ValidationState<'_>| {
+            self.validator.validate_assignment(py, &v, field_name, field_value, s)
+        };
+        self._validate(validate, py, obj, state)
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}
 
 #[derive(Debug)]
 pub struct FunctionAfterValidator {
@@ -184,7 +177,39 @@ impl FunctionAfterValidator {
     }
 }
 
-impl_validator!(FunctionAfterValidator);
+impl_py_gc_traverse!(FunctionAfterValidator {
+    validator,
+    func,
+    config
+});
+
+impl Validator for FunctionAfterValidator {
+    fn validate<'data>(
+        &self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        state: &mut ValidationState<'_>,
+    ) -> ValResult<PyObject> {
+        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
+        self._validate(validate, py, input, state)
+    }
+    fn validate_assignment<'data>(
+        &self,
+        py: Python<'data>,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
+        state: &mut ValidationState,
+    ) -> ValResult<PyObject> {
+        let validate =
+            move |v, s: &mut ValidationState<'_>| self.validator.validate_assignment(py, v, field_name, field_value, s);
+        self._validate(validate, py, obj, state)
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct FunctionPlainValidator {
@@ -199,8 +224,8 @@ impl BuildValidator for FunctionPlainValidator {
     const EXPECTED_TYPE: &'static str = "function-plain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -208,13 +233,10 @@ impl BuildValidator for FunctionPlainValidator {
         Ok(Self {
             func: function_info.function.clone(),
             config: match config {
-                Some(c) => c.into(),
+                Some(c) => c.clone().into(),
                 None => py.None(),
             },
-            name: format!(
-                "function-plain[{}()]",
-                function_name(function_info.function.as_ref(py))?
-            ),
+            name: format!("function-plain[{}()]", function_name(function_info.function.bind(py))?),
             field_name: function_info.field_name.clone(),
             info_arg: function_info.info_arg,
         }
@@ -261,12 +283,12 @@ impl BuildValidator for FunctionWrapValidator {
     const EXPECTED_TYPE: &'static str = "function-wrap";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
+        let validator = build_validator(&schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
         let function_info = destructure_function_schema(schema)?;
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
         let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
@@ -274,10 +296,10 @@ impl BuildValidator for FunctionWrapValidator {
             validator: Arc::new(validator),
             func: function_info.function.clone(),
             config: match config {
-                Some(c) => c.into(),
+                Some(c) => c.clone().into(),
                 None => py.None(),
             },
-            name: format!("function-wrap[{}()]", function_name(function_info.function.as_ref(py))?),
+            name: format!("function-wrap[{}()]", function_name(function_info.function.bind(py))?),
             field_name: function_info.field_name.clone(),
             info_arg: function_info.info_arg,
             hide_input_in_errors,
@@ -290,7 +312,7 @@ impl BuildValidator for FunctionWrapValidator {
 impl FunctionWrapValidator {
     fn _validate<'s, 'data>(
         &'s self,
-        handler: &'s PyAny,
+        handler: &Bound<'_, PyAny>,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
@@ -328,8 +350,8 @@ impl Validator for FunctionWrapValidator {
                 self.validation_error_cause,
             ),
         };
-        let handler = Py::new(py, handler)?.into_ref(py);
-        let result = self._validate(handler, py, input.to_object(py).into_ref(py), state);
+        let handler = Bound::new(py, handler)?;
+        let result = self._validate(handler.as_any(), py, input, state);
         state.exactness = handler.borrow_mut().validator.exactness;
         result
     }
@@ -337,9 +359,9 @@ impl Validator for FunctionWrapValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let handler = AssignmentValidatorCallable {
@@ -354,7 +376,7 @@ impl Validator for FunctionWrapValidator {
             updated_field_name: field_name.to_string(),
             updated_field_value: field_value.to_object(py),
         };
-        self._validate(Py::new(py, handler)?.into_ref(py), py, obj, state)
+        self._validate(Bound::new(py, handler)?.as_any(), py, obj, state)
     }
 
     fn get_name(&self) -> &str {
@@ -370,7 +392,12 @@ struct ValidatorCallable {
 
 #[pymethods]
 impl ValidatorCallable {
-    fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
+    fn __call__(
+        &mut self,
+        py: Python,
+        input_value: &Bound<'_, PyAny>,
+        outer_location: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let outer_location = outer_location.map(Into::into);
         self.validator.validate(py, input_value, outer_location)
     }
@@ -398,13 +425,18 @@ struct AssignmentValidatorCallable {
 
 #[pymethods]
 impl AssignmentValidatorCallable {
-    fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
+    fn __call__(
+        &mut self,
+        py: Python,
+        input_value: &Bound<'_, PyAny>,
+        outer_location: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let outer_location = outer_location.map(Into::into);
         self.validator.validate_assignment(
             py,
             input_value,
             self.updated_field_name.as_str(),
-            self.updated_field_value.as_ref(py),
+            self.updated_field_value.bind(py),
             outer_location,
         )
     }
@@ -440,18 +472,18 @@ macro_rules! py_err_string {
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
 pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
-        let error_value = err.value(py);
+        let error_value = err.value_bound(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
             pydantic_value_error.into_val_error(input)
         } else if let Ok(pydantic_error_type) = error_value.extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
-        } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
+        } else if let Ok(validation_error) = err.value_bound(py).extract::<ValidationError>() {
             validation_error.into_val_error()
         } else {
             py_err_string!(py, err, error_value, ValueError, input)
         }
     } else if err.is_instance_of::<PyAssertionError>(py) {
-        py_err_string!(py, err, err.value(py), AssertionError, input)
+        py_err_string!(py, err, err.value_bound(py), AssertionError, input)
     } else if err.is_instance_of::<PydanticOmit>(py) {
         ValError::Omit
     } else if err.is_instance_of::<PydanticUseDefault>(py) {
@@ -474,9 +506,9 @@ impl ValidationInfo {
     fn new(py: Python, extra: &Extra, config: &PyObject, field_name: Option<Py<PyString>>) -> Self {
         Self {
             config: config.clone_ref(py),
-            context: extra.context.map(Into::into),
+            context: extra.context.map(|ctx| ctx.clone().into()),
             field_name,
-            data: extra.data.map(Into::into),
+            data: extra.data.as_ref().map(|data| data.clone().into()),
             mode: extra.input_type,
         }
     }
@@ -498,16 +530,16 @@ impl ValidationInfo {
 impl ValidationInfo {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let context = match self.context {
-            Some(ref context) => safe_repr(context.as_ref(py)),
+            Some(ref context) => safe_repr(context.bind(py)).to_string(),
             None => "None".into(),
         };
-        let config = self.config.as_ref(py).repr()?;
+        let config = self.config.bind(py).repr()?;
         let data = match self.data {
-            Some(ref data) => safe_repr(data.as_ref(py)),
+            Some(ref data) => safe_repr(data.bind(py)).to_string(),
             None => "None".into(),
         };
         let field_name = match self.field_name {
-            Some(ref field_name) => safe_repr(field_name.as_ref(py)),
+            Some(ref field_name) => safe_repr(field_name.bind(py)).to_string(),
             None => "None".into(),
         };
         Ok(format!(
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index a366da431..1be9fcc8a 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -5,7 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
-use crate::input::{GenericIterator, Input};
+use crate::input::{BorrowInput, GenericIterator, Input};
 use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
@@ -29,8 +29,8 @@ impl BuildValidator for GeneratorValidator {
     const EXPECTED_TYPE: &'static str = "generator";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let item_validator = get_items_schema(schema, config, definitions)?.map(Arc::new);
@@ -145,7 +145,9 @@ impl ValidatorIterator {
                                     ));
                                 }
                             }
-                            validator.validate(py, next, Some(index.into())).map(Some)
+                            validator
+                                .validate(py, next.borrow_input(), Some(index.into()))
+                                .map(Some)
                         }
                         None => Ok(Some(next.to_object(py))),
                     },
@@ -238,7 +240,7 @@ impl InternalValidator {
         Self {
             name: name.to_string(),
             validator,
-            data: extra.data.map(|d| d.into_py(py)),
+            data: extra.data.as_ref().map(|d| d.clone().into()),
             strict: extra.strict,
             from_attributes: extra.from_attributes,
             context: extra.context.map(|d| d.into_py(py)),
@@ -254,18 +256,18 @@ impl InternalValidator {
     pub fn validate_assignment<'data>(
         &mut self,
         py: Python<'data>,
-        model: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        model: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: self.validation_mode,
-            data: self.data.as_ref().map(|data| data.as_ref(py)),
+            data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
-            context: self.context.as_ref().map(|data| data.as_ref(py)),
-            self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
+            context: self.context.as_ref().map(|data| data.bind(py)),
+            self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
@@ -295,11 +297,11 @@ impl InternalValidator {
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: self.validation_mode,
-            data: self.data.as_ref().map(|data| data.as_ref(py)),
+            data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
-            context: self.context.as_ref().map(|data| data.as_ref(py)),
-            self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
+            context: self.context.as_ref().map(|data| data.bind(py)),
+            self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
diff --git a/src/validators/int.rs b/src/validators/int.rs
index a72afcb0e..5bb19fefb 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -19,8 +19,8 @@ impl BuildValidator for IntValidator {
     const EXPECTED_TYPE: &'static str = "int";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -145,7 +145,7 @@ impl Validator for ConstrainedIntValidator {
 }
 
 impl ConstrainedIntValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 8355710d9..9f0fc1a13 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -21,25 +21,24 @@ impl BuildValidator for IsInstanceValidator {
     const EXPECTED_TYPE: &'static str = "is-instance";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let cls_key = intern!(py, "cls");
-        let class: &PyAny = schema.get_as_req(cls_key)?;
+        let class = schema.get_as_req(cls_key)?;
 
         // test that class works with isinstance to avoid errors at call time, reuse cls_key since it doesn't
         // matter what object is being checked
-        let test_value: &PyAny = cls_key.as_ref();
-        if test_value.is_instance(class).is_err() {
+        if cls_key.is_instance(&class).is_err() {
             return py_schema_err!("'cls' must be valid as the first argument to 'isinstance'");
         }
 
         let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
             Some(s) => s,
             None => match class.extract::<&PyType>() {
-                Ok(t) => t.name()?.to_string(),
+                Ok(t) => t.qualname()?.to_string(),
                 Err(_) => class.repr()?.extract()?,
             },
         };
@@ -69,8 +68,8 @@ impl Validator for IsInstanceValidator {
             )));
         }
 
-        let ob = input.to_object(py);
-        match ob.as_ref(py).is_instance(self.class.as_ref(py))? {
+        let ob: Py<PyAny> = input.to_object(py);
+        match ob.bind(py).is_instance(self.class.bind(py))? {
             true => Ok(ob),
             false => Err(ValError::new(
                 ErrorType::IsInstanceOf {
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index e20a5c291..d7fbd238f 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -19,8 +19,8 @@ impl BuildValidator for IsSubclassValidator {
     const EXPECTED_TYPE: &'static str = "is-subclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -28,7 +28,7 @@ impl BuildValidator for IsSubclassValidator {
 
         let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
             Some(s) => s,
-            None => class.name()?.to_string(),
+            None => class.qualname()?.to_string(),
         };
         let name = format!("{}[{class_repr}]", Self::EXPECTED_TYPE);
         Ok(Self {
@@ -49,7 +49,7 @@ impl Validator for IsSubclassValidator {
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        match input.input_is_subclass(self.class.as_ref(py))? {
+        match input.input_is_subclass(self.class.bind(py))? {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(
                 ErrorType::IsSubclassOf {
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 641892364..4543a41d0 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -20,13 +20,13 @@ impl BuildValidator for JsonValidator {
     const EXPECTED_TYPE: &'static str = "json";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let validator = match schema.get_as(intern!(schema.py(), "schema"))? {
             Some(schema) => {
-                let validator = build_validator(schema, config, definitions)?;
+                let validator = build_validator(&schema, config, definitions)?;
                 match validator {
                     CombinedValidator::Any(_) => None,
                     _ => Some(Box::new(validator)),
@@ -66,7 +66,7 @@ impl Validator for JsonValidator {
             None => {
                 let obj =
                     jiter::python_parse(py, json_bytes, true, true).map_err(|e| map_json_err(input, e, json_bytes))?;
-                Ok(obj)
+                Ok(obj.unbind())
             }
         }
     }
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index 7cdb10adf..ddbc53900 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -20,16 +20,16 @@ impl BuildValidator for JsonOrPython {
     const EXPECTED_TYPE: &'static str = "json-or-python";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let json_schema: &PyDict = schema.get_as_req(intern!(py, "json_schema"))?;
-        let python_schema: &PyDict = schema.get_as_req(intern!(py, "python_schema"))?;
+        let json_schema = schema.get_as_req(intern!(py, "json_schema"))?;
+        let python_schema = schema.get_as_req(intern!(py, "python_schema"))?;
 
-        let json = build_validator(json_schema, config, definitions)?;
-        let python = build_validator(python_schema, config, definitions)?;
+        let json = build_validator(&json_schema, config, definitions)?;
+        let python = build_validator(&python_schema, config, definitions)?;
 
         let name = format!(
             "{}[json={},python={}]",
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index c130cc83a..654e38ed8 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -23,16 +23,16 @@ impl BuildValidator for LaxOrStrictValidator {
     const EXPECTED_TYPE: &'static str = "lax-or-strict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let lax_schema = schema.get_as_req(intern!(py, "lax_schema"))?;
-        let lax_validator = Box::new(build_validator(lax_schema, config, definitions)?);
+        let lax_validator = Box::new(build_validator(&lax_schema, config, definitions)?);
 
         let strict_schema = schema.get_as_req(intern!(py, "strict_schema"))?;
-        let strict_validator = Box::new(build_validator(strict_schema, config, definitions)?);
+        let strict_validator = Box::new(build_validator(&strict_schema, config, definitions)?);
 
         let name = format!(
             "{}[lax={},strict={}]",
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 1a8ecb134..a0ab11c29 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -20,13 +20,13 @@ pub struct ListValidator {
 }
 
 pub fn get_items_schema(
-    schema: &PyDict,
-    config: Option<&PyDict>,
+    schema: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<Option<CombinedValidator>> {
     match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
         Some(d) => {
-            let validator = build_validator(d, config, definitions)?;
+            let validator = build_validator(&d, config, definitions)?;
             match validator {
                 CombinedValidator::Any(_) => Ok(None),
                 _ => Ok(Some(validator)),
@@ -96,8 +96,8 @@ impl BuildValidator for ListValidator {
     const EXPECTED_TYPE: &'static str = "list";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 9f8c25e0f..35d37ef17 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -36,14 +36,14 @@ pub struct LiteralLookup<T: Debug> {
 }
 
 impl<T: Debug> LiteralLookup<T> {
-    pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (&'py PyAny, T)>) -> PyResult<Self> {
+    pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (Bound<'py, PyAny>, T)>) -> PyResult<Self> {
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
         let mut expected_bool = BoolLiteral {
             true_id: None,
             false_id: None,
         };
-        let expected_py = PyDict::new(py);
+        let expected_py = PyDict::new_bound(py);
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
@@ -66,7 +66,7 @@ impl<T: Debug> LiteralLookup<T> {
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
                 expected_str.insert(str.to_string(), id);
             } else {
-                expected_py.set_item(k, id)?;
+                expected_py.set_item(&k, id)?;
             }
         }
 
@@ -139,7 +139,7 @@ impl<T: Debug> LiteralLookup<T> {
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py.as_ref(py).get_item(input) {
+            if let Ok(Some(v)) = expected_py.bind(py).get_item(input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
@@ -167,21 +167,21 @@ impl BuildValidator for LiteralValidator {
     const EXPECTED_TYPE: &'static str = "literal";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let expected: &PyList = schema.get_as_req(intern!(schema.py(), "expected"))?;
+        let expected: Bound<PyList> = schema.get_as_req(intern!(schema.py(), "expected"))?;
         if expected.is_empty() {
             return py_schema_err!("`expected` should have length > 0");
         }
         let py = expected.py();
         let mut repr_args: Vec<String> = Vec::new();
-        for item in expected {
+        for item in expected.iter() {
             repr_args.push(item.repr()?.extract()?);
         }
         let (expected_repr, name) = expected_repr_name(repr_args, "literal");
-        let lookup = LiteralLookup::new(py, expected.iter().map(|v| (v, v.to_object(py))))?;
+        let lookup = LiteralLookup::new(py, expected.into_iter().map(|v| (v.clone(), v.into())))?;
         Ok(CombinedValidator::Literal(Self {
             lookup,
             expected_repr,
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 496da5c73..d7eb496ef 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -3,9 +3,9 @@ use std::fmt::Debug;
 use enum_dispatch::enum_dispatch;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict, PyTuple, PyType};
+use pyo3::sync::GILOnceCell;
+use pyo3::types::{PyAny, PyDict, PyString, PyTuple, PyType};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type, SchemaError};
@@ -76,7 +76,7 @@ impl PySome {
 #[pymethods]
 impl PySome {
     pub fn __repr__(&self, py: Python) -> PyResult<String> {
-        Ok(format!("Some({})", self.value.as_ref(py).repr()?,))
+        Ok(format!("Some({})", self.value.bind(py).repr()?,))
     }
 
     #[new]
@@ -86,13 +86,13 @@ impl PySome {
 
     #[classmethod]
     #[pyo3(signature = (_item, /))]
-    pub fn __class_getitem__(cls: &PyType, _item: &PyAny) -> Py<PyType> {
-        cls.into_py(cls.py())
+    pub fn __class_getitem__(cls: Py<PyType>, _item: &Bound<'_, PyAny>) -> Py<PyType> {
+        cls
     }
 
     #[classattr]
-    fn __match_args__(py: Python) -> &PyTuple {
-        PyTuple::new(py, vec![intern!(py, "value")])
+    fn __match_args__(py: Python) -> Bound<'_, PyTuple> {
+        PyTuple::new_bound(py, vec![intern!(py, "value")])
     }
 }
 
@@ -114,14 +114,14 @@ pub struct SchemaValidator {
 #[pymethods]
 impl SchemaValidator {
     #[new]
-    pub fn py_new(py: Python, schema: &PyAny, config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(py: Python, schema: &Bound<'_, PyAny>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
         let validator = build_validator(schema, config, &mut definitions_builder)?;
         let definitions = definitions_builder.finish()?;
         let py_schema = schema.into_py(py);
         let py_config = match config {
-            Some(c) if !c.is_empty() => Some(c.into_py(py)),
+            Some(c) if !c.is_empty() => Some(c.clone().into()),
             _ => None,
         };
         let config_title = match config {
@@ -145,7 +145,7 @@ impl SchemaValidator {
         })
     }
 
-    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
         // Enables support for `pickle` serialization.
         let py = slf.py();
         let cls = slf.get_type().into();
@@ -157,11 +157,11 @@ impl SchemaValidator {
     pub fn validate_python(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         self._validate(
             py,
@@ -179,11 +179,11 @@ impl SchemaValidator {
     pub fn isinstance_python(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<bool> {
         match self._validate(
             py,
@@ -206,10 +206,10 @@ impl SchemaValidator {
     pub fn validate_json(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
             Ok(v_match) => self._validate_json(
@@ -229,12 +229,12 @@ impl SchemaValidator {
     pub fn validate_strings(
         &self,
         py: Python,
-        input: &PyAny,
+        input: Bound<'_, PyAny>,
         strict: Option<bool>,
-        context: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
-        let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
+        let string_mapping = StringMapping::new_value(&input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
         match self._validate(py, &string_mapping, t, strict, None, context, None) {
             Ok(r) => Ok(r),
@@ -247,12 +247,12 @@ impl SchemaValidator {
     pub fn validate_assignment(
         &self,
         py: Python,
-        obj: &PyAny,
+        obj: Bound<'_, PyAny>,
         field_name: &str,
-        field_value: &PyAny,
+        field_value: Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: InputType::Python,
@@ -266,12 +266,17 @@ impl SchemaValidator {
         let guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, guard);
         self.validator
-            .validate_assignment(py, obj, field_name, field_value, &mut state)
+            .validate_assignment(py, &obj, field_name, &field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
     #[pyo3(signature = (*, strict=None, context=None))]
-    pub fn get_default_value(&self, py: Python, strict: Option<bool>, context: Option<&PyAny>) -> PyResult<PyObject> {
+    pub fn get_default_value(
+        &self,
+        py: Python,
+        strict: Option<bool>,
+        context: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: InputType::Python,
             data: None,
@@ -320,8 +325,8 @@ impl SchemaValidator {
         input_type: InputType,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&'data PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'data, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> ValResult<PyObject>
     where
         's: 'data,
@@ -337,11 +342,11 @@ impl SchemaValidator {
     fn _validate_json(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         json_data: &[u8],
         strict: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> ValResult<PyObject> {
         let json_value =
             jiter::JsonValue::parse(json_data, true).map_err(|e| json::map_json_err(input, e, json_data))?;
@@ -377,27 +382,28 @@ impl<'py> SelfValidator<'py> {
         Ok(Self { validator })
     }
 
-    pub fn validate_schema(&self, py: Python<'py>, schema: &'py PyAny, strict: Option<bool>) -> PyResult<&'py PyAny> {
+    pub fn validate_schema(&self, schema: &Bound<'py, PyAny>, strict: Option<bool>) -> PyResult<Bound<'py, PyAny>> {
+        let py = schema.py();
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python),
             &mut recursion_guard,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
-            Ok(schema_obj) => Ok(schema_obj.into_ref(py)),
+            Ok(schema_obj) => Ok(schema_obj.into_bound(py)),
             Err(e) => Err(SchemaError::from_val_error(py, e)),
         }
     }
 
     fn build(py: Python) -> PyResult<SchemaValidator> {
         let code = include_str!("../self_schema.py");
-        let locals = PyDict::new(py);
-        py.run(code, None, Some(locals))?;
-        let self_schema: &PyDict = locals.get_as_req(intern!(py, "self_schema"))?;
+        let locals = PyDict::new_bound(py);
+        py.run_bound(code, None, Some(&locals))?;
+        let self_schema = locals.get_as_req(intern!(py, "self_schema"))?;
 
         let mut definitions_builder = DefinitionsBuilder::new();
 
-        let validator = match build_validator(self_schema, None, &mut definitions_builder) {
+        let validator = match build_validator(&self_schema, None, &mut definitions_builder) {
             Ok(v) => v,
             Err(err) => return py_schema_err!("Error building self-schema:\n  {}", err),
         };
@@ -415,9 +421,9 @@ impl<'py> SelfValidator<'py> {
 }
 
 #[pyfunction(signature = (schema, *, strict = None))]
-pub fn validate_core_schema<'a>(py: Python<'a>, schema: &'a PyAny, strict: Option<bool>) -> PyResult<&'a PyAny> {
-    let self_validator = SelfValidator::new(py)?;
-    self_validator.validate_schema(py, schema, strict)
+pub fn validate_core_schema<'py>(schema: &Bound<'py, PyAny>, strict: Option<bool>) -> PyResult<Bound<'py, PyAny>> {
+    let self_validator = SelfValidator::new(schema.py())?;
+    self_validator.validate_schema(schema, strict)
 }
 
 pub trait BuildValidator: Sized {
@@ -426,17 +432,17 @@ pub trait BuildValidator: Sized {
     /// Build a new validator from the schema, the return type is a trait to provide a way for validators
     /// to return other validators, see `string.rs`, `int.rs`, `float.rs` and `function.rs` for examples
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator>;
 }
 
 /// Logic to create a particular validator, called in the `validator_match` macro, then in turn by `build_validator`
-fn build_specific_validator<'a, T: BuildValidator>(
+fn build_specific_validator<T: BuildValidator>(
     val_type: &str,
-    schema_dict: &'a PyDict,
-    config: Option<&'a PyDict>,
+    schema_dict: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
     T::build(schema_dict, config, definitions)
@@ -455,13 +461,14 @@ macro_rules! validator_match {
     };
 }
 
-pub fn build_validator<'a>(
-    schema: &'a PyAny,
-    config: Option<&'a PyDict>,
+pub fn build_validator(
+    schema: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
-    let dict: &PyDict = schema.downcast()?;
-    let type_: &str = dict.get_as_req(intern!(schema.py(), "type"))?;
+    let dict = schema.downcast::<PyDict>()?;
+    let type_: Bound<'_, PyString> = dict.get_as_req(intern!(schema.py(), "type"))?;
+    let type_ = type_.to_str()?;
     validator_match!(
         type_,
         dict,
@@ -561,23 +568,23 @@ pub struct Extra<'a> {
     /// Validation mode
     pub input_type: InputType,
     /// This is used as the `data` kwargs to validator functions
-    pub data: Option<&'a PyDict>,
+    pub data: Option<Bound<'a, PyDict>>,
     /// whether we're in strict or lax mode
     pub strict: Option<bool>,
     /// Validation time setting of `from_attributes`
     pub from_attributes: Option<bool>,
     /// context used in validator functions
-    pub context: Option<&'a PyAny>,
+    pub context: Option<&'a Bound<'a, PyAny>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
-    self_instance: Option<&'a PyAny>,
+    self_instance: Option<&'a Bound<'a, PyAny>>,
 }
 
 impl<'a> Extra<'a> {
     pub fn new(
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&'a PyAny>,
-        self_instance: Option<&'a PyAny>,
+        context: Option<&'a Bound<'a, PyAny>>,
+        self_instance: Option<&'a Bound<'a, PyAny>>,
         input_type: InputType,
     ) -> Self {
         Extra {
@@ -595,7 +602,7 @@ impl<'a> Extra<'a> {
     pub fn as_strict(&self) -> Self {
         Self {
             input_type: self.input_type,
-            data: self.data,
+            data: self.data.clone(),
             strict: Some(true),
             from_attributes: self.from_attributes,
             context: self.context,
@@ -723,9 +730,9 @@ pub trait Validator: Send + Sync + Debug {
     fn validate_assignment<'data>(
         &self,
         _py: Python<'data>,
-        _obj: &'data PyAny,
-        _field_name: &'data str,
-        _field_value: &'data PyAny,
+        _obj: &Bound<'data, PyAny>,
+        _field_name: &str,
+        _field_value: &Bound<'data, PyAny>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let py_err = PyTypeError::new_err(format!("validate_assignment is not supported for {}", self.get_name()));
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 0cc39b6a3..abe649e2c 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -1,10 +1,9 @@
 use std::ptr::null_mut;
 
-use pyo3::conversion::AsPyPointer;
 use pyo3::exceptions::PyTypeError;
-use pyo3::prelude::*;
+use pyo3::ffi;
 use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
-use pyo3::{ffi, intern};
+use pyo3::{intern, prelude::*};
 
 use super::function::convert_err;
 use super::validation_state::Exactness;
@@ -42,11 +41,11 @@ impl Revalidate {
         }
     }
 
-    pub fn should_revalidate(&self, input: &PyAny, class: &PyType) -> bool {
+    pub fn should_revalidate(&self, input: &Bound<'_, PyAny>, class: &Bound<'_, PyType>) -> bool {
         match self {
             Revalidate::Always => true,
             Revalidate::Never => false,
-            Revalidate::SubclassInstances => !input.get_type().is(class),
+            Revalidate::SubclassInstances => !input.is_exact_instance(class),
         }
     }
 }
@@ -68,36 +67,39 @@ impl BuildValidator for ModelValidator {
     const EXPECTED_TYPE: &'static str = "model";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         // models ignore the parent config and always use the config from this model
         let config = schema.get_as(intern!(py, "config"))?;
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        let validator = build_validator(sub_schema, config, definitions)?;
+        let class: Bound<'_, PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let validator = build_validator(&sub_schema, config.as_ref(), definitions)?;
+        let name = class.getattr(intern!(py, "__name__"))?.extract()?;
 
         Ok(Self {
-            revalidate: Revalidate::from_str(schema_or_config_same(
-                schema,
-                config,
-                intern!(py, "revalidate_instances"),
-            )?)?,
+            revalidate: Revalidate::from_str(
+                schema_or_config_same::<Bound<'_, PyString>>(
+                    schema,
+                    config.as_ref(),
+                    intern!(py, "revalidate_instances"),
+                )?
+                .as_ref()
+                .map(|s| s.to_str())
+                .transpose()?,
+            )?,
             validator: Box::new(validator),
             class: class.into(),
-            post_init: schema
-                .get_as::<&str>(intern!(py, "post_init"))?
-                .map(|s| PyString::new(py, s).into_py(py)),
+            post_init: schema.get_as(intern!(py, "post_init"))?,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
             root_model: schema.get_as(intern!(py, "root_model"))?.unwrap_or(false),
             undefined: PydanticUndefinedType::new(py).to_object(py),
-            // Get the class's `__name__`, not using `class.name()` since it uses `__qualname__`
-            // which is not what we want here
-            name: class.getattr(intern!(py, "__name__"))?.extract()?,
+            // Get the class's `__name__`, not using `class.qualname()`
+            name,
         }
         .into())
     }
@@ -121,26 +123,26 @@ impl Validator for ModelValidator {
         // if we're not in strict mode, instances subclasses are okay, as well as dicts, mappings, from attributes etc.
         // if the input is an instance of the class, we "revalidate" it - e.g. we extract and reuse `__pydantic_fields_set__`
         // but use from attributes to create a new instance of the model field type
-        let class = self.class.as_ref(py);
+        let class = self.class.bind(py);
         if let Some(py_input) = input.input_is_instance(class) {
             if self.revalidate.should_revalidate(py_input, class) {
                 let fields_set = py_input.getattr(intern!(py, DUNDER_FIELDS_SET_KEY))?;
                 if self.root_model {
                     let inner_input = py_input.getattr(intern!(py, ROOT_FIELD))?;
-                    self.validate_construct(py, inner_input, Some(fields_set), state)
+                    self.validate_construct(py, &inner_input, Some(&fields_set), state)
                 } else {
                     // get dict here so from_attributes logic doesn't apply
                     let dict = py_input.getattr(intern!(py, DUNDER_DICT))?;
                     let model_extra = py_input.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?;
 
-                    let inner_input: &PyAny = if model_extra.is_none() {
+                    let inner_input = if PyAnyMethods::is_none(&model_extra) {
                         dict
                     } else {
                         let full_model_dict = dict.downcast::<PyDict>()?.copy()?;
                         full_model_dict.update(model_extra.downcast()?)?;
-                        full_model_dict
+                        full_model_dict.into_any()
                     };
-                    self.validate_construct(py, inner_input, Some(fields_set), state)
+                    self.validate_construct(py, &inner_input, Some(&fields_set), state)
                 }
             } else {
                 Ok(input.to_object(py))
@@ -155,9 +157,9 @@ impl Validator for ModelValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        model: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        model: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.frozen {
@@ -179,23 +181,22 @@ impl Validator for ModelValidator {
                 Ok(model.into_py(py))
             };
         }
-        let old_dict: &PyDict = model.getattr(intern!(py, DUNDER_DICT))?.downcast()?;
+        let old_dict = model.getattr(intern!(py, DUNDER_DICT))?.downcast_into::<PyDict>()?;
 
         let input_dict = old_dict.copy()?;
-        let old_extra: Option<&PyDict> = model.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?.downcast().ok();
-        if let Some(old_extra) = old_extra {
+        if let Ok(old_extra) = model.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?.downcast::<PyDict>() {
             input_dict.update(old_extra.as_mapping())?;
         }
         input_dict.set_item(field_name, field_value)?;
 
         let output = self
             .validator
-            .validate_assignment(py, input_dict, field_name, field_value, state)?;
+            .validate_assignment(py, input_dict.as_any(), field_name, field_value, state)?;
 
         let (validated_dict, validated_extra, validated_fields_set): (&PyDict, &PyAny, &PySet) = output.extract(py)?;
 
         if let Ok(fields_set) = model.getattr(intern!(py, DUNDER_FIELDS_SET_KEY)) {
-            let fields_set: &PySet = fields_set.downcast()?;
+            let fields_set = fields_set.downcast::<PySet>()?;
             for field_name in validated_fields_set {
                 fields_set.add(field_name)?;
             }
@@ -221,7 +222,7 @@ impl ModelValidator {
     fn validate_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        self_instance: &'s PyAny,
+        self_instance: &Bound<'s, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
@@ -232,24 +233,24 @@ impl ModelValidator {
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty(py)?
+                PySet::empty_bound(py)?
             } else {
-                PySet::new(py, [&String::from(ROOT_FIELD)])?
+                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
             force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
-            force_setattr(py, self_instance, intern!(py, ROOT_FIELD), output.as_ref(py))?;
+            force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
         } else {
-            let (model_dict, model_extra, fields_set): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
-            set_model_attrs(self_instance, model_dict, model_extra, fields_set)?;
+            let (model_dict, model_extra, fields_set) = output.extract(py)?;
+            set_model_attrs(self_instance, &model_dict, &model_extra, &fields_set)?;
         }
-        self.call_post_init(py, self_instance.into_py(py), input, state.extra())
+        self.call_post_init(py, self_instance.clone(), input, state.extra())
     }
 
     fn validate_construct<'s, 'data>(
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        existing_fields_set: Option<&'data PyAny>,
+        existing_fields_set: Option<&Bound<'_, PyAny>>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.custom_init {
@@ -261,28 +262,27 @@ impl ModelValidator {
             if let Some(kwargs) = input.as_kwargs(py) {
                 return self
                     .class
-                    .call(py, (), Some(kwargs))
+                    .call_bound(py, (), Some(&kwargs))
                     .map_err(|e| convert_err(py, e, input));
             }
         }
 
         let output = self.validator.validate(py, input, state)?;
 
-        let instance = create_class(self.class.as_ref(py))?;
-        let instance_ref = instance.as_ref(py);
+        let instance = create_class(self.class.bind(py))?;
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty(py)?
+                PySet::empty_bound(py)?
             } else {
-                PySet::new(py, [&String::from(ROOT_FIELD)])?
+                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
-            force_setattr(py, instance_ref, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
-            force_setattr(py, instance_ref, intern!(py, ROOT_FIELD), output)?;
+            force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
+            force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
         } else {
-            let (model_dict, model_extra, val_fields_set): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
-            let fields_set = existing_fields_set.unwrap_or(val_fields_set);
-            set_model_attrs(instance_ref, model_dict, model_extra, fields_set)?;
+            let (model_dict, model_extra, val_fields_set) = output.extract(py)?;
+            let fields_set = existing_fields_set.unwrap_or(&val_fields_set);
+            set_model_attrs(&instance, &model_dict, &model_extra, fields_set)?;
         }
         self.call_post_init(py, instance, input, state.extra())
     }
@@ -290,30 +290,30 @@ impl ModelValidator {
     fn call_post_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        instance: PyObject,
+        instance: Bound<'_, PyAny>,
         input: &'data impl Input<'data>,
         extra: &Extra,
     ) -> ValResult<PyObject> {
         if let Some(ref post_init) = self.post_init {
             instance
-                .call_method1(py, post_init.as_ref(py), (extra.context,))
+                .call_method1(post_init.bind(py), (extra.context,))
                 .map_err(|e| convert_err(py, e, input))?;
         }
-        Ok(instance)
+        Ok(instance.into())
     }
 }
 
 /// based on the following but with the second argument of new_func set to an empty tuple as required
 /// https://github.com/PyO3/pyo3/blob/d2caa056e9aacc46374139ef491d112cb8af1a25/src/pyclass_init.rs#L35-L77
-pub(super) fn create_class(class: &PyType) -> PyResult<PyObject> {
+pub(super) fn create_class<'py>(class: &Bound<'py, PyType>) -> PyResult<Bound<'py, PyAny>> {
     let py = class.py();
-    let args = PyTuple::empty(py);
+    let args = PyTuple::empty_bound(py);
     let raw_type = class.as_type_ptr();
     unsafe {
         // Safety: raw_type is known to be a non-null type object pointer
         match (*raw_type).tp_new {
             // Safety: the result of new_func is guaranteed to be either an owned pointer or null on error returns.
-            Some(new_func) => PyObject::from_owned_ptr_or_err(
+            Some(new_func) => Bound::from_owned_ptr_or_err(
                 py,
                 // Safety: the non-null pointers are known to be valid, and it's allowed to call tp_new with a
                 // null kwargs dict.
@@ -324,7 +324,12 @@ pub(super) fn create_class(class: &PyType) -> PyResult<PyObject> {
     }
 }
 
-fn set_model_attrs(instance: &PyAny, model_dict: &PyAny, model_extra: &PyAny, fields_set: &PyAny) -> PyResult<()> {
+fn set_model_attrs(
+    instance: &Bound<'_, PyAny>,
+    model_dict: &Bound<'_, PyAny>,
+    model_extra: &Bound<'_, PyAny>,
+    fields_set: &Bound<'_, PyAny>,
+) -> PyResult<()> {
     let py = instance.py();
     force_setattr(py, instance, intern!(py, DUNDER_DICT), model_dict)?;
     force_setattr(py, instance, intern!(py, DUNDER_MODEL_EXTRA_KEY), model_extra)?;
@@ -333,7 +338,7 @@ fn set_model_attrs(instance: &PyAny, model_dict: &PyAny, model_extra: &PyAny, fi
     Ok(())
 }
 
-pub(super) fn force_setattr<N, V>(py: Python<'_>, obj: &PyAny, attr_name: N, value: V) -> PyResult<()>
+pub(super) fn force_setattr<N, V>(py: Python<'_>, obj: &Bound<'_, PyAny>, attr_name: N, value: V) -> PyResult<()>
 where
     N: ToPyObject,
     V: ToPyObject,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 192d1ba8f..cbdacd1d7 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -47,8 +47,8 @@ impl BuildValidator for ModelFieldsValidator {
     const EXPECTED_TYPE: &'static str = "model-fields";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -60,7 +60,7 @@ impl BuildValidator for ModelFieldsValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
@@ -68,16 +68,17 @@ impl BuildValidator for ModelFieldsValidator {
             .get_as(intern!(py, "model_name"))?
             .unwrap_or_else(|| "Model".to_string());
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<Field> = Vec::with_capacity(fields_dict.len());
 
         for (key, value) in fields_dict {
-            let field_info: &PyDict = value.downcast()?;
-            let field_name: &str = key.extract()?;
+            let field_info = value.downcast::<PyDict>()?;
+            let field_name_py: Bound<'_, PyString> = key.extract()?;
+            let field_name = field_name_py.to_str()?;
 
             let schema = field_info.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
@@ -85,7 +86,7 @@ impl BuildValidator for ModelFieldsValidator {
             let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, field_name),
             };
@@ -93,7 +94,7 @@ impl BuildValidator for ModelFieldsValidator {
             fields.push(Field {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::new(py, field_name).into(),
+                name_py: field_name_py.into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
             });
@@ -150,8 +151,8 @@ impl Validator for ModelFieldsValidator {
             Err(err) => return Err(err),
         };
 
-        let model_dict = PyDict::new(py);
-        let mut model_extra_dict_op: Option<&PyDict> = None;
+        let model_dict = PyDict::new_bound(py);
+        let mut model_extra_dict_op: Option<Bound<PyDict>> = None;
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
 
@@ -173,9 +174,9 @@ impl Validator for ModelFieldsValidator {
         }
 
         macro_rules! process {
-            ($dict:ident, $get_method:ident, $iter:ty $(,$kwargs:ident)?) => {{
+            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
                 match state.with_new_extra(Extra {
-                    data: Some(model_dict),
+                    data: Some(model_dict.clone()),
                     ..*state.extra()
                 }, |state| {
                     for field in &self.fields {
@@ -248,7 +249,7 @@ impl Validator for ModelFieldsValidator {
                 }
 
                 if let Some(ref mut used_keys) = used_keys {
-                    let model_extra_dict = PyDict::new(py);
+                    let model_extra_dict = PyDict::new_bound(py);
                     for item_result in <$iter>::new($dict)? {
                         let (raw_key, value) = item_result?;
                         let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
@@ -278,7 +279,7 @@ impl Validator for ModelFieldsValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key,
+                                        raw_key.clone(),
                                     )
 
                                 );
@@ -289,8 +290,8 @@ impl Validator for ModelFieldsValidator {
                                 if let Some(ref validator) = self.extras_validator {
                                     match validator.validate(py, value, state) {
                                         Ok(value) => {
-                                            model_extra_dict.set_item(py_key, value)?;
-                                            fields_set_vec.push(py_key.into_py(py));
+                                            model_extra_dict.set_item(&py_key, value)?;
+                                            fields_set_vec.push(py_key.into());
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
@@ -300,8 +301,8 @@ impl Validator for ModelFieldsValidator {
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    model_extra_dict.set_item(py_key, value.to_object(py))?;
-                                    fields_set_vec.push(py_key.into_py(py));
+                                    model_extra_dict.set_item(&py_key, value.to_object(py))?;
+                                    fields_set_vec.push(py_key.into());
                                 };
                             }
                         }
@@ -313,22 +314,26 @@ impl Validator for ModelFieldsValidator {
             }};
         }
         match dict {
-            GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
+            GenericMapping::PyDict(d) => {
+                process!(&d, py_get_dict_item, DictGenericIterator);
+            }
+            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => {
+                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
+            }
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            let fields_set = PySet::new(py, &fields_set_vec)?;
+            let fields_set = PySet::new_bound(py, &fields_set_vec)?;
 
             // if we have extra=allow, but we didn't create a dict because we were validating
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
             if matches!(self.extra_behavior, ExtraBehavior::Allow) && model_extra_dict_op.is_none() {
-                model_extra_dict_op = Some(PyDict::new(py));
+                model_extra_dict_op = Some(PyDict::new_bound(py));
             };
 
             Ok((model_dict, model_extra_dict_op, fields_set).to_object(py))
@@ -338,12 +343,12 @@ impl Validator for ModelFieldsValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let dict: &PyDict = obj.downcast()?;
+        let dict = obj.downcast::<PyDict>()?;
 
         let get_updated_dict = |output: PyObject| {
             dict.set_item(field_name, output)?;
@@ -366,7 +371,7 @@ impl Validator for ModelFieldsValidator {
         let data_dict = dict.copy()?;
         if let Err(err) = data_dict.del_item(field_name) {
             // KeyError is fine here as the field might not be in the dict
-            if !err.get_type(py).is(PyType::new::<PyKeyError>(py)) {
+            if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
                 return Err(err.into());
             }
         }
@@ -416,9 +421,9 @@ impl Validator for ModelFieldsValidator {
 
         let new_extra = match &self.extra_behavior {
             ExtraBehavior::Allow => {
-                let non_extra_data = PyDict::new(py);
+                let non_extra_data = PyDict::new_bound(py);
                 self.fields.iter().for_each(|f| {
-                    let popped_value = PyAny::get_item(new_data, &f.name).unwrap();
+                    let popped_value = PyAnyMethods::get_item(&**new_data, &f.name).unwrap();
                     new_data.del_item(&f.name).unwrap();
                     non_extra_data.set_item(&f.name, popped_value).unwrap();
                 });
@@ -430,7 +435,7 @@ impl Validator for ModelFieldsValidator {
             _ => py.None(),
         };
 
-        let fields_set: &PySet = PySet::new(py, &[field_name.to_string()])?;
+        let fields_set = PySet::new_bound(py, &[field_name.to_string()])?;
         Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
     }
 
diff --git a/src/validators/none.rs b/src/validators/none.rs
index c014c1218..36f19c2bd 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -13,8 +13,8 @@ impl BuildValidator for NoneValidator {
     const EXPECTED_TYPE: &'static str = "none";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 7e5c68d03..872eb3d7f 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -19,12 +19,12 @@ impl BuildValidator for NullableValidator {
     const EXPECTED_TYPE: &'static str = "nullable";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(schema, config, definitions)?);
+        let schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&schema, config, definitions)?);
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, validator.get_name());
         Ok(Self { validator, name }.into())
     }
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 38f21a026..4854f6ba8 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -21,13 +21,13 @@ pub struct SetValidator {
 macro_rules! set_build {
     () => {
         fn build(
-            schema: &PyDict,
-            config: Option<&PyDict>,
+            schema: &Bound<'_, PyDict>,
+            config: Option<&Bound<'_, PyDict>>,
             definitions: &mut DefinitionsBuilder<CombinedValidator>,
         ) -> PyResult<CombinedValidator> {
             let py = schema.py();
             let item_validator = match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
-                Some(d) => Box::new(crate::validators::build_validator(d, config, definitions)?),
+                Some(d) => Box::new(crate::validators::build_validator(&d, config, definitions)?),
                 None => Box::new(crate::validators::any::AnyValidator::build(
                     schema,
                     config,
@@ -71,8 +71,8 @@ impl Validator for SetValidator {
             _ => Exactness::Lax,
         };
         state.floor_exactness(exactness);
-        let set = PySet::empty(py)?;
-        collection.validate_to_set(py, set, input, self.max_length, "Set", &self.item_validator, state)?;
+        let set = PySet::empty_bound(py)?;
+        collection.validate_to_set(py, &set, input, self.max_length, "Set", &self.item_validator, state)?;
         min_length_check!(input, "Set", self.min_length, set);
         Ok(set.into_py(py))
     }
diff --git a/src/validators/string.rs b/src/validators/string.rs
index a8d66a42e..0dffec9c2 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -20,8 +20,8 @@ impl BuildValidator for StrValidator {
     const EXPECTED_TYPE: &'static str = "str";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let con_str_validator = StrConstrainedValidator::build(schema, config)?;
@@ -129,11 +129,11 @@ impl Validator for StrConstrainedValidator {
         }
 
         let py_string = if self.to_lower {
-            PyString::new(py, &str.to_lowercase())
+            PyString::new_bound(py, &str.to_lowercase())
         } else if self.to_upper {
-            PyString::new(py, &str.to_uppercase())
+            PyString::new_bound(py, &str.to_uppercase())
         } else if self.strip_whitespace {
-            PyString::new(py, str)
+            PyString::new_bound(py, str)
         } else {
             // we haven't modified the string, return the original as it might be a PyString
             either_str.as_py_string(py)
@@ -147,15 +147,23 @@ impl Validator for StrConstrainedValidator {
 }
 
 impl StrConstrainedValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let py = schema.py();
 
         let pattern = schema
             .get_as(intern!(py, "pattern"))?
             .map(|s| {
-                let regex_engine =
-                    schema_or_config(schema, config, intern!(py, "regex_engine"), intern!(py, "regex_engine"))?
-                        .unwrap_or(RegexEngine::RUST_REGEX);
+                let regex_engine = schema_or_config::<Bound<'_, PyString>>(
+                    schema,
+                    config,
+                    intern!(py, "regex_engine"),
+                    intern!(py, "regex_engine"),
+                )?;
+                let regex_engine = regex_engine
+                    .as_ref()
+                    .map(|s| s.to_str())
+                    .transpose()?
+                    .unwrap_or(RegexEngine::RUST_REGEX);
                 Pattern::compile(py, s, regex_engine)
             })
             .transpose()?;
@@ -177,7 +185,9 @@ impl StrConstrainedValidator {
             schema_or_config(schema, config, intern!(py, "to_upper"), intern!(py, "str_to_upper"))?.unwrap_or(false);
 
         let coerce_numbers_to_str = match config {
-            Some(c) => c.get_item("coerce_numbers_to_str")?.map_or(Ok(false), PyAny::is_true)?,
+            Some(c) => c
+                .get_item("coerce_numbers_to_str")?
+                .map_or(Ok(false), |any| any.is_truthy())?,
             None => false,
         };
 
@@ -229,7 +239,7 @@ impl Pattern {
                 RegexEngine::RustRegex(Regex::new(&pattern).map_err(|e| py_schema_error_type!("{}", e))?)
             }
             RegexEngine::PYTHON_RE => {
-                let re_compile = py.import(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
+                let re_compile = py.import_bound(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
                 RegexEngine::PythonRe(re_compile.call1((&pattern,))?.into())
             }
             _ => return Err(py_schema_error_type!("Invalid regex engine: {}", engine)),
diff --git a/src/validators/time.rs b/src/validators/time.rs
index 687e01eaf..9aa68955d 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -1,6 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString, PyTime};
+use pyo3::types::{PyDict, PyString};
 
 use speedate::Time;
 
@@ -24,8 +24,8 @@ impl BuildValidator for TimeValidator {
     const EXPECTED_TYPE: &'static str = "time";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let s = Self {
@@ -85,8 +85,8 @@ impl Validator for TimeValidator {
     }
 }
 
-fn convert_pytime(schema: &PyDict, field: &PyString) -> PyResult<Option<Time>> {
-    match schema.get_as::<&PyTime>(field)? {
+fn convert_pytime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Time>> {
+    match schema.get_as(field)? {
         Some(date) => Ok(Some(EitherTime::Py(date).as_raw()?)),
         None => Ok(None),
     }
@@ -102,7 +102,7 @@ struct TimeConstraints {
 }
 
 impl TimeConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: convert_pytime(schema, intern!(py, "le"))?,
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 326a279e8..f516818ef 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -24,10 +24,10 @@ struct TimedeltaConstraints {
     gt: Option<Duration>,
 }
 
-fn get_constraint(schema: &PyDict, key: &str) -> PyResult<Option<Duration>> {
+fn get_constraint(schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Duration>> {
     match schema.get_item(key)? {
         Some(value) => {
-            let either_timedelta = EitherTimedelta::try_from(value)?;
+            let either_timedelta = EitherTimedelta::try_from(&value)?;
             Ok(Some(either_timedelta.to_duration()?))
         }
         None => Ok(None),
@@ -38,8 +38,8 @@ impl BuildValidator for TimeDeltaValidator {
     const EXPECTED_TYPE: &'static str = "timedelta";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let constraints = TimedeltaConstraints {
@@ -88,7 +88,7 @@ impl Validator for TimeDeltaValidator {
                                     $constraint: pydelta_to_human_readable(duration_as_pytimedelta(py, constraint)?)
                                         .into(),
                                 },
-                                py_timedelta.as_ref(),
+                                py_timedelta.as_any(),
                             ));
                         }
                     }
@@ -107,7 +107,7 @@ impl Validator for TimeDeltaValidator {
         Self::EXPECTED_TYPE
     }
 }
-fn pydelta_to_human_readable(py_delta: &PyDelta) -> String {
+fn pydelta_to_human_readable(py_delta: Bound<'_, PyDelta>) -> String {
     let total_seconds = py_delta.get_seconds();
     let hours = total_seconds / 3600;
     let minutes = (total_seconds % 3600) / 60;
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 6cad26073..d9311e4fe 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -5,6 +5,7 @@ use std::collections::VecDeque;
 
 use crate::build_tools::is_strict;
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::input::BorrowInput;
 use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
 use crate::validators::Exactness;
@@ -24,15 +25,15 @@ pub struct TupleValidator {
 impl BuildValidator for TupleValidator {
     const EXPECTED_TYPE: &'static str = "tuple";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
+        let items: Bound<'_, PyList> = schema.get_as_req(intern!(py, "items_schema"))?;
         let validators: Vec<CombinedValidator> = items
             .iter()
-            .map(|item| build_validator(item, config, definitions))
+            .map(|item| build_validator(&item, config, definitions))
             .collect::<PyResult<_>>()?;
 
         let mut validator_names = validators.iter().map(Validator::get_name).collect::<Vec<_>>();
@@ -59,7 +60,7 @@ impl_py_gc_traverse!(TupleValidator { validators });
 
 impl TupleValidator {
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_items<'s, 'data, I: Input<'data> + 'data>(
+    fn validate_tuple_items<'s, 'data, I: BorrowInput + 'data>(
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
@@ -67,13 +68,13 @@ impl TupleValidator {
         output: &mut Vec<PyObject>,
         errors: &mut Vec<ValLineError>,
         item_validators: &[CombinedValidator],
-        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
     ) -> ValResult<()> {
         // Validate the head:
         for validator in item_validators {
             match collection_iter.next() {
-                Some((index, input_item)) => match validator.validate(py, input_item, state) {
+                Some((index, input_item)) => match validator.validate(py, input_item.borrow_input(), state) {
                     Ok(item) => self.push_output_item(input, output, item, actual_length)?,
                     Err(ValError::LineErrors(line_errors)) => {
                         errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
@@ -96,13 +97,13 @@ impl TupleValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_variable<'data, I: Input<'data> + 'data, InputT: Input<'data> + 'data>(
+    fn validate_tuple_variable<'data, I: BorrowInput + 'data, InputT: Input<'data> + 'data>(
         &self,
         py: Python<'data>,
         input: &'data InputT,
         state: &mut ValidationState,
         errors: &mut Vec<ValLineError>,
-        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
     ) -> ValResult<Vec<PyObject>> {
         let expected_length = if self.variadic_item_index.is_some() {
@@ -133,7 +134,7 @@ impl TupleValidator {
             let n_tail_validators = tail_validators.len();
             if n_tail_validators == 0 {
                 for (index, input_item) in collection_iter {
-                    match variable_validator.validate(py, input_item, state) {
+                    match variable_validator.validate(py, input_item.borrow_input(), state) {
                         Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
                         Err(ValError::LineErrors(line_errors)) => {
                             errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
@@ -147,8 +148,7 @@ impl TupleValidator {
                 // NB: We take from collection_iter.inner to avoid increasing the next calls count
                 // while populating the buffer. This means the index in the following loop is the
                 // right one for user errors.
-                let mut tail_buffer: VecDeque<&'data I> =
-                    collection_iter.inner.by_ref().take(n_tail_validators).collect();
+                let mut tail_buffer: VecDeque<I> = collection_iter.inner.by_ref().take(n_tail_validators).collect();
 
                 // Save the current index for the tail validation below when we recreate a new NextCountingIterator
                 let mut index = collection_iter.next_calls();
@@ -161,7 +161,7 @@ impl TupleValidator {
                     let buffered_item = tail_buffer.pop_front().unwrap();
                     tail_buffer.push_back(input_item);
 
-                    match variable_validator.validate(py, buffered_item, state) {
+                    match variable_validator.validate(py, buffered_item.borrow_input(), state) {
                         Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
                         Err(ValError::LineErrors(line_errors)) => {
                             errors.extend(
@@ -326,7 +326,7 @@ impl Validator for TupleValidator {
         }
 
         if errors.is_empty() {
-            Ok(PyTuple::new(py, &output).into_py(py))
+            Ok(PyTuple::new_bound(py, output).into_py(py))
         } else {
             Err(ValError::LineErrors(errors))
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index ec0cc07cf..7299cfff9 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -44,14 +44,15 @@ impl BuildValidator for TypedDictValidator {
     const EXPECTED_TYPE: &'static str = "typed-dict";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         // typed dicts ignore the parent config and always use the config from this TypedDict
         let config = schema.get_as(intern!(py, "config"))?;
+        let config = config.as_ref();
 
         let strict = is_strict(schema, config)?;
 
@@ -62,21 +63,22 @@ impl BuildValidator for TypedDictValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<TypedDictField> = Vec::with_capacity(fields_dict.len());
 
         for (key, value) in fields_dict {
-            let field_info: &PyDict = value.downcast()?;
-            let field_name: &str = key.extract()?;
+            let field_info = value.downcast::<PyDict>()?;
+            let field_name_py = key.downcast_into::<PyString>()?;
+            let field_name = field_name_py.to_str()?;
 
             let schema = field_info.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
@@ -112,7 +114,7 @@ impl BuildValidator for TypedDictValidator {
             let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, field_name),
             };
@@ -120,7 +122,7 @@ impl BuildValidator for TypedDictValidator {
             fields.push(TypedDictField {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::new(py, field_name).into(),
+                name_py: field_name_py.into(),
                 validator,
                 required,
             });
@@ -152,7 +154,7 @@ impl Validator for TypedDictValidator {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
 
-        let output_dict = PyDict::new(py);
+        let output_dict = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
         // we only care about which keys have been used if we're iterating over the object for extra after
@@ -173,9 +175,9 @@ impl Validator for TypedDictValidator {
         }
 
         macro_rules! process {
-            ($dict:ident, $get_method:ident, $iter:ty $(,$kwargs:ident)?) => {{
+            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
                 match state.with_new_extra(Extra {
-                    data: Some(output_dict),
+                    data: Some(output_dict.clone()),
                     ..*state.extra()
                 }, |state| {
                     for field in &self.fields {
@@ -278,7 +280,7 @@ impl Validator for TypedDictValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key,
+                                        raw_key.clone(),
                                     )
 
                                 );
@@ -310,10 +312,14 @@ impl Validator for TypedDictValidator {
             }};
         }
         match dict {
-            GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
+            GenericMapping::PyDict(d) => {
+                process!(&d, py_get_dict_item, DictGenericIterator);
+            }
+            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => {
+                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
+            }
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 0a5bd0c65..8b64ecbf6 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -51,17 +51,17 @@ impl BuildValidator for UnionValidator {
     const EXPECTED_TYPE: &'static str = "union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let choices: Vec<(CombinedValidator, Option<String>)> = schema
-            .get_as_req::<&PyList>(intern!(py, "choices"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(py, "choices"))?
             .iter()
             .map(|choice| {
                 let mut label: Option<String> = None;
-                let choice: &PyAny = match choice.downcast::<PyTuple>() {
+                let choice = match choice.downcast::<PyTuple>() {
                     Ok(py_tuple) => {
                         let choice = py_tuple.get_item(0)?;
                         label = Some(py_tuple.get_item(1)?.to_string());
@@ -69,14 +69,14 @@ impl BuildValidator for UnionValidator {
                     }
                     Err(_) => choice,
                 };
-                Ok((build_validator(choice, config, definitions)?, label))
+                Ok((build_validator(&choice, config, definitions)?, label))
             })
             .collect::<PyResult<Vec<(CombinedValidator, Option<String>)>>>()?;
 
         let auto_collapse = || schema.get_as_req(intern!(py, "auto_collapse")).unwrap_or(true);
         let mode = schema
-            .get_as::<&str>(intern!(py, "mode"))?
-            .map_or(Ok(UnionMode::Smart), UnionMode::from_str)?;
+            .get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?
+            .map_or(Ok(UnionMode::Smart), |mode| mode.to_str().and_then(UnionMode::from_str))?;
         match choices.len() {
             0 => py_schema_err!("One or more union choices required"),
             1 if auto_collapse() => Ok(choices.into_iter().next().unwrap().0),
@@ -284,7 +284,7 @@ enum Discriminator {
 }
 
 impl Discriminator {
-    fn new(py: Python, raw: &PyAny) -> PyResult<Self> {
+    fn new(py: Python, raw: &Bound<'_, PyAny>) -> PyResult<Self> {
         if raw.is_callable() {
             return Ok(Self::Function(raw.to_object(py)));
         } else if let Ok(py_str) = raw.downcast::<PyString>() {
@@ -332,24 +332,24 @@ impl BuildValidator for TaggedUnionValidator {
     const EXPECTED_TYPE: &'static str = "tagged-union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let discriminator = Discriminator::new(py, schema.get_as_req(intern!(py, "discriminator"))?)?;
+        let discriminator = Discriminator::new(py, &schema.get_as_req(intern!(py, "discriminator"))?)?;
         let discriminator_repr = discriminator.to_string_py(py)?;
 
-        let choices = PyDict::new(py);
+        let choices = PyDict::new_bound(py);
         let mut tags_repr = String::with_capacity(50);
         let mut descr = String::with_capacity(50);
         let mut first = true;
         let mut discriminators = Vec::with_capacity(choices.len());
-        let schema_choices: &PyDict = schema.get_as_req(intern!(py, "choices"))?;
+        let schema_choices: Bound<PyDict> = schema.get_as_req(intern!(py, "choices"))?;
         let mut lookup_map = Vec::with_capacity(choices.len());
         for (choice_key, choice_schema) in schema_choices {
-            discriminators.push(choice_key);
-            let validator = build_validator(choice_schema, config, definitions)?;
+            discriminators.push(choice_key.clone());
+            let validator = build_validator(&choice_schema, config, definitions)?;
             let tag_repr = choice_key.repr()?.to_string();
             if first {
                 first = false;
@@ -399,13 +399,11 @@ impl Validator for TaggedUnionValidator {
         match self.discriminator {
             Discriminator::LookupKey(ref lookup_key) => {
                 macro_rules! find_validator {
-                    ($get_method:ident, $($dict:ident),+) => {{
+                    ($get_method:ident, $($dict:expr),+) => {{
                         // note all these methods return PyResult<Option<(data, data)>>, the outer Err is just for
                         // errors when getting attributes which should be "raised"
                         match lookup_key.$get_method($( $dict ),+)? {
-                            Some((_, value)) => {
-                                Ok(value.to_object(py).into_ref(py))
-                            }
+                            Some((_, value)) => Ok(value.to_object(py)),
                             None => Err(self.tag_not_found(input)),
                         }
                     }};
@@ -413,24 +411,32 @@ impl Validator for TaggedUnionValidator {
                 let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
                 let dict = input.validate_model_fields(self.strict, from_attributes)?;
                 let tag = match dict {
-                    GenericMapping::PyDict(dict) => find_validator!(py_get_dict_item, dict),
-                    GenericMapping::PyMapping(mapping) => find_validator!(py_get_mapping_item, mapping),
-                    GenericMapping::StringMapping(d) => find_validator!(py_get_dict_item, d),
-                    GenericMapping::PyGetAttr(obj, kwargs) => find_validator!(py_get_attr, obj, kwargs),
+                    GenericMapping::PyDict(dict) => {
+                        find_validator!(py_get_dict_item, &dict)
+                    }
+                    GenericMapping::PyMapping(mapping) => {
+                        find_validator!(py_get_mapping_item, &mapping)
+                    }
+                    GenericMapping::StringMapping(d) => {
+                        find_validator!(py_get_dict_item, &d)
+                    }
+                    GenericMapping::PyGetAttr(obj, kwargs) => {
+                        find_validator!(py_get_attr, &obj, kwargs.as_ref())
+                    }
                     GenericMapping::JsonObject(mapping) => find_validator!(json_get, mapping),
                 }?;
-                self.find_call_validator(py, tag, input, state)
+                self.find_call_validator(py, tag.bind(py), input, state)
             }
             Discriminator::Function(ref func) => {
-                let tag = func.call1(py, (input.to_object(py),))?;
+                let tag: Py<PyAny> = func.call1(py, (input.to_object(py),))?;
                 if tag.is_none(py) {
                     Err(self.tag_not_found(input))
                 } else {
-                    self.find_call_validator(py, tag.into_ref(py), input, state)
+                    self.find_call_validator(py, tag.bind(py), input, state)
                 }
             }
             Discriminator::SelfSchema => {
-                self.find_call_validator(py, self.self_schema_tag(py, input)?.as_ref(), input, state)
+                self.find_call_validator(py, self.self_schema_tag(py, input)?.as_any(), input, state)
             }
         }
     }
@@ -441,45 +447,43 @@ impl Validator for TaggedUnionValidator {
 }
 
 impl TaggedUnionValidator {
-    fn self_schema_tag<'s, 'data>(
-        &'s self,
+    fn self_schema_tag<'data>(
+        &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-    ) -> ValResult<&'data PyString> {
+    ) -> ValResult<Bound<'data, PyString>> {
         let dict = input.strict_dict()?;
-        let either_tag = match dict {
+        let tag = match &dict {
             GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
-                Some(t) => t.validate_str(true, false)?.into_inner(),
+                Some(t) => t.downcast_into::<PyString>()?,
                 None => return Err(self.tag_not_found(input)),
             },
             _ => unreachable!(),
         };
-        let tag_cow = either_tag.as_cow()?;
-        let tag = tag_cow.as_ref();
+        let tag = tag.to_str()?;
         // custom logic to distinguish between different function and tuple schemas
         if tag == "function" {
-            let mode = match dict {
-                GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode"))? {
-                    Some(m) => Some(m.validate_str(true, false)?.into_inner()),
-                    None => None,
-                },
-                _ => unreachable!(),
+            let GenericMapping::PyDict(dict) = dict else {
+                unreachable!()
             };
-            let mode = mode.ok_or_else(|| self.tag_not_found(input))?;
-            match mode.as_cow()?.as_ref() {
-                "plain" => Ok(intern!(py, "function-plain")),
-                "wrap" => Ok(intern!(py, "function-wrap")),
-                _ => Ok(intern!(py, "function")),
-            }
+            let Some(mode) = dict.get_item(intern!(py, "mode"))? else {
+                return Err(self.tag_not_found(input));
+            };
+            let tag = match mode.validate_str(true, false)?.into_inner().as_cow()?.as_ref() {
+                "plain" => Ok(intern!(py, "function-plain").to_owned()),
+                "wrap" => Ok(intern!(py, "function-wrap").to_owned()),
+                _ => Ok(intern!(py, "function").to_owned()),
+            };
+            tag
         } else {
-            Ok(PyString::new(py, tag))
+            Ok(PyString::new_bound(py, tag))
         }
     }
 
     fn find_call_validator<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        tag: &'data PyAny,
+        tag: &Bound<'data, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
diff --git a/src/validators/url.rs b/src/validators/url.rs
index ba0d4cd4d..5529c2667 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -37,8 +37,8 @@ impl BuildValidator for UrlValidator {
     const EXPECTED_TYPE: &'static str = "url";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let (allowed_schemes, name) = get_allowed_schemas(schema, Self::EXPECTED_TYPE)?;
@@ -165,8 +165,8 @@ impl BuildValidator for MultiHostUrlValidator {
     const EXPECTED_TYPE: &'static str = "multi-host-url";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let (allowed_schemes, name) = get_allowed_schemas(schema, Self::EXPECTED_TYPE)?;
@@ -501,7 +501,7 @@ fn check_sub_defaults(
     Ok(())
 }
 
-fn get_allowed_schemas(schema: &PyDict, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
+fn get_allowed_schemas(schema: &Bound<'_, PyDict>, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
     match schema.get_as::<&PyList>(intern!(schema.py(), "allowed_schemes"))? {
         Some(list) => {
             if list.is_empty() {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index c0854c10f..a567d3f6b 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -23,13 +23,13 @@ const UUID_IS_SAFE: &str = "is_safe";
 static UUID_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
 fn import_type(py: Python, module: &str, attr: &str) -> PyResult<Py<PyType>> {
-    py.import(module)?.getattr(attr)?.extract()
+    py.import_bound(module)?.getattr(attr)?.extract()
 }
 
-fn get_uuid_type(py: Python) -> PyResult<&PyType> {
+fn get_uuid_type(py: Python) -> PyResult<&Bound<'_, PyType>> {
     Ok(UUID_TYPE
         .get_or_init(py, || import_type(py, "uuid", "UUID").unwrap())
-        .as_ref(py))
+        .bind(py))
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -68,8 +68,8 @@ impl BuildValidator for UuidValidator {
     const EXPECTED_TYPE: &'static str = "uuid";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -113,7 +113,7 @@ impl Validator for UuidValidator {
         } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::IsInstanceOf {
-                    class: class.name().unwrap_or("UUID").to_string(),
+                    class: class.qualname().unwrap_or_else(|_| "UUID".to_owned()),
                     context: None,
                 },
                 input,
@@ -140,7 +140,7 @@ impl Validator for UuidValidator {
                     ));
                 }
             }
-            self.create_py_uuid(py, class, &uuid)
+            self.create_py_uuid(class, &uuid)
         }
     }
 
@@ -213,16 +213,16 @@ impl UuidValidator {
     ///
     /// This implementation does not use the Python `__init__` function to speed up the process,
     /// as the `__init__` function in the Python `uuid` module performs extensive checks.
-    fn create_py_uuid(&self, py: Python<'_>, py_type: &PyType, uuid: &Uuid) -> ValResult<Py<PyAny>> {
-        let class = create_class(py_type)?;
-        let dc = class.as_ref(py);
+    fn create_py_uuid(&self, py_type: &Bound<'_, PyType>, uuid: &Uuid) -> ValResult<PyObject> {
+        let py = py_type.py();
+        let dc = create_class(py_type)?;
         let int = uuid.as_u128();
         let safe = py
-            .import(intern!(py, "uuid"))?
+            .import_bound(intern!(py, "uuid"))?
             .getattr(intern!(py, "SafeUUID"))?
             .get_item("safe")?;
-        force_setattr(py, dc, intern!(py, UUID_INT), int)?;
-        force_setattr(py, dc, intern!(py, UUID_IS_SAFE), safe)?;
-        Ok(dc.to_object(py))
+        force_setattr(py, &dc, intern!(py, UUID_INT), int)?;
+        force_setattr(py, &dc, intern!(py, UUID_IS_SAFE), safe)?;
+        Ok(dc.into())
     }
 }
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 4f241d768..61de64fd6 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -38,7 +38,9 @@ impl<'a> ValidationState<'a> {
             extra,
         };
         let result = f(&mut new_state);
-        match new_state.exactness {
+        let exactness = new_state.exactness;
+        drop(new_state);
+        match exactness {
             Some(exactness) => self.floor_exactness(exactness),
             None => self.exactness = None,
         }
@@ -53,7 +55,10 @@ impl<'a> ValidationState<'a> {
         f: impl FnOnce(&mut Extra<'a>),
     ) -> ValidationStateWithReboundExtra<'state, 'a> {
         #[allow(clippy::unnecessary_struct_initialization)]
-        let old_extra = Extra { ..self.extra };
+        let old_extra = Extra {
+            data: self.extra.data.clone(),
+            ..self.extra
+        };
         f(&mut self.extra);
         ValidationStateWithReboundExtra { state: self, old_extra }
     }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index f520eaf38..b1ee12ca9 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -1,7 +1,8 @@
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::PyDict;
+use pyo3::types::PyString;
 use pyo3::PyTraverseError;
 use pyo3::PyVisit;
 
@@ -17,7 +18,7 @@ use crate::PydanticUndefinedType;
 static COPY_DEEPCOPY: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_deepcopy(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("copy")?.getattr("deepcopy")?.into_py(py))
+    Ok(py.import_bound("copy")?.getattr("deepcopy")?.into_py(py))
 }
 
 #[derive(Debug, Clone)]
@@ -28,7 +29,7 @@ pub enum DefaultType {
 }
 
 impl DefaultType {
-    pub fn new(schema: &PyDict) -> PyResult<Self> {
+    pub fn new(schema: &Bound<'_, PyDict>) -> PyResult<Self> {
         let py = schema.py();
         match (
             schema.get_as(intern!(py, "default"))?,
@@ -81,13 +82,18 @@ impl BuildValidator for WithDefaultValidator {
     const EXPECTED_TYPE: &'static str = "default";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let default = DefaultType::new(schema)?;
-        let on_error = match schema.get_as::<&str>(intern!(py, "on_error"))? {
+        let on_error = match schema
+            .get_as::<Bound<'_, PyString>>(intern!(py, "on_error"))?
+            .as_ref()
+            .map(|s| s.to_str())
+            .transpose()?
+        {
             Some("raise") => OnError::Raise,
             Some("omit") => OnError::Omit,
             Some("default") => {
@@ -101,11 +107,11 @@ impl BuildValidator for WithDefaultValidator {
             _ => unreachable!(),
         };
 
-        let sub_schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&sub_schema, config, definitions)?);
 
         let copy_default = if let DefaultType::Default(default_obj) = &default {
-            default_obj.as_ref(py).hash().is_err()
+            default_obj.bind(py).hash().is_err()
         } else {
             false
         };
@@ -166,7 +172,7 @@ impl Validator for WithDefaultValidator {
                     stored_dft
                 };
                 if self.validate_default {
-                    match self.validate(py, dft.into_ref(py), state) {
+                    match self.validate(py, dft.bind(py), state) {
                         Ok(v) => Ok(Some(v)),
                         Err(e) => {
                             if let Some(outer_loc) = outer_loc {
diff --git a/tests/test.rs b/tests/test.rs
index 597084b3b..46d0ede8d 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -45,8 +45,8 @@ mod tests {
                     },
                 ]
             }";
-            let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
-            SchemaSerializer::py_new(py, schema, None).unwrap();
+            let schema: Bound<'_, PyDict> = py.eval_bound(code, None, None).unwrap().extract().unwrap();
+            SchemaSerializer::py_new(schema, None).unwrap();
         });
     }
 
@@ -73,18 +73,22 @@ schema = {
 }
 a = A()
             "#;
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let a: &PyAny = locals.get_item("a").unwrap().unwrap().extract().unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let a = locals.get_item("a").unwrap().unwrap();
+            let schema = locals
+                .get_item("schema")
+                .unwrap()
+                .unwrap()
+                .downcast_into::<PyDict>()
+                .unwrap();
+            let serialized = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(
-                    py, a, None, None, None, true, false, false, false, false, true, None, None,
+                    py, &a, None, None, None, true, false, false, false, false, true, None, None,
                 )
-                .unwrap()
-                .extract(py)
                 .unwrap();
+            let serialized: &[u8] = serialized.extract(py).unwrap();
             assert_eq!(serialized, b"{\"b\":\"b\"}");
         });
     }
@@ -106,13 +110,13 @@ schema = {
 }
 json_input = '{"a": "something"}'
             "#;
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let json_input: &PyAny = locals.get_item("json_input").unwrap().unwrap().extract().unwrap();
-            let binding = SchemaValidator::py_new(py, schema, None)
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let schema = locals.get_item("schema").unwrap().unwrap();
+            let json_input = locals.get_item("json_input").unwrap().unwrap();
+            let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, json_input, None, None, None)
+                .validate_json(py, &json_input, None, None, None)
                 .unwrap();
             let validation_result: &PyAny = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
@@ -159,26 +163,21 @@ schema = {
 dump_json_input_1 = 1
 dump_json_input_2 = {'a': 'something'}
             ";
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let dump_json_input_1: &PyAny = locals
-                .get_item("dump_json_input_1")
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let schema = locals
+                .get_item("schema")
                 .unwrap()
                 .unwrap()
-                .extract()
+                .downcast_into::<PyDict>()
                 .unwrap();
-            let dump_json_input_2: &PyAny = locals
-                .get_item("dump_json_input_2")
-                .unwrap()
-                .unwrap()
-                .extract()
-                .unwrap();
-            let binding = SchemaSerializer::py_new(py, schema, None)
-                .unwrap()
+            let dump_json_input_1 = locals.get_item("dump_json_input_1").unwrap().unwrap();
+            let dump_json_input_2 = locals.get_item("dump_json_input_2").unwrap().unwrap();
+            let serializer = SchemaSerializer::py_new(schema, None).unwrap();
+            let serialization_result = serializer
                 .to_json(
                     py,
-                    dump_json_input_1,
+                    &dump_json_input_1,
                     None,
                     None,
                     None,
@@ -192,15 +191,13 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                 )
                 .unwrap();
-            let serialization_result: &PyAny = binding.extract(py).unwrap();
-            let repr = format!("{}", serialization_result.repr().unwrap());
+            let repr = format!("{}", serialization_result.bind(py).repr().unwrap());
             assert_eq!(repr, "b'1'");
 
-            let binding = SchemaSerializer::py_new(py, schema, None)
-                .unwrap()
+            let serialization_result = serializer
                 .to_json(
                     py,
-                    dump_json_input_2,
+                    &dump_json_input_2,
                     None,
                     None,
                     None,
@@ -214,8 +211,7 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                 )
                 .unwrap();
-            let serialization_result: &PyAny = binding.extract(py).unwrap();
-            let repr = format!("{}", serialization_result.repr().unwrap());
+            let repr = format!("{}", serialization_result.bind(py).repr().unwrap());
             assert_eq!(repr, "b'{\"a\":\"something\"}'");
         });
     }