OkHttp Interceptors: Supercharge Networking Libraries in Your Android Toolkit

Networking on Android has come a long way. Retrofit, Ktor, and even raw HttpURLConnection all have their place, but at the heart of many popular libraries sits one workhorse: OkHttp. If you’ve ever used Retrofit, chances are you’ve been using OkHttp under the hood without realizing it.

Here’s the catch: most Android developers use OkHttp just for its default client. But the real power of OkHttp isn’t in firing off API calls — it’s in its interceptors. With interceptors, you can transparently handle authentication, retries, logging, caching, and even build your own observability layer without rewriting networking code.

This post is your guide to making OkHttp interceptors a first-class citizen in your Android toolkit.

Why OkHttp is the Default HTTP Client for Android

At this point, OkHttp has become the de facto HTTP client for Android. It’s lightweight, efficient, and fully HTTP/2 and WebSocket compliant. More importantly, it integrates seamlessly with Retrofit and other higher-level libraries.

But out of the box, it only gives you the basics: open a connection, send a request, get a response. Interceptors unlock the advanced use cases every production app needs.

Think of them as middleware for your network layer. Requests go in, responses come out — and interceptors can inspect, modify, or replace both.

Types of OkHttp Interceptors

OkHttp offers two kinds of interceptors:

Application Interceptors

Added with OkHttpClient.Builder().addInterceptor().

Run once for every request.

Great for auth headers, retries, request modification.

Network Interceptors

Added with OkHttpClient.Builder().addNetworkInterceptor().

Run only when a request actually hits the network.

Useful for caching and monitoring raw data.

Understanding which type to use is key: application interceptors are more flexible, but network interceptors let you deal with lower-level details.

Practical Use Cases for Interceptors

Let’s explore a few real-world scenarios where interceptors shine.

1. Adding Authentication Headers

Tired of manually attaching tokens to every request? An interceptor does it globally:

class AuthInterceptor(
    private val tokenProvider: () -> String
) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val newRequest = chain.request().newBuilder()
            .addHeader("Authorization", "Bearer ${tokenProvider()}")
            .build()
        return chain.proceed(newRequest)
    }
}

Usage:

val client = OkHttpClient.Builder()
    .addInterceptor(AuthInterceptor { getAuthToken() })
    .build()

Now every API call is authenticated automatically.

2. Retrying Failed Requests

Flaky network? Instead of bubbling errors up immediately, you can retry safely:

class RetryInterceptor(
    private val maxRetries: Int = 3
) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        var attempt = 0
        var response: Response
        var exception: IOException? = null

````````do {
            try {
                response = chain.proceed(chain.request())
                return response
            } catch (e: IOException) {
                exception = e
                attempt++
            }
        } while (attempt < maxRetries)
        throw exception ?: IOException("Unknown network error")
    }
}

This ensures your users don’t see an error screen just because Wi-Fi flickered for half a second.

3. Caching Responses for Offline Mode

OkHttp already has a powerful cache system, but pairing it with an interceptor gives you control:

class OfflineCacheInterceptor(
    private val context: Context
) : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        var request = chain.request()
        if (!isNetworkAvailable(context)) {
            request = request.newBuilder()
                .header("Cache-Control", "public, only-if-cached, max-stale=2419200")
                .build()
        }
        return chain.proceed(request)
    }

private fun isNetworkAvailable(context: Context): Boolean {
        // Implement using ConnectivityManager
        return true
    }
}

And then configure a cache:

val cacheSize = 10L * 1024 * 1024 // 10 MB
val cache = Cache(File(context.cacheDir, "http_cache"), cacheSize)

val client = OkHttpClient.Builder()
    .cache(cache)
    .addInterceptor(OfflineCacheInterceptor(context))
    .build()

Suddenly, your app gracefully supports offline reads.

4. Logging and Metrics

Debugging network calls is painful without visibility. Instead of sprinkling logs everywhere, add one clean interceptor:

class MetricsInterceptor : Interceptor {
    override fun intercept(chain: Interceptor.Chain): Response {
        val start = System.nanoTime()
        val request = chain.request()
        val response = chain.proceed(request)
        val end = System.nanoTime()

````````val durationMs = (end - start) / 1e6
        Log.d("Metrics", "${request.url} took ${durationMs}ms")
        return response
    }
}

Now you’ve got built-in timing metrics for every call. Pair it with analytics to track API health.

Bringing It All Together

Here’s what a production-ready OkHttp client might look like:

val client = OkHttpClient.Builder()
    .addInterceptor(AuthInterceptor { getAuthToken() })
    .addInterceptor(RetryInterceptor(3))
    .addInterceptor(MetricsInterceptor())
    .addNetworkInterceptor(OfflineCacheInterceptor(context))
    .cache(Cache(File(context.cacheDir, "http_cache"), 10L * 1024 * 1024))
    .build()

From one central place, your networking stack now supports auth, retries, metrics, caching, and offline resilience.

Conclusion

OkHttp isn’t just another HTTP client — it’s the foundation of modern Android networking. By embracing interceptors, you move from “just making API calls” to owning the networking layer: you control reliability, observability, and user experience.

The next time you’re building an Android app, don’t just plug in Retrofit and call it a day. Reach for OkHttp interceptors and build a network layer that’s battle-tested, observable, and future-proof.