Skip to main content

How to Resolve Python "DeprecationWarning: There is no current event loop" and "RuntimeError: no running event loop in Python" Errors in asyncio library

When working with Python's asyncio library for asynchronous programming, you might encounter errors like DeprecationWarning: There is no current event loop or RuntimeError: no running event loop. These errors typically occur when you try to interact with the event loop (e.g., get it, create tasks on it) at a time when no loop is explicitly set or running in the current thread, especially with changes introduced in recent Python versions (3.10+).

This guide explains the common causes of these errors and provides the standard solutions using asyncio.run() or manual loop management.

Understanding the Error: asyncio Event Loops​

asyncio uses an event loop to manage and execute asynchronous tasks (coroutines). The event loop waits for events (like I/O completion) and runs the appropriate code when an event occurs. Certain asyncio functions need to interact with this loop:

  • asyncio.get_event_loop(): (Older approach) Tries to get the current loop for the thread. If none is set, it used to create one automatically (now deprecated/error).
  • asyncio.get_running_loop(): Gets the loop currently running in the thread. Raises RuntimeError if none is running.
  • asyncio.create_task(): Schedules a coroutine to run on the currently running loop.

The errors occur when these functions are called in a context where the required loop isn't available or running as expected.

Error 1: DeprecationWarning: There is no current event loop / RuntimeError (Getting the Loop)​

Cause: Calling get_event_loop() or get_running_loop() Improperly​

  • asyncio.get_event_loop(): Before Python 3.10, if no loop was set for the current thread, this function would automatically create a new one. Starting in 3.10, this behavior is deprecated (showing the DeprecationWarning), and in Python 3.12+, it raises a RuntimeError. You should no longer rely on its automatic creation behavior.
  • asyncio.get_running_loop(): This function specifically requires an event loop to be already running in the current thread. Calling it when no loop is running directly causes a RuntimeError.
import asyncio

# --- Error Scenario: DeprecationWarning/RuntimeError with get_event_loop ---
try:
    # ⛔️ DeprecationWarning (Python 3.10+) or RuntimeError (Python 3.12+)
    # No loop is set or running yet in this main thread context.
    loop1 = asyncio.get_event_loop()
    print(f"Loop from get_event_loop: {loop1}")
except RuntimeError as e:
    print(f"RuntimeError from get_event_loop: {e}") # Expected in 3.12+


# --- Error Scenario: RuntimeError with get_running_loop ---
try:
    # ⛔️ RuntimeError: no running event loop
    # No loop is running at this point.
    loop2 = asyncio.get_running_loop()
    print(f"Loop from get_running_loop: {loop2}")
except RuntimeError as e:
    print(f"RuntimeError from get_running_loop: {e}")

Solution 1: Use asyncio.run() (High-Level Approach - Recommended)​

The simplest and recommended way to run an async function (coroutine) is using asyncio.run(). This function automatically handles creating/getting the loop, running your main coroutine until it completes, and performing necessary cleanup. You typically don't need to get the loop manually when using asyncio.run().

import asyncio

async def my_main_coroutine():
  print("Inside main coroutine...")
  # You can get the *running* loop here if needed, but often unnecessary
  loop = asyncio.get_running_loop()
  print(f"Running loop inside async func: {loop}")
  await asyncio.sleep(0.1)
  print("Coroutine finished.")

# ✅ Use asyncio.run() to execute the main entry point coroutine
print("Running via asyncio.run()...")
asyncio.run(my_main_coroutine())
print("asyncio.run() finished.")

Output:

Running via asyncio.run()...
Inside main coroutine...
Running loop inside async func: <...>
Coroutine finished.
asyncio.run() finished.

asyncio.run() takes care of the loop lifecycle for you.

Solution 2: Manual Loop Management (new_event_loop, set_event_loop)​

If you need lower-level control (less common for typical applications), you must explicitly create and manage the loop.

import asyncio

async def my_task(id):
  print(f"Task {id} running...")
  await asyncio.sleep(0.1)
  print(f"Task {id} finished.")

async def main_manual_loop():
    # Example coroutine that needs a loop to run on
    await my_task(1)

# --- Manual Loop Management ---
# ✅ 1. Create a new event loop
loop = asyncio.new_event_loop()
print(f"Created loop: {loop}")

# ✅ 2. Set it as the current loop for this thread
asyncio.set_event_loop(loop)
print("Set loop as current for thread.")

try:
    print("Running coroutine using loop.run_until_complete()...")
    # ✅ 3. Run the coroutine on the manually managed loop
    loop.run_until_complete(main_manual_loop())
    print("Coroutine completed.")
finally:
    # ✅ 4. Close the loop when done (important!)
    print("Closing the loop.")
    loop.close()

This gives fine-grained control but requires careful setup (new_event_loop, set_event_loop) and cleanup (loop.close()).

Handling Version Compatibility (< 3.10)​

If your code needs to run on Python versions both older and newer than 3.10, you might conditionally get the loop. However, refactoring to use asyncio.run() is often a better long-term solution.

import asyncio
import sys

# --- Compatibility Pattern (Less Preferred than asyncio.run) ---
if sys.version_info >= (3, 10):
    try:
        # Use get_running_loop if available and a loop is running
        loop = asyncio.get_running_loop()
    except RuntimeError:
        # If no loop running, create and set a new one
        loop = asyncio.new_event_loop()
        asyncio.set_event_loop(loop)
else:
    # Older versions: get_event_loop automatically creates/gets
    loop = asyncio.get_event_loop()

print(f"Acquired loop (compatibility mode): {loop}")
# ... proceed to use 'loop' with run_until_complete, etc. ...
# Remember to close it if you created it with new_event_loop!
if 'loop' in locals() and sys.version_info >= (3, 10) and not loop.is_running():
     # Crude check, closing logic might need refinement
    loop.close()

Error 2: RuntimeError: no running event loop (Creating Tasks)​

Cause: Calling asyncio.create_task() Without a Running Loop​

The asyncio.create_task(coro) function is a shortcut that internally calls asyncio.get_running_loop().create_task(coro). If no loop is running when you call asyncio.create_task(), it fails with the RuntimeError.

import asyncio

async def simple_task(n):
    print(f"Simple Task {n}")
    await asyncio.sleep(0.01)

# Error Scenario: Calling asyncio.create_task outside a running loop context
try:
    # ⛔️ RuntimeError: no running event loop
    # This tries get_running_loop() internally and fails
    task = asyncio.create_task(simple_task(1))
    # loop.run_until_complete(task) # We don't even get here
except RuntimeError as e:
    print(e)

Solution 1: Create Tasks Within an async Function (via asyncio.run)​

The standard way is to create tasks inside an async function, which is then executed using asyncio.run(). By the time create_task is called within the async function, asyncio.run() ensures a loop is running.

import asyncio

async def worker(id):
  print(f"Worker {id} started")
  await asyncio.sleep(0.1)
  print(f"Worker {id} finished")

async def main_with_tasks():
  print("Main: Creating tasks...")
  # ✅ Call asyncio.create_task INSIDE an async function
  task1 = asyncio.create_task(worker(1))
  task2 = asyncio.create_task(worker(2))

  print("Main: Waiting for tasks...")
  # Wait for tasks to complete (using await asyncio.gather is common)
  await task1
  await task2
  print("Main: Tasks completed.")

# ✅ Run the main async function which handles task creation
asyncio.run(main_with_tasks())

Output:

Main: Creating tasks...
Main: Waiting for tasks...
Worker 1 started
Worker 2 started
Worker 1 finished
Worker 2 finished
Main: Tasks completed.

Solution 2: Use loop.create_task() with Manual Loop Management​

If you are managing the loop manually (Solution 2.3), create tasks explicitly on your loop object using loop.create_task().

import asyncio

async def worker(id):
  print(f"Worker {id} started (manual loop)")
  await asyncio.sleep(0.1)
  print(f"Worker {id} finished (manual loop)")

async def main_for_manual_loop():
    # This coroutine will be run by loop.run_until_complete
    # Get the loop that is *about* to run this coroutine
    # Note: In production, passing the loop explicitly might be better
    loop = asyncio.get_running_loop() # Safe inside the coroutine context

    print("Main Manual: Creating tasks...")
    # ✅ Call loop.create_task() on the specific loop object
    task1 = loop.create_task(worker(1))
    task2 = loop.create_task(worker(2))

    print("Main Manual: Waiting for tasks...")
    # Wait using asyncio.gather or similar
    await asyncio.gather(task1, task2)
    print("Main Manual: Tasks completed.")


# --- Manual Loop Management ---
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
try:
    loop.run_until_complete(main_for_manual_loop())
finally:
    loop.close()

Choosing asyncio.run() vs. Manual Loop Management​

  • asyncio.run(): Preferred for most applications. It simplifies setup and cleanup, reduces boilerplate code, and aligns with modern asyncio best practices. Use it to run your main entry-point coroutine.
  • Manual Loop Management: Necessary in specific scenarios like integrating asyncio into existing synchronous frameworks (e.g., GUI toolkits), long-running server processes where fine-grained control over the loop lifecycle is needed, or for advanced library/framework development. Avoid it for simple scripts if asyncio.run() suffices.

Conclusion​

Errors related to "no current event loop" or "no running event loop" in asyncio usually mean you're trying to use loop-dependent functions outside of an active asyncio context or are affected by recent Python version changes regarding get_event_loop().

Key Solutions:

  1. Use asyncio.run(your_main_async_function()): This is the recommended high-level approach. It manages the loop lifecycle for you. Create tasks within the coroutine passed to asyncio.run().
  2. Manual Loop Management: If necessary, explicitly create (asyncio.new_event_loop()), set (asyncio.set_event_loop()), run (loop.run_until_complete()), and close (loop.close()) the loop. When creating tasks this way, use loop.create_task().

By adopting asyncio.run() for typical use cases or correctly managing the loop manually when required, you can effectively avoid these common asyncio errors.

Table of Contents