Glossary

Unhandled promise rejection

The failed request nobody was listening for.

By Roger Campos · Last updated: September 2026

TL;DR

An unhandled promise rejection happens when a JavaScript promise fails and no code has attached a handler for the failure — no .catch() and no try/catch around an await. The browser reports it as "Uncaught (in promise)" in the console and fires an unhandledrejection event; the feature that depended on it quietly stops working.

Start free See the API

Free plan, no credit card. 1,000 credits a month.

How it works

How it happens

A promise either fulfils or rejects. If it rejects and, by the time the current task finishes, nothing has attached a rejection handler, the runtime calls it unhandled. The classic case is a fetch whose error nobody catches:

Two unhandled rejections

// 1. An async function called without await or .catch()
async function loadPrices() {
  const res = await fetch("/api/prices");
  if (!res.ok) throw new Error(`prices: ${res.status}`);
  render(await res.json());
}
loadPrices(); // a 500 here rejects, and nothing is listening

// 2. A .then() chain with no .catch()
fetch("/api/user").then((res) => res.json()).then(showUser);

The page does not crash. The prices simply never render, and the only trace is a line in the console — which no one reads on a production site.

In practice

Catching them

Handle the rejection where it happens (try/catch around await, or .catch()), and add a global listener as a safety net that reports the ones you missed:

A last line of defence

window.addEventListener("unhandledrejection", (event) => {
  reportError(event.reason); // send it to your error tracker
});

In Node.js the default is stricter: since version 15 an unhandled rejection terminates the process.

URLpipe

Finding them with URLpipe

/console loads the page in real Chrome and returns what it logs: console.error, console.warn, uncaught exceptions and unhandled promise rejections, the last two with type exception. It keeps listening briefly after the network settles, so a rejection from a late API call is caught. Run it on pages you don't control, or after each deploy on the ones you do.

What it does not capture: console.log output, failed resource loads that raise no error, and messages from inside third-party iframes, which have their own console.

POST /console — a rejection in the result

[
  { "type": "exception", "text": "Uncaught (in promise) Error: prices: 500" },
  { "type": "warning", "text": "[analytics] no consent yet, 3 events queued" }
]

Try it

Unhandled promise rejection, on a page you choose

Check any website for JavaScript errors

Paste a link and see the console errors, warnings and uncaught exceptions logged while the page loads in a real browser — no DevTools, no local setup.

Try it free

FAQ

Frequently asked questions

What does Uncaught (in promise) mean?

That a promise rejected and no handler caught it. The value after the message is the rejection reason — often an Error from a failed fetch.

How do I find unhandled promise rejections on a live site?

Listen for the unhandledrejection event in your own code, or load the page in a headless browser and collect its console exceptions.

Do unhandled promise rejections crash the page?

No. The page keeps running, and whatever depended on the promise silently doesn't happen. In Node.js 15 and later they terminate the process by default.

Keep reading

Console Check any website for JavaScript errors Find JavaScript errors on any site Monitoring client websites Console API Request timing as marks, not spans All of glossary

See it on your own pages.

Free plan, no card. Confirm your email and your API key is live — you'll be making real requests in minutes.

Start free Email the team