How to fix The return type of an async function or method must be the global Promise<T> type in TypeScript

What this error means

In TypeScript, when you declare a function with the `async` keyword, the function is guaranteed to return a Promise, even if you don't explicitly return one. The `await` keyword inside async functions only works with Promises. When you specify a return type annotation for an async function, TypeScript requires that type to be `Promise<T>` where `T` is the type of the value being resolved. If you try to annotate an async function with a non-Promise type (like `string`, `number`, or a custom object), TypeScript will raise error TS1058. This is a fundamental requirement in TypeScript's type system—it ensures type safety when working with asynchronous code.

Typical symptoms

• Compilation error appears when declaring an async function with a simple return type
• Error message mentions 'The return type of an async function or method must be the global Promise<T> type'
• IDE shows red squiggly line under the return type annotation
• Happens even if the function body correctly returns the expected value
• Issue affects both named async functions and arrow functions

Common causes

1. Annotating an async function return type without wrapping it in Promise<> (most common)
2. Copy-pasting code from a synchronous function and adding async without updating the return type
3. Misunderstanding that async functions always return Promises, regardless of what you return inside them
4. Using an incorrect Promise type like Promise[] instead of Promise<T>
5. Trying to return a thenable object that doesn't fully conform to Promise spec

How to fix "The return type of an async function or method must be the global Promise<T> type"

async function getUsername(): string {  // ❌ Error: TS1058
  const user = await fetchUser();
  return user.name;
}

// ✅ Correct - Named function
async function getUsername(): Promise<string> {
  const user = await fetchUser();
  return user.name;
}

// ✅ Correct - Arrow function
const getUsername = async (): Promise<string> => {
  const user = await fetchUser();
  return user.name;
};

// ✅ Correct - Class method
class UserService {
  async getUsername(): Promise<string> {
    const user = await fetchUser();
    return user.name;
  }
}

// ❌ Error
async function logUser(): undefined {
  const user = await fetchUser();
  console.log(user.name);
}

// ✅ Correct
async function logUser(): Promise<void> {
  const user = await fetchUser();
  console.log(user.name);
}

// ✅ Return a union
async function fetchData(): Promise<string | null> {
  try {
    return await api.getData();
  } catch {
    return null;
  }
}

// ✅ Return an object
async function getUser(): Promise<{ id: string; name: string }> {
  const response = await fetch('/api/user');
  return response.json();
}

// ✅ Return an array
async function getUsers(): Promise<User[]> {
  const response = await fetch('/api/users');
  return response.json();
}

npx tsc --noEmit

npm run dev

Advanced notes

// TypeScript infers: Promise<string>
async function getName() {
  return 'John';
}

// ❌ May cause issues
async function getPromiseLike(): MyCustomThenable {
  return new MyCustomThenable();
}

// ✅ Wrap in Promise
async function getPromiseLike(): Promise<MyType> {
  return new Promise((resolve) => {
    resolve(new MyCustomThenable());
  });
}

// ✅ Async generator function
async function* generateData(): AsyncGenerator<string, void, unknown> {
  yield 'data1';
  yield 'data2';
}

Frequently asked questions

What does "TS1058" mean?

In TypeScript, when you declare a function with the async keyword, the function is guaranteed to return a Promise, even if you don't explicitly return one. The await keyword inside async functions only works with Promises. When you specify a return type annotation for an async function, TypeScript requires that type to be Promise<T> where T is the type of the value being resolved.

How do I fix "TS1058"?

This error occurs when you annotate an async function with a non-Promise return type. Async functions always return a Promise, so TypeScript requires you to wrap the return type in Promise<T>.

What causes "TS1058"?

Annotating an async function return type without wrapping it in Promise<> (most common) Copy-pasting code from a synchronous function and adding async without updating the return type Misunderstanding that async functions always return Promises, regardless of what you return inside them

Is the "TS1058" error serious?

It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Related errors

• Augmenting module 'X' but no export found in original

  How to fix 'Augmenting module but no export found in original' in TypeScript

  MEDIUM

• The left-hand side of an assignment expression must be a variable or a property access

  How to fix 'The left-hand side of an assignment expression must be a variable or a property access' in TypeScript

  MEDIUM

• Cannot use 'await' in non-async function

  Cannot use 'await' in non-async function

  MEDIUM

• Assertion signature required for type narrowing

  How to fix 'assertion signature required' for type narrowing in TypeScript

  MEDIUM

• Module has no exported member 'X'

  How to fix 'Module has no exported member X' error in TypeScript

  MEDIUM

• Argument of type 'undefined' is not assignable to parameter of type 'string'

  How to fix "Argument of type 'undefined' is not assignable to parameter of type 'string'" in TypeScript

  MEDIUM

Official resources & further reading

• 📚TypeScript Official Documentation
• TypeScript Issue #15292 - The return type of an async function or method must be the global Promise<T> type
• TypeScript Handbook - Return Type Annotations
• MDN - async function documentation
• Total TypeScript - Typing Promises and Async Requests
• Stack Overflow - TypeScript async/await return type
• Medium - TS1058 error explanation