View Categories

How does the async and await work when nested?

Parthiban Kannan
Updated on December 6, 2025

2 min read

when I mark a function as async, Dart automatically wraps its return type in a Future. Inside that function, whenever I use await, Dart pauses execution of that particular function until the awaited Future completes — but the rest of the program keeps running.

Now, when async and await are nested, meaning an async function calls another async function and awaits it, Dart will wait for each layer of async calls to complete before continuing. It’s kind of like a chain of futures where each one depends on the completion of the previous one.

Let me give you a simple example:

📄
filename.dart 
Future fetchUser() async {
  await Future.delayed(Duration(seconds: 2));
  return "User data fetched";
}

Future processUser() async {
  print("Fetching user...");
  var user = await fetchUser(); // awaits inner async function
  print(user);
  print("Processing user completed");
}

void main() async {
  await processUser(); // outer await
  print("All done");
}

Here’s what happens —
processUser() is called and awaited in main(). Inside processUser(), it awaits fetchUser(). Dart won’t move past the await fetchUser() line until that inner Future finishes. So it’s like a chain — the inner async completes first, then the outer one continues.

In one of my projects, I had a situation where multiple API calls were nested — for example, fetching user details, then based on that, fetching related transactions, and then updating the UI. Initially, I faced an issue because I forgot to await one of the inner async calls, so the outer function returned before the data was ready, leading to inconsistent UI updates. Once I added the missing await, everything worked smoothly because Dart properly sequenced the async calls.

A challenge with nested async is readability — if you nest too many async/awaits, it can look like “callback hell.” To handle that, I sometimes refactor my code using smaller functions or chain Futures with .then() when it fits better.

The limitation is that Dart doesn’t support truly parallel awaits inside one function — each await waits sequentially unless you use something like Future.wait() for concurrency.

So in short, when async/await is nested, Dart executes it layer by layer — each async function waits for its awaited Future to complete before moving forward, ensuring proper sequencing and predictable flow.

Scroll to Top