How to call apis with Kotlin coroutines in chain

I am quite new to kotlin world and coroutines.
I am trying to send API request with webClient. But it should be in order because the second API call depends of data as param from the first API call. And as end result I want to save the first API call to variable and then modify its property with result from second call so I can return it to the client.

I did this approach and would like to know if this is the correct way and if there is better way. The code itself seems somehow to work as result. I did look many blog posts and watched few hours videos about coroutines however I am struggling to understand them.

Here is the code:

suspend fun firstApiCall(): FirstApiCall {
    return try {
        myClient.get()
            .uri(uri)
            .header(TENANT_HEADER, httpProperties.tenantId)
            .retrieve()
            .bodyToMono<FirstApiCall>()
            .awaitSingle()
    } catch (ex: Exception) {
        throw Exception("fail")
    }


suspend fun secondtApiCall(paramOne:String): SecondtApiCall {
    return try {
        myClient.get()
            .uri(uri)
            .header(TENANT_HEADER, httpProperties.tenantId)
            .retrieve()
            .bodyToMono<SecondtApiCall>()
            .awaitSingle()
    } catch (ex: Exception) {
        throw Exception("fail")
    }



suspend fun doApiCalls(
): SomeThing {


    val first = CoroutineScope(TenantDispatcher.IO).async {
        firstApicall()
    }.await()


    val second = CoroutineScope(TenantDispatcher.IO).async {
        secondApiCall(first.parameter)
    }.await()

  first.something = second.name

   return first
}

I also tried the usual without adding async as:

    val first = firstApicall(id)
    val second = secondApiCall(first.parameter)

But this one was slower with few seconds

You have a few anti patterns here.

• Creating new CoroutineScopes inside a suspend function. A new scope is for running new base-level coroutines. You almost never have a reason to do this in a suspend function. Since a suspend function is only called from within a coroutine, it should usually not be spinning off new coroutines that are not its own children. When you need a scope to launch child coroutines in a suspend function, you can use the coroutineScope { } or withContext functions to create a local one.
• Creating new CoroutineScope without storing it in a variable and cancelling it when its lifetime should be over. This creates memory and resource leaks.
• Calling async immediately followed by await. This accomplishes nothing.
• Using Dispatchers.IO to call a suspend function. Dispatchers.IO is for calling blocking functions, not suspend functions, even suspend functions that do IO. But this does rely on those suspend functions not doing blocking work, which is convention. Your suspend functions correctly do no blocking work. They are just setting up a network call and executing it with a suspend function.

To call suspend functions in sequence, you just call them in sequence!

suspend fun doApiCalls(
): SomeThing {
    val first = firstApicall()

    val second = secondApiCall(first.parameter)

    first.something = second.name

    return first
}

This should not run slower than the wrong way you were doing it. I don’t think we have enough detail to know why you might have encountered that.