Async/Await in JavaScript Explained Simply (With Examples)

What problem does async/await solve?

Many operations in JavaScript don't finish immediately. Fetching data from a server might take a fraction of a second — an eternity for a computer. JavaScript handles this with Promises: objects that represent a value that will exist later. Async/await is simply nicer syntax for working with those Promises.

The basics: async and await

Marking a function with `async` means it always returns a Promise. Inside that function, `await` pauses execution until a Promise settles, then gives you the result — without blocking the rest of your program.

async function getUser() {
  const response = await fetch('/api/user');
  const user = await response.json();
  return user;
}

Notice how the code reads top to bottom, like synchronous code, even though each await is non-blocking under the hood. That readability is the whole point.

Handling errors with try/catch

Because awaited Promises can reject, you wrap them in a try/catch block. This is far cleaner than chaining `.catch()` on every Promise.

async function getUser() {
  try {
    const res = await fetch('/api/user');
    if (!res.ok) throw new Error('Request failed');
    return await res.json();
  } catch (err) {
    console.error('Could not load user:', err);
    return null;
  }
}

Running tasks in parallel

A classic beginner mistake is awaiting things one after another when they could run at the same time. If two requests don't depend on each other, fire them together with Promise.all to cut your waiting time roughly in half.

const [user, posts] = await Promise.all([
  fetch('/api/user').then(r => r.json()),
  fetch('/api/posts').then(r => r.json()),
]);

Common mistakes to avoid

• Forgetting that `await` only works inside an `async` function.
• Awaiting independent operations sequentially instead of with Promise.all.
• Forgetting to handle rejected Promises, leading to silent failures.
• Using `await` inside a regular array loop callback like forEach, which won't wait as expected.