Introduction

await is a keyword used inside an async function to pause its execution until an awaited operation (a Promise, Task, or Future) finishes. Crucially, this pause is non-blocking: while the async function waits, the thread is free to run other work. Once the awaited value is ready, execution resumes right after the await with the result.

Real-World Analogy

Key Rules of await

• You can only use await inside an async function (or a top-level module in modern JS/Python).
• await expects an awaitable — a Promise (JS), Task (C#), or coroutine/Future (Python).
• It unwraps the awaitable: await promise gives you the resolved value, not the promise.
• If the awaited operation fails, await throws — catch it with try/catch.

Prerequisites

What Happens When You await

1. Execution reaches await someTask.
2. If someTask is already done, the value is returned immediately.
3. If not, the async function suspends and returns control to the event loop.
4. The event loop runs other ready work while someTask completes in the background.
5. When someTask resolves, the function resumes right after the await, with the result.
6. If someTask rejected/threw, the await expression throws that error.

await in JavaScript

In JavaScript, await pauses an async function until a Promise settles.

Basic usage

async function getUser() {
    // await unwraps the Promise into the actual value
    const response = await fetch("/api/user");
    const user = await response.json();
    console.log(user.name);
    return user;
}

getUser();

With error handling

async function loadProfile() {
    try {
        const data = await fetch("/api/profile");
        return await data.json();
    } catch (err) {
        console.error("Request failed:", err);
        return null;
    }
}

// Runs one after another — total = timeA + timeB
const a = await fetchA();
const b = await fetchB();

// Runs together — total = max(timeA, timeB)
const [a, b] = await Promise.all([fetchA(), fetchB()]);

await in Python (asyncio)

In Python, await suspends a coroutine until the awaited awaitable completes.

import asyncio

async def get_data():
    print("Fetching...")
    await asyncio.sleep(2)      # non-blocking pause
    print("Done")
    return {"status": "ok"}

async def main():
    result = await get_data()   # await unwraps the coroutine's result
    print(result)

asyncio.run(main())

async def main():
    a, b = await asyncio.gather(get_data(), get_data())
    print(a, b)

await in C# (.NET)

In C#, await asynchronously waits for a Task or Task<T> to complete.

using System;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        using var client = new HttpClient();

        // await unwraps Task<string> into string
        string html = await client.GetStringAsync("https://example.com");
        Console.WriteLine($"Length: {html.Length}");
    }
}

await vs Blocking Wait

Sequential vs Concurrent Awaits

If you await \(N\) independent tasks one after another, total time is the sum of all durations:

\[ T_{\text{sequential}} = \sum_{i=1}^{N} t_i \]

If instead you start them together and await them at once (e.g. Promise.all / gather):

\[ T_{\text{concurrent}} = \max_{1 \le i \le N} t_i \]

This is why where you place your await matters as much as using it at all.

Best Practices

Common Mistakes

Interview Questions

Quick Revision