Summary  
This chapter explains how to use asyncio.run() as the single entry point to execute coroutines by automatically managing the event loop—creating it, running the top-level async function to completion, and closing it—and stresses structuring async code with a main coroutine and using await instead of calling asyncio.run inside another coroutine.  

General domain of usage  
Asynchronous HTTP requests

This video walks you through how to use `asyncio.run()` to execute coroutines in Python. You'll see how `asyncio.run()` starts and manages the event loop, why it should only be called once at the top level of your script, and what happens if you try to use it inside another coroutine. The video also covers the recommended structure for asyncio programs: defining a `main()` coroutine and using `asyncio.run(main())` as your entry point. Visual examples illustrate correct and incorrect usage, helping you avoid common pitfalls and write clean, reliable async code.

A coroutine defined with `async def` does nothing on its own. To actually execute it, you need an entry point – a way to start the event loop and hand it the coroutine. That entry point is `asyncio.run()`.

## What `asyncio.run()` Does

`asyncio.run(coroutine)` does three things in sequence:

- creates a new event loop;
- runs the given coroutine until it completes;
- closes the loop and cleans up resources.

It is the standard way to run the top-level coroutine in any asyncio program.


import asyncio
import httpx
import nest_asyncio

nest_asyncio.apply()

# Fetching the number of posts from a public API
async def count_posts():
    async with httpx.AsyncClient() as client:
        response = await client.get("https://jsonplaceholder.typicode.com/posts")
        posts = response.json()
        print(f"Total posts: {len(posts)}")

asyncio.run(count_posts())  # Starting the event loop

In a regular `.py` script there is no pre-existing event loop, so `asyncio.run()` works without any patches. The `import nest_asyncio` and `nest_asyncio.apply()` lines that appear throughout this course are only needed on this platform. You can safely remove them when running code locally.


Note

## One Entry Point Per Program

`asyncio.run()` is designed to be called **once** – at the top level of your script. Calling it from inside a running event loop raises a `RuntimeError`.



import asyncio
import nest_asyncio

nest_asyncio.apply()

async def inner():
    print("Inner coroutine")

async def outer():
    asyncio.run(inner())  # RuntimeError: cannot be called from a running event loop

asyncio.run(outer())

To call one coroutine from another, use `await` – not `asyncio.run()`:

import asyncio
import nest_asyncio

nest_asyncio.apply()

async def inner():
    print("Inner coroutine")

async def outer():
    await inner()  # Correct way to call a coroutine from another coroutine

asyncio.run(outer())

## Structuring an Asyncio Program

The standard pattern for any asyncio script is to define a `main()` coroutine as the program's entry point and pass it to `asyncio.run()`:


import asyncio
import httpx
import nest_asyncio

nest_asyncio.apply()

# Fetching titles of the first three posts
async def fetch_title(client, post_id):
    url = f"https://jsonplaceholder.typicode.com/posts/{post_id}"
    response = await client.get(url)
    data = response.json()
    return data["title"]

async def main():
    async with httpx.AsyncClient() as client:
        for post_id in range(1, 4):
            title = await fetch_title(client, post_id)
            print(f"Post {post_id}: {title}")

asyncio.run(main())

All async logic lives inside `main()`. `asyncio.run()` only appears once, at the bottom of the file.

Where should `asyncio.run()` be called in a typical asyncio program?

Master the skills needed to build efficient, concurrent Python applications using asyncio – from coroutines and event loop fundamentals through tasks, synchronization primitives, and real-world debugging techniques.

Gain a solid understanding of asynchronous programming concepts and the core mechanisms behind Python's asyncio library.

Dive into asyncio's task scheduling mechanisms and learn how to run multiple coroutines concurrently.

Get hands-on experience with HTTP clients, synchronization primitives, and queue-based pipelines using asyncio.

Explore advanced asyncio features for controlling task groups, running blocking code, and debugging asynchronous applications.

Running Coroutines with asyncio.run()

What asyncio.run() Does

One Entry Point Per Program

Structuring an Asyncio Program

What `asyncio.run()` Does