diff --git a/V4_MIGRATION_GUIDE.md b/V4_MIGRATION_GUIDE.md
index b8ca744b..5b0e083b 100644
--- a/V4_MIGRATION_GUIDE.md
+++ b/V4_MIGRATION_GUIDE.md
@@ -50,14 +50,16 @@ buildscript {
 
 ### Kotlin Version
 
-v4 uses **Kotlin 2.0.21**. If you're using Kotlin in your project, you may need to update your Kotlin version to ensure compatibility.
+v4 uses **Kotlin 2.2.0**. If you're using Kotlin in your project, you may need to update your Kotlin version to ensure compatibility.
 
 ```groovy
 buildscript {
-    ext.kotlin_version = "2.0.21"
+    ext.kotlin_version = "2.2.0"
 }
 ```
 
+> **Note:** Kotlin 2.2.0 promotes the deprecation of `String.toLowerCase()` / `String.toUpperCase()` without a `Locale` parameter to an error. If your project uses these methods, replace them with `lowercase(Locale.ROOT)` / `uppercase(Locale.ROOT)`.
+
 ## Breaking Changes
 
 ### Classes Removed
@@ -96,6 +98,17 @@ implementation 'com.google.code.gson:gson:2.8.9' // your preferred version
 
 > **Note:** Pinning or excluding is not recommended long-term, as the SDK has been tested and validated against Gson 2.11.0.
 
+### OkHttp 4.12.0 → 5.0.0 (Internal Dependency)
+
+v4 upgrades the internal OkHttp dependency from **4.12.0** to **5.0.0**. OkHttp is used as an `implementation` dependency and is **not** exposed in the SDK's public API, so this change should be transparent to most applications.
+
+However, if your app provides a custom `NetworkingClient` implementation that interacts with OkHttp types, or if you depend on OkHttp transitively through the SDK, be aware of the following:
+
+- **OkHttp 5.0.0 requires Kotlin 2.2.0+** at compile time. This is already satisfied by the SDK's Kotlin version requirement.
+- **Okio 3.x is now required.** OkHttp 5.0.0 depends on Okio 3.x (previously Okio 2.x). If your app uses Okio directly, you may need to update your Okio dependency.
+
+> **Note:** Since OkHttp is an internal dependency of the SDK, no changes are required in your application code unless you are directly depending on OkHttp types from this SDK's classpath.
+
 ## Getting Help
 
 If you encounter issues during migration:
diff --git a/auth0/build.gradle b/auth0/build.gradle
index 28ff39fb..d4769bfc 100644
--- a/auth0/build.gradle
+++ b/auth0/build.gradle
@@ -80,7 +80,7 @@ android {
 }
 
 ext {
-    okhttpVersion = '4.12.0'
+    okhttpVersion = '5.0.0'
     coroutinesVersion = '1.10.2'
     biometricLibraryVersion = '1.1.0'
 }
@@ -104,7 +104,7 @@ dependencies {
     testImplementation 'org.hamcrest:java-hamcrest:2.0.0.0'
     testImplementation 'org.mockito:mockito-core:5.14.0'
     testImplementation 'org.mockito.kotlin:mockito-kotlin:5.4.0'
-    testImplementation "com.squareup.okhttp3:mockwebserver:$okhttpVersion"
+    testImplementation "com.squareup.okhttp3:mockwebserver3:$okhttpVersion"
     testImplementation "com.squareup.okhttp3:okhttp-tls:$okhttpVersion"
     testImplementation 'com.jayway.awaitility:awaitility:1.7.0'
     testImplementation 'org.robolectric:robolectric:4.15.1'
diff --git a/auth0/src/main/java/com/auth0/android/provider/WebAuthProvider.kt b/auth0/src/main/java/com/auth0/android/provider/WebAuthProvider.kt
index 955eec9c..09920438 100644
--- a/auth0/src/main/java/com/auth0/android/provider/WebAuthProvider.kt
+++ b/auth0/src/main/java/com/auth0/android/provider/WebAuthProvider.kt
@@ -176,7 +176,7 @@ public object WebAuthProvider : SenderConstraining<WebAuthProvider> {
          * @return the current builder instance
          */
         public fun withScheme(scheme: String): LogoutBuilder {
-            val lowerCase = scheme.toLowerCase(Locale.ROOT)
+            val lowerCase = scheme.lowercase(Locale.ROOT)
             if (scheme != lowerCase) {
                 Log.w(
                     TAG,
@@ -397,7 +397,7 @@ public object WebAuthProvider : SenderConstraining<WebAuthProvider> {
          * @return the current builder instance
          */
         public fun withScheme(scheme: String): Builder {
-            val lowerCase = scheme.toLowerCase(Locale.ROOT)
+            val lowerCase = scheme.lowercase(Locale.ROOT)
             if (scheme != lowerCase) {
                 Log.w(
                     TAG,
diff --git a/auth0/src/main/java/com/auth0/android/request/internal/OidcUtils.kt b/auth0/src/main/java/com/auth0/android/request/internal/OidcUtils.kt
index bcb22f67..ee5d2bc2 100644
--- a/auth0/src/main/java/com/auth0/android/request/internal/OidcUtils.kt
+++ b/auth0/src/main/java/com/auth0/android/request/internal/OidcUtils.kt
@@ -19,7 +19,7 @@ internal object OidcUtils {
      */
     fun includeRequiredScope(scope: String): String {
         val existingScopes = scope.split(" ")
-            .map { it.toLowerCase(Locale.ROOT) }
+            .map { it.lowercase(Locale.ROOT) }
         return if (!existingScopes.contains(REQUIRED_SCOPE)) {
             (existingScopes + REQUIRED_SCOPE).joinToString(separator = " ").trim()
         } else {
diff --git a/auth0/src/test/java/com/auth0/android/authentication/AuthenticationAPIClientTest.kt b/auth0/src/test/java/com/auth0/android/authentication/AuthenticationAPIClientTest.kt
index 350ec5d2..60a28ae9 100755
--- a/auth0/src/test/java/com/auth0/android/authentication/AuthenticationAPIClientTest.kt
+++ b/auth0/src/test/java/com/auth0/android/authentication/AuthenticationAPIClientTest.kt
@@ -41,7 +41,7 @@ import org.mockito.kotlin.whenever
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
 import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.RecordedRequest
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers
 import org.hamcrest.collection.IsMapContaining
@@ -183,12 +183,12 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -221,12 +221,12 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<Any>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -250,12 +250,12 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<Any>(request)
-        assertThat(request.path, Matchers.equalTo("/passkey/register"))
+        assertThat(request.target, Matchers.equalTo("/passkey/register"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("realm", MY_CONNECTION))
         assertThat(body, Matchers.hasEntry("organization", "testOrganization"))
@@ -273,12 +273,12 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/passkey/challenge"))
+        assertThat(request.target, Matchers.equalTo("/passkey/challenge"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("realm", MY_CONNECTION))
         assertThat(body, Matchers.hasEntry("organization", "testOrganization"))
@@ -304,12 +304,12 @@ public class AuthenticationAPIClientTest {
         assertThat(callback.payload.recoveryCode, Matchers.`is`("654321"))
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -336,12 +336,12 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -369,12 +369,12 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -395,11 +395,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/mfa/challenge"))
+        assertThat(request.target, Matchers.equalTo("/mfa/challenge"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("mfa_token", "ey30.the-mfa-token.value"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
@@ -422,11 +422,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/mfa/challenge"))
+        assertThat(request.target, Matchers.equalTo("/mfa/challenge"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("mfa_token", "ey30.the-mfa-token.value"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
@@ -451,7 +451,7 @@ public class AuthenticationAPIClientTest {
         assertThat(credentials.user.getId(), Matchers.`is`("auth0|123456"))
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -475,7 +475,7 @@ public class AuthenticationAPIClientTest {
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -505,12 +505,12 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
             body,
@@ -537,9 +537,9 @@ public class AuthenticationAPIClientTest {
             )
         )
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.`is`("/oauth/token"))
+        assertThat(request.target, Matchers.`is`("/oauth/token"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -562,9 +562,9 @@ public class AuthenticationAPIClientTest {
             .execute()
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.`is`("/oauth/token"))
+        assertThat(request.target, Matchers.`is`("/oauth/token"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -588,9 +588,9 @@ public class AuthenticationAPIClientTest {
             .await()
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.`is`("/oauth/token"))
+        assertThat(request.target, Matchers.`is`("/oauth/token"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -619,15 +619,15 @@ public class AuthenticationAPIClientTest {
         )
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         assertThat(
-            request.getHeader("Authorization"),
+            request.headers["Authorization"],
             Matchers.`is`("Bearer ACCESS_TOKEN")
         )
-        assertThat(request.path, Matchers.equalTo("/userinfo"))
+        assertThat(request.target, Matchers.equalTo("/userinfo"))
     }
 
     @Test
@@ -639,15 +639,15 @@ public class AuthenticationAPIClientTest {
         assertThat(profile, Matchers.`is`(Matchers.notNullValue()))
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         assertThat(
-            request.getHeader("Authorization"),
+            request.headers["Authorization"],
             Matchers.`is`("Bearer ACCESS_TOKEN")
         )
-        assertThat(request.path, Matchers.equalTo("/userinfo"))
+        assertThat(request.target, Matchers.equalTo("/userinfo"))
     }
 
     @Test
@@ -660,15 +660,15 @@ public class AuthenticationAPIClientTest {
         assertThat(profile, Matchers.`is`(Matchers.notNullValue()))
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
         assertThat(
-            request.getHeader("Authorization"),
+            request.headers["Authorization"],
             Matchers.`is`("Bearer ACCESS_TOKEN")
         )
-        assertThat(request.path, Matchers.equalTo("/userinfo"))
+        assertThat(request.target, Matchers.equalTo("/userinfo"))
     }
 
     @Test
@@ -680,11 +680,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -709,11 +709,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -735,11 +735,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -763,11 +763,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -795,11 +795,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -826,11 +826,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -854,11 +854,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -882,11 +882,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -914,11 +914,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -946,11 +946,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -975,11 +975,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -1002,11 +1002,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1029,11 +1029,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1053,11 +1053,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1076,11 +1076,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1101,11 +1101,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1123,11 +1123,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1145,11 +1145,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1170,11 +1170,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1192,11 +1192,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1214,11 +1214,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1238,11 +1238,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1259,11 +1259,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1284,11 +1284,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1300,7 +1300,7 @@ public class AuthenticationAPIClientTest {
             )
         )
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1325,11 +1325,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1356,11 +1356,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<Any>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1369,7 +1369,7 @@ public class AuthenticationAPIClientTest {
         assertThat(body, Matchers.hasEntry("user_metadata", testMetadata))
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1392,11 +1392,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1404,7 +1404,7 @@ public class AuthenticationAPIClientTest {
         assertThat(body, Matchers.hasEntry("connection", MY_CONNECTION))
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1429,11 +1429,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("username", SUPPORT))
@@ -1441,7 +1441,7 @@ public class AuthenticationAPIClientTest {
         assertThat(body, Matchers.hasEntry("connection", MY_CONNECTION))
         assertThat(credentials, Matchers.`is`(Matchers.notNullValue()))
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1465,11 +1465,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("password", PASSWORD))
@@ -1480,7 +1480,7 @@ public class AuthenticationAPIClientTest {
             )
         )
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1506,11 +1506,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1522,7 +1522,7 @@ public class AuthenticationAPIClientTest {
             )
         )
         val loginRequest = mockAPI.takeRequest()
-        assertThat(loginRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(loginRequest.target, Matchers.equalTo("/oauth/token"))
         val loginBody = bodyFromRequest<String>(loginRequest)
         assertThat(loginBody, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(loginBody, Matchers.hasEntry("password", PASSWORD))
@@ -1540,11 +1540,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1559,11 +1559,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1578,11 +1578,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1598,11 +1598,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1618,11 +1618,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1638,11 +1638,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/dbconnections/change_password"))
+        assertThat(request.target, Matchers.equalTo("/dbconnections/change_password"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.not(Matchers.hasKey("username")))
@@ -1659,11 +1659,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1681,11 +1681,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1701,11 +1701,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1721,11 +1721,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1742,11 +1742,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1764,11 +1764,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1784,11 +1784,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1804,11 +1804,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1829,11 +1829,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1851,11 +1851,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1871,11 +1871,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1891,11 +1891,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("email", SUPPORT_AUTH0_COM))
@@ -1912,11 +1912,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -1934,11 +1934,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -1954,11 +1954,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -1974,11 +1974,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -1995,11 +1995,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2017,11 +2017,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2037,11 +2037,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2057,11 +2057,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2078,11 +2078,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2100,11 +2100,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2120,11 +2120,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2140,11 +2140,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("phone_number", "+1123123123"))
@@ -2160,9 +2160,9 @@ public class AuthenticationAPIClientTest {
             .start(callback)
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/.well-known/jwks.json"))
+        assertThat(request.target, Matchers.equalTo("/.well-known/jwks.json"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -2175,9 +2175,9 @@ public class AuthenticationAPIClientTest {
         val result = client.fetchJsonWebKeys()
             .execute()
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/.well-known/jwks.json"))
+        assertThat(request.target, Matchers.equalTo("/.well-known/jwks.json"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -2192,9 +2192,9 @@ public class AuthenticationAPIClientTest {
         val result = client.fetchJsonWebKeys()
             .await()
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/.well-known/jwks.json"))
+        assertThat(request.target, Matchers.equalTo("/.well-known/jwks.json"))
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
@@ -2211,7 +2211,7 @@ public class AuthenticationAPIClientTest {
             .start(callback)
         ShadowLooper.idleMainLooper()
         val firstRequest = mockAPI.takeRequest()
-        assertThat(firstRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(firstRequest.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(firstRequest)
         assertThat(body, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("password", "voidpassword"))
@@ -2223,10 +2223,10 @@ public class AuthenticationAPIClientTest {
         )
         val secondRequest = mockAPI.takeRequest()
         assertThat(
-            secondRequest.getHeader("Authorization"),
+            secondRequest.headers["Authorization"],
             Matchers.`is`("Bearer " + AuthenticationAPIMockServer.ACCESS_TOKEN)
         )
-        assertThat(secondRequest.path, Matchers.equalTo("/userinfo"))
+        assertThat(secondRequest.target, Matchers.equalTo("/userinfo"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 Authentication::class.java
@@ -2245,11 +2245,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/revoke"))
+        assertThat(request.target, Matchers.equalTo("/oauth/revoke"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("token", "refreshToken"))
@@ -2265,11 +2265,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/revoke"))
+        assertThat(request.target, Matchers.equalTo("/oauth/revoke"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("token", "refreshToken"))
@@ -2285,11 +2285,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/revoke"))
+        assertThat(request.target, Matchers.equalTo("/oauth/revoke"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("token", "refreshToken"))
@@ -2304,11 +2304,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2334,11 +2334,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2361,11 +2361,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2388,11 +2388,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2418,11 +2418,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2443,11 +2443,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(
@@ -2473,11 +2473,11 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.not(Matchers.hasKey("scope")))
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
@@ -2499,11 +2499,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2522,11 +2522,11 @@ public class AuthenticationAPIClientTest {
             .await()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2545,11 +2545,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2567,11 +2567,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2591,11 +2591,11 @@ public class AuthenticationAPIClientTest {
                 .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2614,11 +2614,11 @@ public class AuthenticationAPIClientTest {
             .execute()
         val request = mockAPI.takeRequest()
         assertThat(
-            request.getHeader("Accept-Language"), Matchers.`is`(
+            request.headers["Accept-Language"], Matchers.`is`(
                 defaultLocale
             )
         )
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("client_id", CLIENT_ID))
         assertThat(body, Matchers.hasEntry("refresh_token", "refreshToken"))
@@ -2641,7 +2641,7 @@ public class AuthenticationAPIClientTest {
         )
             .execute()
         val firstRequest = mockAPI.takeRequest()
-        assertThat(firstRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(firstRequest.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(firstRequest)
         assertThat(body, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("password", "voidpassword"))
@@ -2653,10 +2653,10 @@ public class AuthenticationAPIClientTest {
         )
         val secondRequest = mockAPI.takeRequest()
         assertThat(
-            secondRequest.getHeader("Authorization"),
+            secondRequest.headers["Authorization"],
             Matchers.`is`("Bearer " + AuthenticationAPIMockServer.ACCESS_TOKEN)
         )
-        assertThat(secondRequest.path, Matchers.equalTo("/userinfo"))
+        assertThat(secondRequest.target, Matchers.equalTo("/userinfo"))
         assertThat(authentication, Matchers.`is`(Matchers.notNullValue()))
     }
 
@@ -2674,7 +2674,7 @@ public class AuthenticationAPIClientTest {
         )
             .await()
         val firstRequest = mockAPI.takeRequest()
-        assertThat(firstRequest.path, Matchers.equalTo("/oauth/token"))
+        assertThat(firstRequest.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(firstRequest)
         assertThat(body, Matchers.hasEntry("username", SUPPORT_AUTH0_COM))
         assertThat(body, Matchers.hasEntry("password", "voidpassword"))
@@ -2686,10 +2686,10 @@ public class AuthenticationAPIClientTest {
         )
         val secondRequest = mockAPI.takeRequest()
         assertThat(
-            secondRequest.getHeader("Authorization"),
+            secondRequest.headers["Authorization"],
             Matchers.`is`("Bearer " + AuthenticationAPIMockServer.ACCESS_TOKEN)
         )
-        assertThat(secondRequest.path, Matchers.equalTo("/userinfo"))
+        assertThat(secondRequest.target, Matchers.equalTo("/userinfo"))
         assertThat(authentication, Matchers.`is`(Matchers.notNullValue()))
     }
 
@@ -2702,7 +2702,7 @@ public class AuthenticationAPIClientTest {
             .start(callback)
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -2727,7 +2727,7 @@ public class AuthenticationAPIClientTest {
             .start(callback)
         ShadowLooper.idleMainLooper()
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -2759,8 +2759,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 Credentials::class.java
@@ -2776,8 +2776,8 @@ public class AuthenticationAPIClientTest {
         val challengeResponse = client.passkeyChallenge(MY_CONNECTION, "testOrganization")
             .execute()
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/passkey/challenge"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/passkey/challenge"))
         assertThat(challengeResponse, Matchers.`is`(Matchers.notNullValue()))
     }
 
@@ -2790,8 +2790,8 @@ public class AuthenticationAPIClientTest {
         val challengeResponse = client.passkeyChallenge(MY_CONNECTION, "testOrganization")
             .execute()
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/passkey/challenge"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/passkey/challenge"))
         assertThat(challengeResponse, Matchers.`is`(Matchers.notNullValue()))
     }
 
@@ -2808,8 +2808,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 Credentials::class.java
@@ -2829,8 +2829,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 Credentials::class.java
@@ -2848,8 +2848,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 Credentials::class.java
@@ -2871,8 +2871,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
 
         val body = bodyFromRequest<String>(request)
         assertThat(
@@ -2906,8 +2906,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
 
         val body = bodyFromRequest<String>(request)
         assertThat(body, Matchers.hasEntry("grant_type", "refresh_token"))
@@ -2938,8 +2938,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
 
         val body = bodyFromRequest<String>(request)
         assertThat(
@@ -2973,9 +2973,9 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.getHeader("Authorization"), Matchers.`is`("DPoP ACCESS_TOKEN"))
-        assertThat(request.path, Matchers.equalTo("/userinfo"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.headers["Authorization"], Matchers.`is`("DPoP ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/userinfo"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 UserProfile::class.java
@@ -2993,9 +2993,9 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.getHeader("Authorization"), Matchers.`is`("Bearer ACCESS_TOKEN"))
-        assertThat(request.path, Matchers.equalTo("/userinfo"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.headers["Authorization"], Matchers.`is`("Bearer ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/userinfo"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 UserProfile::class.java
@@ -3017,8 +3017,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/dbconnections/signup"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/dbconnections/signup"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 DatabaseUser::class.java
@@ -3040,8 +3040,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/passwordless/start"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/passwordless/start"))
         assertThat(callback, AuthenticationCallbackMatcher.hasNoError())
     }
 
@@ -3059,8 +3059,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.nullValue())
-        assertThat(request.path, Matchers.equalTo("/.well-known/jwks.json"))
+        assertThat(request.headers["DPoP"], Matchers.nullValue())
+        assertThat(request.target, Matchers.equalTo("/.well-known/jwks.json"))
         assertThat(callback, AuthenticationCallbackMatcher.hasPayload(emptyMap()))
     }
 
@@ -3077,8 +3077,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         val body = bodyFromRequest<String>(request)
         assertThat(
             body,
@@ -3104,8 +3104,8 @@ public class AuthenticationAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.getHeader("DPoP"), Matchers.notNullValue())
-        assertThat(request.path, Matchers.equalTo("/oauth/token"))
+        assertThat(request.headers["DPoP"], Matchers.notNullValue())
+        assertThat(request.target, Matchers.equalTo("/oauth/token"))
         assertThat(
             callback, AuthenticationCallbackMatcher.hasPayloadOfType(
                 SSOCredentials::class.java
@@ -3134,7 +3134,7 @@ public class AuthenticationAPIClientTest {
 
     private inline fun <reified T> bodyFromRequest(request: RecordedRequest): Map<String, T> {
         val mapType = object : TypeToken<Map<String, T>>() {}.type
-        return gson.fromJson(request.body.readUtf8(), mapType)
+        return gson.fromJson(request.body!!.utf8(), mapType)
     }
 
     private val defaultLocale: String
diff --git a/auth0/src/test/java/com/auth0/android/authentication/MfaApiClientTest.kt b/auth0/src/test/java/com/auth0/android/authentication/MfaApiClientTest.kt
index 8fec80b5..8090187b 100644
--- a/auth0/src/test/java/com/auth0/android/authentication/MfaApiClientTest.kt
+++ b/auth0/src/test/java/com/auth0/android/authentication/MfaApiClientTest.kt
@@ -20,9 +20,9 @@ import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.MockResponse
+import mockwebserver3.MockWebServer
+import mockwebserver3.RecordedRequest
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers.*
 import org.junit.After
@@ -57,15 +57,16 @@ public class MfaApiClientTest {
 
     @After
     public fun tearDown(): Unit {
-        mockServer.shutdown()
+        mockServer.close()
     }
 
     private fun enqueueMockResponse(json: String, statusCode: Int = 200): Unit {
         mockServer.enqueue(
-            MockResponse()
-                .setResponseCode(statusCode)
+            MockResponse.Builder()
+                .code(statusCode)
                 .addHeader("Content-Type", "application/json")
-                .setBody(json)
+                .body(json)
+                .build()
         )
     }
 
@@ -76,7 +77,7 @@ public class MfaApiClientTest {
 
     private inline fun <reified T> bodyFromRequest(request: RecordedRequest): Map<String, T> {
         val mapType = object : TypeToken<Map<String, T>>() {}.type
-        return gson.fromJson(request.body.readUtf8(), mapType)
+        return gson.fromJson(request.body!!.utf8(), mapType)
     }
 
 
@@ -139,8 +140,8 @@ public class MfaApiClientTest {
         mfaClient.getAuthenticators(listOf("oob")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.getHeader("Authorization"), `is`("Bearer $MFA_TOKEN"))
-        assertThat(request.path, `is`("/mfa/authenticators"))
+        assertThat(request.headers["Authorization"], `is`("Bearer $MFA_TOKEN"))
+        assertThat(request.target, `is`("/mfa/authenticators"))
         assertThat(request.method, `is`("GET"))
     }
 
@@ -193,9 +194,9 @@ public class MfaApiClientTest {
         mfaClient.enroll(MfaEnrollmentType.Phone("+12025550135")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/mfa/associate"))
+        assertThat(request.target, `is`("/mfa/associate"))
         assertThat(request.method, `is`("POST"))
-        assertThat(request.getHeader("Authorization"), `is`("Bearer $MFA_TOKEN"))
+        assertThat(request.headers["Authorization"], `is`("Bearer $MFA_TOKEN"))
 
         val body = bodyFromRequest<Any>(request)
         assertThat(body["authenticator_types"], `is`(listOf("oob")))
@@ -240,9 +241,9 @@ public class MfaApiClientTest {
         mfaClient.enroll(MfaEnrollmentType.Email("user@example.com")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/mfa/associate"))
+        assertThat(request.target, `is`("/mfa/associate"))
         assertThat(request.method, `is`("POST"))
-        assertThat(request.getHeader("Authorization"), `is`("Bearer $MFA_TOKEN"))
+        assertThat(request.headers["Authorization"], `is`("Bearer $MFA_TOKEN"))
 
         val body = bodyFromRequest<Any>(request)
         assertThat(body["authenticator_types"], `is`(listOf("oob")))
@@ -297,9 +298,9 @@ public class MfaApiClientTest {
         mfaClient.enroll(MfaEnrollmentType.Otp).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/mfa/associate"))
+        assertThat(request.target, `is`("/mfa/associate"))
         assertThat(request.method, `is`("POST"))
-        assertThat(request.getHeader("Authorization"), `is`("Bearer $MFA_TOKEN"))
+        assertThat(request.headers["Authorization"], `is`("Bearer $MFA_TOKEN"))
 
         val body = bodyFromRequest<Any>(request)
         assertThat(body["authenticator_types"], `is`(listOf("otp")))
@@ -342,9 +343,9 @@ public class MfaApiClientTest {
         mfaClient.enroll(MfaEnrollmentType.Push).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/mfa/associate"))
+        assertThat(request.target, `is`("/mfa/associate"))
         assertThat(request.method, `is`("POST"))
-        assertThat(request.getHeader("Authorization"), `is`("Bearer $MFA_TOKEN"))
+        assertThat(request.headers["Authorization"], `is`("Bearer $MFA_TOKEN"))
 
         val body = bodyFromRequest<Any>(request)
         assertThat(body["authenticator_types"], `is`(listOf("oob")))
@@ -390,7 +391,7 @@ public class MfaApiClientTest {
         mfaClient.challenge("sms|dev_123").await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/mfa/challenge"))
+        assertThat(request.target, `is`("/mfa/challenge"))
         assertThat(request.method, `is`("POST"))
 
         val body = bodyFromRequest<Any>(request)
@@ -442,7 +443,7 @@ public class MfaApiClientTest {
         mfaClient.verify(MfaVerificationType.Otp("123456")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/oauth/token"))
+        assertThat(request.target, `is`("/oauth/token"))
         assertThat(request.method, `is`("POST"))
 
         val body = bodyFromRequest<Any>(request)
@@ -517,7 +518,7 @@ public class MfaApiClientTest {
         mfaClient.verify(MfaVerificationType.Oob(oobCode = "oob_code_123", bindingCode = "654321")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/oauth/token"))
+        assertThat(request.target, `is`("/oauth/token"))
         assertThat(request.method, `is`("POST"))
 
         val body = bodyFromRequest<Any>(request)
@@ -580,7 +581,7 @@ public class MfaApiClientTest {
         mfaClient.verify(MfaVerificationType.RecoveryCode("RECOVERY_123")).await()
 
         val request = mockServer.takeRequest()
-        assertThat(request.path, `is`("/oauth/token"))
+        assertThat(request.target, `is`("/oauth/token"))
         assertThat(request.method, `is`("POST"))
 
         val body = bodyFromRequest<Any>(request)
diff --git a/auth0/src/test/java/com/auth0/android/management/UsersAPIClientTest.kt b/auth0/src/test/java/com/auth0/android/management/UsersAPIClientTest.kt
index 7c1d370e..06a11d4e 100755
--- a/auth0/src/test/java/com/auth0/android/management/UsersAPIClientTest.kt
+++ b/auth0/src/test/java/com/auth0/android/management/UsersAPIClientTest.kt
@@ -21,7 +21,7 @@ import com.google.gson.reflect.TypeToken
 import org.mockito.kotlin.*
 import kotlinx.coroutines.ExperimentalCoroutinesApi
 import kotlinx.coroutines.test.runTest
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.RecordedRequest
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers
 import org.hamcrest.Matchers.instanceOf
@@ -143,11 +143,11 @@ public class UsersAPIClientTest {
 
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_POST))
@@ -168,11 +168,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_POST))
@@ -194,11 +194,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_POST))
@@ -222,11 +222,11 @@ public class UsersAPIClientTest {
 
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities/$PROVIDER/$USER_ID_SECONDARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_DELETE))
@@ -247,11 +247,11 @@ public class UsersAPIClientTest {
 
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities/$PROVIDER/$USER_ID_SECONDARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_DELETE))
@@ -273,11 +273,11 @@ public class UsersAPIClientTest {
 
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY/identities/$PROVIDER/$USER_ID_SECONDARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_DELETE))
@@ -303,9 +303,9 @@ public class UsersAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY"))
+        assertThat(request.target, Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY"))
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_PATCH))
@@ -332,11 +332,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_PATCH))
@@ -361,11 +361,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(request.method, Matchers.equalTo(METHOD_PATCH))
@@ -384,11 +384,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(
@@ -407,11 +407,11 @@ public class UsersAPIClientTest {
         val request = mockAPI.takeRequest()
 
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY")
         )
         assertThat(
-            request.getHeader(HEADER_AUTHORIZATION),
+            request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY)
         )
         assertThat(
@@ -430,8 +430,8 @@ public class UsersAPIClientTest {
         ShadowLooper.idleMainLooper()
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY"))
-        assertThat(request.getHeader(HEADER_AUTHORIZATION),
+        assertThat(request.target, Matchers.equalTo("/api/v2/users/$USER_ID_PRIMARY"))
+        assertThat(request.headers[HEADER_AUTHORIZATION],
             Matchers.equalTo(BEARER + TOKEN_PRIMARY))
         assertThat(request.method, Matchers.equalTo(METHOD_GET))
         assertThat(
@@ -443,7 +443,7 @@ public class UsersAPIClientTest {
 
     private inline fun <reified T> bodyFromRequest(request: RecordedRequest): Map<String, T> {
         val mapType = object : TypeToken<Map<String, T>>() {}.type
-        return gson.fromJson(request.body.readUtf8(), mapType)
+        return gson.fromJson(request.body!!.utf8(), mapType)
     }
 
     private companion object {
diff --git a/auth0/src/test/java/com/auth0/android/myaccount/MyAccountAPIClientTest.kt b/auth0/src/test/java/com/auth0/android/myaccount/MyAccountAPIClientTest.kt
index 388530df..499cf1cd 100644
--- a/auth0/src/test/java/com/auth0/android/myaccount/MyAccountAPIClientTest.kt
+++ b/auth0/src/test/java/com/auth0/android/myaccount/MyAccountAPIClientTest.kt
@@ -18,7 +18,7 @@ import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import org.mockito.kotlin.mock
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.RecordedRequest
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers
 import org.junit.After
@@ -56,7 +56,7 @@ public class MyAccountAPIClientTest {
         client.passkeyEnrollmentChallenge()
             .start(callback)
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
     }
 
     @Test
@@ -92,7 +92,7 @@ public class MyAccountAPIClientTest {
             .start(callback)
 
         val request = mockAPI.takeRequest()
-        val header = request.getHeader("Authorization")
+        val header = request.headers["Authorization"]
 
         assertThat(
             header, Matchers.`is`(
@@ -147,7 +147,7 @@ public class MyAccountAPIClientTest {
         // Take and verify the request was sent correctly
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/me/v1/authentication-methods")
         )
         // Verify error details
@@ -175,7 +175,7 @@ public class MyAccountAPIClientTest {
         }
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/me/v1/authentication-methods")
         )
 
@@ -206,7 +206,7 @@ public class MyAccountAPIClientTest {
             .start(callback)
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/me/v1/authentication-methods/${AUTHENTICATION_ID}/verify")
         )
     }
@@ -248,7 +248,7 @@ public class MyAccountAPIClientTest {
             .start(callback)
 
         val request = mockAPI.takeRequest()
-        val header = request.getHeader("Authorization")
+        val header = request.headers["Authorization"]
 
         assertThat(
             header, Matchers.`is`(
@@ -299,7 +299,7 @@ public class MyAccountAPIClientTest {
         // Take and verify the request was sent correctly
         val request = mockAPI.takeRequest()
         assertThat(
-            request.path,
+            request.target,
             Matchers.equalTo("/me/v1/authentication-methods/${AUTHENTICATION_ID}/verify")
         )
         assertThat(error, Matchers.notNullValue())
@@ -318,8 +318,8 @@ public class MyAccountAPIClientTest {
         client.getFactors().start(callback)
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/me/v1/factors"))
-        assertThat(request.getHeader("Authorization"), Matchers.equalTo("Bearer $ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/factors"))
+        assertThat(request.headers["Authorization"], Matchers.equalTo("Bearer $ACCESS_TOKEN"))
         assertThat(request.method, Matchers.equalTo("GET"))
     }
 
@@ -329,8 +329,8 @@ public class MyAccountAPIClientTest {
         client.getAuthenticationMethods().start(callback)
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
-        assertThat(request.getHeader("Authorization"), Matchers.equalTo("Bearer $ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.headers["Authorization"], Matchers.equalTo("Bearer $ACCESS_TOKEN"))
         assertThat(request.method, Matchers.equalTo("GET"))
     }
 
@@ -341,8 +341,8 @@ public class MyAccountAPIClientTest {
         client.getAuthenticationMethodById(methodId).start(callback)
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods/email%7C12345"))
-        assertThat(request.getHeader("Authorization"), Matchers.equalTo("Bearer $ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods/email%7C12345"))
+        assertThat(request.headers["Authorization"], Matchers.equalTo("Bearer $ACCESS_TOKEN"))
         assertThat(request.method, Matchers.equalTo("GET"))
     }
 
@@ -353,8 +353,8 @@ public class MyAccountAPIClientTest {
         client.deleteAuthenticationMethod(methodId).start(callback)
 
         val request = mockAPI.takeRequest()
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods/email%7C12345"))
-        assertThat(request.getHeader("Authorization"), Matchers.equalTo("Bearer $ACCESS_TOKEN"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods/email%7C12345"))
+        assertThat(request.headers["Authorization"], Matchers.equalTo("Bearer $ACCESS_TOKEN"))
         assertThat(request.method, Matchers.equalTo("DELETE"))
     }
 
@@ -366,7 +366,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods/phone%7C12345"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods/phone%7C12345"))
         assertThat(request.method, Matchers.equalTo("PATCH"))
         assertThat(body, Matchers.hasEntry("preferred_authentication_method", "sms" as Any))
     }
@@ -380,7 +380,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods/totp%7C12345"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods/totp%7C12345"))
         assertThat(request.method, Matchers.equalTo("PATCH"))
         assertThat(body, Matchers.hasEntry("name", name as Any))
     }
@@ -393,7 +393,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("type", "email" as Any))
         assertThat(body, Matchers.hasEntry("email", email as Any))
@@ -407,7 +407,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("type", "phone" as Any))
         assertThat(body, Matchers.hasEntry("phone_number", phoneNumber as Any))
@@ -421,7 +421,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("type", "totp" as Any))
     }
@@ -434,7 +434,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("type", "recovery-code" as Any))
     }
@@ -449,7 +449,7 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods/email%7C123/verify"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods/email%7C123/verify"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("otp_code", otp as Any))
         assertThat(body, Matchers.hasEntry("auth_session", session as Any))
@@ -462,14 +462,14 @@ public class MyAccountAPIClientTest {
 
         val request = mockAPI.takeRequest()
         val body = bodyFromRequest<String>(request)
-        assertThat(request.path, Matchers.equalTo("/me/v1/authentication-methods"))
+        assertThat(request.target, Matchers.equalTo("/me/v1/authentication-methods"))
         assertThat(request.method, Matchers.equalTo("POST"))
         assertThat(body, Matchers.hasEntry("type", "push-notification" as Any))
     }
 
     private inline fun <reified T> bodyFromRequest(request: RecordedRequest): Map<String, T> {
         val mapType = object : TypeToken<Map<String, T>>() {}.type
-        return gson.fromJson(request.body.readUtf8(), mapType)
+        return gson.fromJson(request.body!!.utf8(), mapType)
     }
 
     private val auth0: Auth0
diff --git a/auth0/src/test/java/com/auth0/android/provider/WebAuthProviderTest.kt b/auth0/src/test/java/com/auth0/android/provider/WebAuthProviderTest.kt
index 9eea3b9e..ea097673 100644
--- a/auth0/src/test/java/com/auth0/android/provider/WebAuthProviderTest.kt
+++ b/auth0/src/test/java/com/auth0/android/provider/WebAuthProviderTest.kt
@@ -45,7 +45,6 @@ import org.hamcrest.core.IsNot.not
 import org.hamcrest.core.IsNull.notNullValue
 import org.junit.Assert
 import org.junit.Before
-import org.junit.Ignore
 import org.junit.Test
 import org.junit.runner.RunWith
 import org.mockito.ArgumentMatchers
@@ -57,6 +56,7 @@ import org.mockito.MockitoAnnotations
 import org.robolectric.Robolectric
 import org.robolectric.RobolectricTestRunner
 import org.robolectric.annotation.Config
+import org.robolectric.annotation.ConscryptMode
 import org.robolectric.shadows.ShadowLooper
 import java.io.ByteArrayInputStream
 import java.io.InputStream
@@ -1538,18 +1538,17 @@ public class WebAuthProviderTest {
     }
 
 
-    // TODO: https://auth0team.atlassian.net/browse/SDK-7752
+    @ConscryptMode(ConscryptMode.Mode.OFF)
     @Test
-    @Ignore("Fix these failing tests in CI once Roboelectric and other dependencies are updated")
     @Throws(Exception::class)
     public fun shouldFailToResumeLoginWhenRSAKeyIsMissingFromJWKSet() {
         val pkce = Mockito.mock(PKCE::class.java)
         `when`(pkce.codeChallenge).thenReturn("challenge")
-        val mockAPI = AuthenticationAPIMockServer()
-        mockAPI.willReturnEmptyJsonWebKeys()
+        val networkingClient: NetworkingClient = Mockito.spy(DefaultClient())
         val authCallback = mock<Callback<Credentials, AuthenticationException>>()
-        val proxyAccount: Auth0 = Auth0.getInstance(JwtTestUtils.EXPECTED_AUDIENCE, mockAPI.domain)
-        proxyAccount.networkingClient = SSLTestUtils.testClient
+        val proxyAccount =
+            Auth0.getInstance(JwtTestUtils.EXPECTED_AUDIENCE, JwtTestUtils.EXPECTED_BASE_DOMAIN)
+        proxyAccount.networkingClient = networkingClient
         login(proxyAccount)
             .withState("1234567890")
             .withNonce(JwtTestUtils.EXPECTED_NONCE)
@@ -1586,8 +1585,15 @@ public class WebAuthProviderTest {
             callbackCaptor.firstValue.onSuccess(codeCredentials)
             null
         }.`when`(pkce).getToken(eq("1234"), callbackCaptor.capture())
+        // Mock JWKS response with empty keys (no matching RSA key for kid)
+        val emptyJwksJson = """{"keys": []}"""
+        val jwksInputStream: InputStream = ByteArrayInputStream(emptyJwksJson.toByteArray())
+        val jwksResponse = ServerResponse(200, jwksInputStream, emptyMap())
+        Mockito.doReturn(jwksResponse).`when`(networkingClient).load(
+            eq(proxyAccount.getDomainUrl() + ".well-known/jwks.json"),
+            any()
+        )
         Assert.assertTrue(resume(intent))
-        mockAPI.takeRequest()
         ShadowLooper.idleMainLooper()
         verify(authCallback).onFailure(authExceptionCaptor.capture())
         val error = authExceptionCaptor.firstValue
@@ -1603,7 +1609,6 @@ public class WebAuthProviderTest {
             error.cause?.message,
             `is`("Could not find a public key for kid \"key123\"")
         )
-        mockAPI.shutdown()
     }
 
     @Test
@@ -1673,18 +1678,17 @@ public class WebAuthProviderTest {
     }
 
 
-    //TODO: https://auth0team.atlassian.net/browse/SDK-7752
+    @ConscryptMode(ConscryptMode.Mode.OFF)
     @Test
-    @Ignore("Fix these failing tests in CI once Roboelectric and other dependencies are updated")
     @Throws(Exception::class)
     public fun shouldFailToResumeLoginWhenKeyIdIsMissingFromIdTokenHeader() {
         val pkce = Mockito.mock(PKCE::class.java)
         `when`(pkce.codeChallenge).thenReturn("challenge")
-        val mockAPI = AuthenticationAPIMockServer()
-        mockAPI.willReturnValidJsonWebKeys()
+        val networkingClient: NetworkingClient = Mockito.spy(DefaultClient())
         val authCallback = mock<Callback<Credentials, AuthenticationException>>()
-        val proxyAccount: Auth0 = Auth0.getInstance(JwtTestUtils.EXPECTED_AUDIENCE, mockAPI.domain)
-        proxyAccount.networkingClient = SSLTestUtils.testClient
+        val proxyAccount =
+            Auth0.getInstance(JwtTestUtils.EXPECTED_AUDIENCE, JwtTestUtils.EXPECTED_BASE_DOMAIN)
+        proxyAccount.networkingClient = networkingClient
         login(proxyAccount)
             .withState("1234567890")
             .withNonce("abcdefg")
@@ -1720,8 +1724,15 @@ public class WebAuthProviderTest {
             callbackCaptor.firstValue.onSuccess(codeCredentials)
             null
         }.`when`(pkce).getToken(eq("1234"), callbackCaptor.capture())
+        // Mock JWKS response with valid keys
+        val encoded = Files.readAllBytes(Paths.get("src/test/resources/rsa_jwks.json"))
+        val jwksInputStream: InputStream = ByteArrayInputStream(encoded)
+        val jwksResponse = ServerResponse(200, jwksInputStream, emptyMap())
+        Mockito.doReturn(jwksResponse).`when`(networkingClient).load(
+            eq(proxyAccount.getDomainUrl() + ".well-known/jwks.json"),
+            any()
+        )
         Assert.assertTrue(resume(intent))
-        mockAPI.takeRequest()
         ShadowLooper.idleMainLooper()
         verify(authCallback).onFailure(authExceptionCaptor.capture())
         val error = authExceptionCaptor.firstValue
@@ -1737,7 +1748,6 @@ public class WebAuthProviderTest {
             error.cause?.message,
             `is`("Could not find a public key for kid \"null\"")
         )
-        mockAPI.shutdown()
     }
 
     @Test
diff --git a/auth0/src/test/java/com/auth0/android/request/DefaultClientTest.kt b/auth0/src/test/java/com/auth0/android/request/DefaultClientTest.kt
index 7a71a70b..b02755f1 100644
--- a/auth0/src/test/java/com/auth0/android/request/DefaultClientTest.kt
+++ b/auth0/src/test/java/com/auth0/android/request/DefaultClientTest.kt
@@ -6,9 +6,9 @@ import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
 import okhttp3.Interceptor
 import okhttp3.logging.HttpLoggingInterceptor
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.MockResponse
+import mockwebserver3.MockWebServer
+import mockwebserver3.RecordedRequest
 import org.hamcrest.CoreMatchers.*
 import org.hamcrest.MatcherAssert.assertThat
 import org.hamcrest.Matchers.empty
@@ -51,7 +51,7 @@ public class DefaultClientTest {
 
     @After
     public fun tearDown() {
-        mockServer.shutdown()
+        mockServer.close()
     }
 
     @Test
@@ -274,7 +274,7 @@ public class DefaultClientTest {
         method: HttpMethod,
         headers: Map<String, String> = mapOf("a-header" to "b-value")
     ) {
-        val requestUri = Uri.parse(request.path)
+        val requestUri = Uri.parse(request.target)
         when (method) {
             HttpMethod.GET -> assertThat(request.method, equalTo("GET"))
             HttpMethod.POST -> assertThat(request.method, equalTo("POST"))
@@ -331,10 +331,11 @@ public class DefaultClientTest {
     }
 
     private fun enqueueMockResponse(responseCode: Int = STATUS_SUCCESS, jsonBody: String) {
-        val response = MockResponse()
-        response.setBody(jsonBody)
-        response.setResponseCode(responseCode)
-        response.setHeader("content-type", "application/json")
+        val response = MockResponse.Builder()
+            .body(jsonBody)
+            .code(responseCode)
+            .setHeader("content-type", "application/json")
+            .build()
         mockServer.enqueue(response)
     }
 
@@ -344,7 +345,7 @@ public class DefaultClientTest {
             .collect(Collectors.joining("\n"))
 
     private fun RecordedRequest.bodyFromJson(): Map<String, Any> {
-        val text = this.body.readUtf8()
+        val text = this.body?.utf8() ?: ""
         if (text.isEmpty()) {
             return emptyMap()
         }
diff --git a/auth0/src/test/java/com/auth0/android/request/internal/ThreadSwitcherShadow.java b/auth0/src/test/java/com/auth0/android/request/internal/ThreadSwitcherShadow.java
index 0c096ba3..17100bf9 100644
--- a/auth0/src/test/java/com/auth0/android/request/internal/ThreadSwitcherShadow.java
+++ b/auth0/src/test/java/com/auth0/android/request/internal/ThreadSwitcherShadow.java
@@ -26,4 +26,9 @@ public ThreadSwitcherShadow() {
     public void backgroundThread(Runnable runnable) {
         executor.execute(runnable);
     }
+
+    @Implementation
+    public void mainThread(Runnable runnable) {
+        executor.execute(runnable);
+    }
 }
diff --git a/auth0/src/test/java/com/auth0/android/util/APIMockServer.kt b/auth0/src/test/java/com/auth0/android/util/APIMockServer.kt
index de8ddd30..23f808e3 100644
--- a/auth0/src/test/java/com/auth0/android/util/APIMockServer.kt
+++ b/auth0/src/test/java/com/auth0/android/util/APIMockServer.kt
@@ -1,8 +1,8 @@
 package com.auth0.android.util
 
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import okhttp3.mockwebserver.RecordedRequest
+import mockwebserver3.MockResponse
+import mockwebserver3.MockWebServer
+import mockwebserver3.RecordedRequest
 import java.io.IOException
 
 internal abstract class APIMockServer {
@@ -12,7 +12,7 @@ internal abstract class APIMockServer {
 
     @Throws(IOException::class)
     fun shutdown() {
-        server.shutdown()
+        server.close()
     }
 
     @Throws(InterruptedException::class)
@@ -21,22 +21,23 @@ internal abstract class APIMockServer {
     }
 
     fun responseWithJSON(json: String, statusCode: Int): MockResponse {
-        return MockResponse()
-            .setResponseCode(statusCode)
+        return MockResponse.Builder()
+            .code(statusCode)
             .addHeader("Content-Type", "application/json")
-            .setBody(json)
+            .body(json)
+            .build()
     }
 
     fun responseWithJSON(json: String, statusCode: Int, header: Map<String, String>): MockResponse {
-        val response = MockResponse()
-            .setResponseCode(statusCode)
+        val builder = MockResponse.Builder()
+            .code(statusCode)
             .addHeader("Content-Type", "application/json")
-            .setBody(json)
+            .body(json)
 
         header.forEach { (key, value) ->
-            response.addHeader(key, value)
+            builder.addHeader(key, value)
         }
-        return response
+        return builder.build()
     }
 
     init {
diff --git a/auth0/src/test/java/com/auth0/android/util/AuthenticationAPIMockServer.kt b/auth0/src/test/java/com/auth0/android/util/AuthenticationAPIMockServer.kt
index e08361e5..10375ec9 100755
--- a/auth0/src/test/java/com/auth0/android/util/AuthenticationAPIMockServer.kt
+++ b/auth0/src/test/java/com/auth0/android/util/AuthenticationAPIMockServer.kt
@@ -1,6 +1,6 @@
 package com.auth0.android.util
 
-import okhttp3.mockwebserver.MockResponse
+import mockwebserver3.MockResponse
 import java.nio.file.Files
 import java.nio.file.Paths
 
@@ -189,15 +189,17 @@ internal class AuthenticationAPIMockServer : APIMockServer() {
     }
 
     private fun responseEmpty(statusCode: Int): MockResponse {
-        return MockResponse()
-            .setResponseCode(statusCode)
+        return MockResponse.Builder()
+            .code(statusCode)
+            .build()
     }
 
     private fun responseWithPlainText(statusMessage: String, statusCode: Int): MockResponse {
-        return MockResponse()
-            .setResponseCode(statusCode)
+        return MockResponse.Builder()
+            .code(statusCode)
             .addHeader("Content-Type", "text/plain")
-            .setBody(statusMessage)
+            .body(statusMessage)
+            .build()
     }
 
     companion object {
diff --git a/auth0/src/test/java/com/auth0/android/util/SSLTestUtils.kt b/auth0/src/test/java/com/auth0/android/util/SSLTestUtils.kt
index 542a8e4b..61730129 100644
--- a/auth0/src/test/java/com/auth0/android/util/SSLTestUtils.kt
+++ b/auth0/src/test/java/com/auth0/android/util/SSLTestUtils.kt
@@ -2,7 +2,7 @@ package com.auth0.android.util
 
 import com.auth0.android.request.DefaultClient
 import com.auth0.android.request.internal.GsonProvider
-import okhttp3.mockwebserver.MockWebServer
+import mockwebserver3.MockWebServer
 import okhttp3.tls.HandshakeCertificates
 import okhttp3.tls.HeldCertificate
 import java.net.InetAddress
@@ -44,7 +44,7 @@ internal object SSLTestUtils {
 
     fun createMockWebServer(): MockWebServer {
         val mockServer = MockWebServer()
-        mockServer.useHttps(serverCertificates.sslSocketFactory(), false)
+        mockServer.useHttps(serverCertificates.sslSocketFactory())
         return mockServer
     }
 }
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 7f94c35e..d0139700 100644
--- a/build.gradle
+++ b/build.gradle
@@ -1,6 +1,6 @@
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 buildscript {
-    ext.kotlin_version = "2.0.21"
+    ext.kotlin_version = "2.2.0"
     repositories {
         google()
         mavenCentral()