Introduction

await does work inside a while loop, but only under the right conditions. Most bugs come from one of three problems: the loop is not inside an async function, the loop condition never changes in a way the awaited code can observe, or the loop structure is the wrong tool for an event-driven problem.

Core Sections

await only works inside async

The first requirement is syntactic. A plain function cannot use await directly.

1async function pollJobUntilDone(api, jobId) {
2  let done = false;
3
4  while (!done) {
5    const result = await api.getStatus(jobId);
6    done = result.done;
7  }
8
9  return "finished";
10}

If the surrounding function is not async, await is not even valid JavaScript in that context.

A while loop with await is sequential, not parallel

Each iteration waits for the current promise to resolve before the next iteration begins. That means the loop is serialized by design.

1async function readPages(client) {
2  let page = 1;
3  let hasMore = true;
4
5  while (hasMore) {
6    const response = await client.fetchPage(page);
7    console.log(response.items);
8    hasMore = response.hasMore;
9    page += 1;
10  }
11}

That behavior is often correct for polling, pagination, and retry loops. It is not correct if you expected all iterations to start immediately.

Why loops appear “stuck”

A common mistake is waiting inside a loop whose condition depends on state that never changes. For example, developers sometimes expect an external callback to flip a flag, but the code structure prevents that state from being updated in the intended way.

Another issue is a loop with no delay, where you repeatedly await a very fast promise or a resolved value and create a busy polling pattern that hammers a resource.

A safer polling loop adds a pause.

1function sleep(ms) {
2  return new Promise(resolve => setTimeout(resolve, ms));
3}
4
5async function waitForReady(api) {
6  while (true) {
7    const status = await api.status();
8    if (status.ready) {
9      return status;
10    }
11    await sleep(1000);
12  }
13}

This avoids tight-loop polling against the server.

Use the right pattern for the real problem

If you are waiting for events, a while loop may be the wrong abstraction. Event listeners, promise composition, or async iterators may fit better.

For example, if you already have an async iterable, for await ... of is clearer than managing the loop manually.

1async function consume(stream) {
2  for await (const item of stream) {
3    console.log(item);
4  }
5}

The loop is still sequential, but the code expresses “consume async values as they arrive” much more directly.

Beware of mixing await with array helpers incorrectly

People often say “await is not working in my loop” when the real code is using forEach, map, or another helper that does not await callbacks the way a normal control-flow loop does.

1for (const id of ids) {
2  const value = await loadById(id);
3  console.log(value);
4}

This works predictably. Replacing it with ids.forEach(async id => { ... }) does not give the same control flow.

Common Pitfalls

• Using await outside an async function and assuming the problem is the while loop itself.
• Expecting a while loop with await to run iterations in parallel even though each iteration waits for the previous one.
• Writing a polling loop whose exit condition never changes, which makes the loop appear frozen.
• Hammering an API with a tight await-based loop that has no delay between checks.
• Blaming while when the actual bug comes from using forEach or another helper that does not coordinate async control flow the same way.

Summary

• 'await works in a while loop as long as the surrounding function is async.'
• The loop runs sequentially, which is often correct for polling and pagination.
• If the loop seems stuck, inspect the condition and whether the awaited code can actually change it.
• Add delays for polling loops so they do not become hot retry loops.
• Use event-driven or async-iterator patterns when the task is not naturally a manual while loop.