Exploring Ktor: A Modern Networking Framework for Kotlin

Source: Dev.to

Ktor is an asynchronous networking framework developed by JetBrains, designed for building both server and client applications in Kotlin. While Retrofit has long been the go‑to standard for Android networking, many developers see Ktor as the future of Kotlin‑first networking.

The choice between Ktor and Retrofit ultimately depends on project requirements, scope, and developer preference. Below is a practical guide to setting up and using Ktor in an Android project.

Project Setup and Dependencies

Add Ktor and Serialization Plugins

In the root build.gradle.kts file, apply the Kotlin Serialization plugin:

plugins {
    id("org.jetbrains.kotlin.plugin.serialization") version "2.1.20"
}

Add Ktor Dependencies

In the app‑level build.gradle.kts, include the required Ktor libraries:

plugins {
    id("kotlinx-serialization")
}

dependencies {
    implementation(platform("io.ktor:ktor-bom:3.1.2"))
    implementation("io.ktor:ktor-client-android")
    implementation("io.ktor:ktor-client-serialization")
    implementation("io.ktor:ktor-client-logging")
    implementation("io.ktor:ktor-client-content-negotiation")
    implementation("io.ktor:ktor-serialization-kotlinx-json")
}

Creating a Reusable HttpClient

Benefits of a Reusable Client

• Persistent Connections – Keeps connections alive, reducing latency for subsequent requests.
• Kotlin Multiplatform Compatibility – Share networking logic across Android, iOS, and other targets.
• Resource Management – Simplifies cleanup (e.g., client.close()) and prevents leaks.

Example of Creating a Client Instance

private const val NETWORK_TIME_OUT = 15_000

val httpClient = HttpClient(Android) {
    install(ContentNegotiation) {
        json(Json {
            prettyPrint = true
            isLenient = true
            ignoreUnknownKeys = true
        })
    }
    install(HttpTimeout) {
        requestTimeoutMillis = NETWORK_TIME_OUT
        connectTimeoutMillis = NETWORK_TIME_OUT
        socketTimeoutMillis = NETWORK_TIME_OUT
    }
    install(Logging) {
        logger = object : Logger {
            override fun log(message: String) {
                Log.v("KtorLogger", message)
            }
        }
        level = LogLevel.ALL
    }
    install(DefaultRequest) {
        header(HttpHeaders.ContentType, ContentType.Application.Json)
    }
    defaultRequest {
        contentType(ContentType.Application.Json)
        accept(ContentType.Application.Json)
    }
}

Making Requests with Ktor

Example: GET Request

suspend fun fetchLocationsList(): User = httpClient.get("https://api.example.com/locations/123").body()

Example: POST Request

suspend fun createLocationList(location: Location): HttpResponse = httpClient.post("https://api.example.com/locations") {
    contentType(ContentType.Application.Json)
    setBody(location)
}

Creating Data Models

@Serializable
data class Location(
    val locationId: Int,
    val locationName: String,
    val locationLatLong: String
)

Note: The serialization plugin is already added in the app‑level build.gradle.kts.

Logging and Debugging

Ktor’s built‑in logging feature lets you monitor requests and responses in Logcat. It integrates smoothly with DI frameworks such as Koin or Hilt, and you can pair it with logging libraries like Timber or Klogging for richer output.

Final Thoughts

Retrofit remains a solid, reliable choice for traditional Android apps, while Ktor shines in modern, Kotlin‑first and multiplatform environments. The steps above should help you get started quickly with Ktor. Future articles will explore deeper integration with dependency injection (Koin) and advanced logging using Timber.

Give Ktor a try and experience the flexibility of Kotlin‑first development.