Python Asyncio - making a second call based on the first call's response

I am trying to develop a system in which I can send a large number of requests to an API and capture which ones were successfully sent. I want to use asyncio to send these requests quickly and follow up with a second call to a different API if the first one was successful. How can I do this without having to wait for all the first API calls to be made before making the second ones? I.e. as soon as the first call has a response, call the second API?

import asyncio
import aiottp


def get_tasks(session, url, payload):
    tasks = []
    for p in payload:
        response = session.get(url, params=payload))
        tasks.append(response)
        
        # What I need: if response.status == 200: do something
    return tasks


async def main():
    url = "foo"
    payload = ['{"a": 1}', '{"b": 2}']
    
    async with aiottp.ClientSession() as session:
        tasks = get_tasks(session, url, payload)
        responses = await asyncio.gather(*tasks)

if __name__ == "__main__":
     asyncio.run(main())

The easier thing to do is to pack the calls that are related, and have to happen in sequence, in a small async function, and then create tasks out of this function, instead of creating tasks with each call taking place solo.

async def atomic_task(session, url, payload):
    response = await session.get(url, params=payload))
        
    if response.status == 200:
        # do something
        ... # use `await` at will

def get_tasks(session, url, payload):
    tasks = []
    for p in payload:
        tasks.append(atomic_task(session, url, params=payload)

    return tasks

Another way is to add the second call as a "done callback" of each task:

extra_tasks = set()

def task_done(task):
    response = task.result()
    if response.status == 200:
         # do stuff. But this is a sync function:  can't use await.
         # if there are async things to be done, you can create a task here, and add them to a registry to be awaited somewhere else:

         new_task = asyncio.create_task(...)
         extra_tasks.add(new_task)

def get_tasks(session, url, payload):
    tasks = []
    for p in payload:
        task = session.get(url, params=payload))
        task.add_done_callback(task_done)
        tasks.append(task)


async def main():
    url = "foo"
    payload = ['{"a": 1}', '{"b": 2}']
    
    async with aiottp.ClientSession() as session:
        tasks = get_tasks(session, url, payload)
        responses = await asyncio.gather(*tasks)
        await asyncio.gather(*extra_tasks)

Note that the first option, inlining the sequencial operations in a co-routine, is the recommended way, and also simpler - with callback code being somewhat of a "hack". Butit works: the fact we await for the "extra_tasks" just after the initial tasks are awaited, does not mean they will be executed only after all those finish: they will start to run as soon as they are created, in the callback - the extra gather on the last line will just ensure the program does not terminate until all of the new tasks are also done.