What Does an async Function Actually Return? Uncover the Promise Mechanics

Async/await has become the standard way to handle asynchronous operations in JavaScript, allowing developers to write code that looks synchronous while improving readability and maintainability. A common question is what an async function actually returns.

Scenario 1: Returning a non‑Promise value

When an async function returns a plain value (e.g., a number, string, or object), the JavaScript engine automatically wraps that value in a resolved Promise. For example:

async function getNumber() {
  return 42; // returns a normal number
}
const result = getNumber();
console.log(result); // Promise { <pending> }

The promise quickly becomes fulfilled with the value 42. Internally, the function is equivalent to:

function getNumber() {
  return Promise.resolve(42);
}

Therefore, to obtain the actual value you must await the call or use .then().

Scenario 2: Returning a Promise

If the async function itself returns an explicit Promise, the engine detects this and returns the same promise without adding another layer. Example:

async function fetchUser() {
  // returns an explicit Promise
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ name: 'Alice' });
    }, 1000);
  });
}
const promise = fetchUser();
console.log(promise); // Promise { <pending> }
promise.then(user => console.log(user)); // after 1 s: { name: 'Alice' }

This behavior ensures that the return value of an async function is always a consistently usable, await -able object, avoiding unnecessary nested promises.

Scenario 3: Throwing an error inside the function

When an async function throws an error, the engine catches it and returns a rejected Promise whose reason is the thrown Error object. You can handle it with standard promise error handling:

// Using try…catch with await
async function handleFailure() {
  try {
    await willFail();
  } catch (error) {
    console.error(error.message); // outputs: Something went wrong!
  }
}
handleFailure();
// Or using .catch()
willFail().catch(error => console.error(error.message));

This integrates synchronous try...catch semantics seamlessly into asynchronous flow control.

Scenario 4: No return statement

If an async function finishes without a return, it implicitly returns undefined. Following the rule from Scenario 1, that undefined is wrapped in a resolved Promise:

async function doNothing() {
  const a = 1 + 1; // no return
}

doNothing().then(value => console.log(value)); // outputs: undefined

Thus, even a function that does nothing still adheres to the “always return a Promise” principle.

In summary, async/await is syntactic sugar for promises: the async keyword wraps return values (including undefined) into resolved promises, avoids double‑wrapping when a promise is already returned, and converts thrown errors into rejected promises, while await performs the corresponding unwrapping.