Use Promise.all() when every request must succeed for the combined result to be useful. Use Promise.allSettled() when requests are independent and you need to inspect every success and failure, including partial results. Both return outcomes in input order, and neither cancels work that is already running.
How do the two methods handle concurrent requests?
| Behavior | Promise.all() |
Promise.allSettled() |
|---|---|---|
| When the aggregate fulfills | After every input fulfills. | After every input fulfills or rejects. |
| If an input rejects | The aggregate rejects with the first rejection reason. | The aggregate fulfills with a rejected-outcome record for that input. |
| Successful result shape | An array of fulfillment values. | An array of outcome records, each with a status and either a value or reason. |
| Result order | Both preserve the order of the input iterable, not the order in which operations finish. | |
| Typical fit | All results are required to produce a valid combined answer. | Requests are independent and partial results or individual failures are useful. |
These behaviors are documented in MDN’s Promise.all() reference, which also points to the related allSettled() behavior.
When should you use Promise.all()?
Choose Promise.all() when the caller cannot proceed correctly without every result—for example, when loading a profile and its permissions as one required view. If any input rejects, the aggregate rejects, so catch that rejection at the boundary where the application can report the error or recover.
const [profile, permissions] = await Promise.all([
fetchProfile(userId),
fetchPermissions(userId),
]);The returned array follows the order of the promises passed in, so profile corresponds to the first input and permissions to the second even if the second request finishes sooner.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
#1 Best Overall
When should you use Promise.allSettled()?
Use Promise.allSettled() when one failed request should not hide other outcomes—for example, a dashboard that can display whichever independent data sources respond. Each record has status: "fulfilled" and a value, or status: "rejected" and a reason.
const outcomes = await Promise.allSettled(
urls.map((url) => fetch(url)),
);
for (const outcome of outcomes) {
if (outcome.status === "fulfilled") {
console.log("request succeeded", outcome.value);
} else {
console.error("request failed", outcome.reason);
}
}Keep the original input list or pair each request with a stable key when you need to associate a result with a URL or record. Outcome positions match input positions; completion order does not determine their placement.
Rank #2
How do you pass requests to either method?
Pass promises, not bare async-function references. Invoke each function while building the iterable, as in urls.map((url) => fetch(url)). A function reference by itself is not a promise, so the combinator will not call it for you.
For request code using fetch(), account for HTTP status separately: a response with an HTTP error status generally still fulfills with a Response. If your application should treat a non-success status as a failed request, check the response status and convert it into an error before interpreting the settled outcomes.
Recommended Free Tools
What fail-fast does—and does not—mean
Promise.all() rejects its aggregate as soon as an input rejects, but it does not cancel the remaining operations. Those requests may still be running; the aggregate simply does not give you their later outcomes. MDN’s reference puts it plainly: “Rejecting the returned promise does not cancel the remaining operations or unsubscribe the handlers attached to their promises.”
If stopping work is a requirement, use cancellation supported by the underlying request API and coordinate it separately. Neither combinator is a cancellation mechanism.
Rank #4
Limits to account for with large or slow batches
- Waiting:
Promise.allSettled()waits until every input settles. A request that hangs can therefore hold up the aggregate; use the request API’s timeout or cancellation strategy if needed. - Concurrency: Neither method caps the number of active requests. If a large batch must run with a limit, use batching or a concurrency-control approach rather than relying on the aggregate combinator.
- Repeated handlers:
Promise.all()attaches handlers to its inputs when called. Avoid repeatedly attaching handlers to long-lived pending promises in a loop.
Is one method faster?
There is no documented speed benchmark in the cited reference comparing these methods. Choose according to the failure policy and whether partial results are useful, not an assumed performance advantage.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
