How is `Promise.all()` different from `Promise.allSettled()`?

TL;DR

Promise.all() and Promise.allSettled() are both methods for handling multiple promises in JavaScript, but they behave differently. Promise.all() waits for all promises to resolve and fails fast if any promise rejects, returning a single rejected promise. Promise.allSettled(), on the other hand, waits for all promises to settle (either resolve or reject) and returns an array of objects describing the outcome of each promise.

Choosing an aggregation outcome

The methods start from the same set of inputs but differ in when and how the aggregate promise settles.

Use all() when every result is required for success; use allSettled() when every outcome must be inspected independently.

Promise.all()

Promise.all() takes an iterable of promises and returns a single promise that resolves when all of the input promises have resolved. If any of the input promises reject, the returned promise immediately rejects with the reason of the first promise that rejected.

Example

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3])
  .then((values) => {
    console.log(values); // [3, 42, 'foo']
  })
  .catch((error) => {
    console.error(error);
  });

In this example, Promise.all() resolves with an array of results [3, 42, 'foo'] because all promises resolve successfully.

Failure case

const promise1 = Promise.resolve(3);
const promise2 = Promise.reject('error');
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.all([promise1, promise2, promise3])
  .then((values) => {
    console.log(values);
  })
  .catch((error) => {
    console.error(error); // 'error'
  });

In this example, Promise.all() rejects immediately with the reason 'error' because promise2 rejects.

Promise.allSettled()

Promise.allSettled() takes an iterable of promises and returns a single promise that resolves when all of the input promises have settled (either resolved or rejected). The returned promise resolves with an array of objects that each describe the outcome of each promise.

Example

const promise1 = Promise.resolve(3);
const promise2 = 42;
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.allSettled([promise1, promise2, promise3]).then((results) => {
  results.forEach((result) => console.log(result));
  // { status: 'fulfilled', value: 3 }
  // { status: 'fulfilled', value: 42 }
  // { status: 'fulfilled', value: 'foo' }
});

In this example, Promise.allSettled() resolves with an array of result objects, each indicating the status and value of the promises.

Failure case

const promise1 = Promise.resolve(3);
const promise2 = Promise.reject('error');
const promise3 = new Promise((resolve, reject) => {
  setTimeout(resolve, 100, 'foo');
});

Promise.allSettled([promise1, promise2, promise3]).then((results) => {
  results.forEach((result) => console.log(result));
  // { status: 'fulfilled', value: 3 }
  // { status: 'rejected', reason: 'error' }
  // { status: 'fulfilled', value: 'foo' }
});

In this example, Promise.allSettled() resolves with an array of result objects, including the rejected promise with its reason.

When to use Promise.all() vs Promise.allSettled()

The choice comes down to a single question: if one of these operations fails, is the rest of the work still useful?

Use Promise.all() when partial success is invalid

• Prefetching everything a page needs before render: if any required call fails (auth, feature flags, current user), you want to render an error state, not a half-broken UI.
• Required independent reads: loading the current user, permissions, and feature configuration before rendering a page that needs all three.
• Gating UI on multiple checks: show the dashboard only if getUser() AND getPermissions() both succeed. Fail-fast is the desired behavior.

Use Promise.allSettled() when partial success is acceptable

• Dashboard with multiple independent widgets: six analytics endpoints fan out in parallel. One slow or failing endpoint should not blank the rest of the dashboard.
• Bulk operations with per-item feedback: deleting 50 selected rows; the UI needs to show which succeeded and which failed, not abort on the first failure.
• Analytics or telemetry batches: sending several events where partial loss is acceptable; you want to know which fired even if one rejected.

If you would try/catch each call individually anyway, Promise.allSettled() is what you actually want.

Do not treat Promise.all() as a transaction. If several bookings or writes start together, one rejection does not cancel or roll back the others. Use a real transactional boundary where available, or design idempotency and compensating actions explicitly.

Failure-mode reference

Predict the output

Concurrent vs sequential awaits

These two snippets look almost identical but run very differently:

const slow = (label, ms) =>
  new Promise((resolve) => setTimeout(() => resolve(label), ms));

(async () => {
  console.time('parallel');
  const a = await Promise.all([slow('A', 300), slow('B', 300)]);
  console.timeEnd('parallel'); // ~300ms: both ran concurrently

  console.time('sequential');
  const b = [await slow('A', 300), await slow('B', 300)];
  console.timeEnd('sequential'); // ~600ms: second await waits for the first
})();

In this example, both calls have started before Promise.all() receives their promises. [await ..., await ...] evaluates left-to-right, so the second call starts only after the first fulfills.

Promise.allSettled() does not reject on per-promise failures

(async () => {
  const results = await Promise.allSettled([
    Promise.resolve(1),
    Promise.reject(new Error('boom')),
    Promise.resolve(3),
  ]);

  console.log(results.map((r) => r.status));
  // ['fulfilled', 'rejected', 'fulfilled']

  // The outer await never throws for inner rejections, so this line still runs:
  console.log('still here');
})();

You will almost never put Promise.allSettled() inside a try/catch for the inner promises, since it does not throw on their rejections. To check for failures, filter on status === 'rejected' after the fact. (The returned promise can still reject if the input itself is invalid, for example, a non-iterable will produce a TypeError.)

Further reading

• MDN Web Docs: Promise.all()
• MDN Web Docs: Promise.allSettled()
• JavaScript.info: Promise API

Exercises