How to Reject a Promise in async/await with TypeScript

By the end of this page, you will understand how async functions wrap return values in resolved promises, how errors become rejected promises, and why throw is the correct way to reject from async/await code. You will also see practical TypeScript examples, common mistakes, and patterns used in real projects.

An async function always returns a promise.

That leads to two important rules:

• return value becomes Promise.resolve(value)
• throw error becomes Promise.reject(error)

This is the key idea behind rejecting in async/await syntax.

In promise chains, you often write:

return Promise.reject(error);

But in an async function, the more natural equivalent is:

throw error;

So if you want your async function to fail, you should throw, not return a normal value.

Why this matters

If you accidentally return a fallback value inside catch, callers will see the operation as successful, even though something actually failed. That can hide bugs and make error handling confusing.

For example:

Think of an async function as a machine that automatically wraps your output.

• If you hand it a value with return, it puts that value in a success box.
• If you throw an error, it puts that error in a failure box.

So:

• return 200 means: "This operation succeeded with value 200."
• throw 400 means: "This operation failed with reason 400."

A catch block does not automatically reject. It only gives you a chance to decide what happens next.

Inside catch, you can:

• recover and return a default value
• transform the error and throw a new one
• rethrow the same error

The important part is that return = success, throw = failure.

The core syntax is simple.

Return a resolved promise from an async function

async function successExample(): Promise<number> {
  return 200;
}

This is equivalent to:

function successExample(): Promise<number> {
  return Promise.resolve(200);
}

Return a rejected promise from an async function

async function failureExample(): Promise<number> {
  throw new Error("Something went wrong");
}

This is equivalent to:

function failureExample(): <> {
   .( ());
}

Consider this example:

async function foo(): Promise<number> {
  try {
    await someAsyncPromise();
    return 200;
  } catch (error) {
    throw new Error("Operation failed");
  }
}

If someAsyncPromise() succeeds

1. foo() is called.
2. Because foo is async, it immediately returns a promise.
3. Execution pauses at await someAsyncPromise().
4. If that promise resolves, execution continues.
5. return 200 runs.
6. The promise returned by foo() resolves with 200.

If someAsyncPromise() fails

1. foo() is called.

Rejecting correctly in async functions is important in many common situations.

API requests

If a request fails, the function should reject so the caller can show an error message:

async function getProfile(): Promise<User> {
  const response = await fetch("/api/profile");

  if (!response.ok) {
    throw new Error("Failed to fetch profile");
  }

  return response.json();
}

Validation

Reject when input is invalid:

async function saveEmail(email: string): Promise<void> {
  if (!email.includes("@")) {
    throw new Error("Invalid email address");
  }

   (email);
}

In real projects, developers usually do more than just throw inside catch. They use patterns that make error handling clearer and more maintainable.

1. Rethrow the original error

If you just want the failure to continue upward:

async function processOrder(): Promise<void> {
  try {
    await chargeCustomer();
  } catch (error) {
    throw error;
  }
}

This works, though sometimes the try/catch is unnecessary if you are not adding anything.

2. Throw a more meaningful error

async function processOrder(): Promise<void> {
  try {
    await chargeCustomer();
  } catch (error) {
    throw new Error("Payment processing failed");
  }
}

This is useful when low-level errors need to be translated into business-level messages.

1. Returning an error value instead of throwing

Broken example:

async function foo(): Promise<number> {
  try {
    await someAsyncPromise();
    return 200;
  } catch {
    return 400;
  }
}

Problem:

• This resolves with 400
• It does not reject

Fix:

async function foo(): Promise<number> {
  try {
    await someAsyncPromise();
    return 200;
  } catch {
    throw new Error("Operation failed");
  }
}

2. Catching an error and silently hiding it

Broken example:

async function example() {
  return 123; // resolves with 123
}

async function example2() {
  throw new Error("Failed"); // rejects
}

Rules

• async functions always return a promise
• return value => resolved promise
• throw error => rejected promise
• await pauses until a promise settles
• rejected await jumps to catch

Correct rejection pattern

async function foo(): Promise<number> {
  try {
    await someAsyncPromise();
    return ;
  }  (error) {
      ();
  }
}

How do you reject a promise inside an async function?

Use throw, not return. In an async function, throw turns into a rejected promise.

Is return Promise.reject(...) allowed inside an async function?

Yes, but throw is clearer and more idiomatic in async/await code.

Why does return 400 not reject?

Because async functions treat returned values as successful results. It becomes a resolved promise with value 400.

Should I throw numbers like 400?

You can, but it is better to throw an Error object for better debugging and clearer code.

Do I always need a try/catch with await?

No. If you are not recovering from or transforming the error, you can let it bubble up naturally.

What happens if an awaited promise rejects and there is no catch block?

The function returns a rejected promise automatically.

• Promises — async/await is built on top of promises.
• try/catch — used to handle rejected promises inside async functions.
• throw — the mechanism that creates rejection in async code.
• Error objects — preferred way to represent failures.
• Promise.resolve and Promise.reject — useful for understanding what return and throw map to.
• Await — pauses execution until a promise resolves or rejects.
• Error handling patterns — helps decide when to recover and when to propagate failures.