Verify emails in Kotlin with Verifly

Coroutine-friendly email verification

Email verification is a network round-trip, which in Kotlin means it belongs inside a suspend function, off the main thread. A regex or a syntactic check only tells you user@dead-domain.com is well-formed; it cannot tell you the mailbox bounces. That answer lives behind an SMTP handshake, and Verifly performs it for you over one HTTPS request you can await from any coroutine.

Two idiomatic clients fit. Ktor's HttpClient is coroutine-native — a get call is already a suspend function, and with the ContentNegotiation plugin and kotlinx.serialization it deserializes the JSON straight into a @Serializable data class. Alternatively, OkHttp with its coroutine-friendly await extension works well, especially on Android where OkHttp is already on the classpath. Either way the response carries a result field of deliverable, undeliverable, or risky plus boolean flags for disposable, role, catch_all, and smtp.

Do not embed the Bearer key in an Android APK — treat it as a server-side secret and proxy verification through your own backend, which is where Ktor server routes shine. Pricing is pay-as-you-go from $2 per 1,000 checks down to $0.60 per 1,000 at volume, and you can self-register for 100 free credits with no card at the autonomous register endpoint.

The same call with OkHttp coroutines

If you already depend on OkHttp, you do not need to add Ktor. OkHttp's Call exposes an await() suspend extension, so a verification becomes a clean suspend function on Dispatchers.IO. Parse the JSON with kotlinx.serialization and branch on the result field. Reuse a single OkHttpClient across your app — it is designed to be shared and pools connections.

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlinx.serialization.json.Json
import kotlinx.serialization.json.jsonPrimitive
import kotlinx.serialization.json.jsonObject
import okhttp3.*
import java.io.IOException
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException

val http = OkHttpClient()

suspend fun Call.await(): Response = suspendCancellableCoroutine { cont ->
    enqueue(object : Callback {
        override fun onFailure(call: Call, e: IOException) = cont.resumeWithException(e)
        override fun onResponse(call: Call, response: Response) = cont.resume(response)
    })
    cont.invokeOnCancellation { cancel() }
}

suspend fun isDeliverable(email: String): Boolean = withContext(Dispatchers.IO) {
    val req = Request.Builder()
        .url("https://verifly.email/api/v1/verify?email=$email")
        .header("Authorization", "Bearer vf_YOUR_KEY")
        .build()
    http.newCall(req).await().use { resp ->
        val obj = Json.parseToJsonElement(resp.body!!.string()).jsonObject
        obj["result"]?.jsonPrimitive?.content == "deliverable"
    }
}

Batch-verify a list with Ktor

For cleaning many addresses, do not fire the single endpoint in a loop — POST them together to /api/v1/verify/batch. It accepts a JSON body with an emails array and returns a results array in the same order, which deserializes into a list of @Serializable items. Filter the list down to deliverable, non-disposable addresses with a standard Kotlin filter/map.

import io.ktor.client.request.*
import io.ktor.http.*
import kotlinx.serialization.Serializable

@Serializable
data class Item(val email: String, val result: String, val disposable: Boolean = false)

@Serializable
data class Batch(val results: List<Item>)

@Serializable
data class BatchRequest(val emails: List<String>)

suspend fun cleanList(client: HttpClient, emails: List<String>): List<String> {
    val batch: Batch = client.post("https://verifly.email/api/v1/verify/batch") {
        header("Authorization", "Bearer vf_YOUR_KEY")
        contentType(ContentType.Application.Json)
        setBody(BatchRequest(emails))
    }.body()

    return batch.results
        .filter { it.result == "deliverable" && !it.disposable }
        .map { it.email }
}