How can I give an asynchronous operation a time limit?

Set up a timer and race it against the operation. Return an explicit result for success, failure, or timeout so callers don’t have to guess what happened. If the operation accepts an AbortSignal, pass it a signal and abort the controller when the timer expires. That signal only helps if the operation honors it; a timeout wrapper alone does not stop arbitrary work. [S1] [S2]

Here’s a reusable pattern. Its start function is expected to accept a signal if the underlying API supports cancellation:

async function withTimeout(start, milliseconds) {
  const controller = new AbortController();
  let timer;

  const work = Promise.resolve().then(() => start(controller.signal));
  const settledWork = work.then(
    value => ({ status: "success", value }),
    error => ({ status: "error", error })
  );

  const timeout = new Promise(resolve => {
    timer = setTimeout(() => {
      resolve({ status: "timeout" });
      controller.abort();
    }, milliseconds);
  });

  try {
    return await Promise.race([settledWork, timeout]);
  } finally {
    clearTimeout(timer);
  }
}

For example, call it as withTimeout(signal => fetchData({ signal }), 3000) only if fetchData accepts and uses that signal. Adapt the arguments to your actual API.

The race decides which result your wrapper returns first; it does not cancel the losing Promise. JavaScript Promises have no built-in cancellation protocol. Cancellation may be available through the underlying operation, often via AbortController, but the particular API must support it. [S2]

Without cancellation support, your caller can receive { status: "timeout" } while the underlying task continues. Don’t start duplicate work or treat that result as proof the operation stopped. Check the operation’s documentation and, if it has no cancellation mechanism, design for the possibility that it finishes later.

The wrapper’s finally clears its timer whether the operation succeeds, fails, or times out. The example also converts a rejection into { status: "error", error }, distinct from { status: "timeout" }, so callers can respond separately.

If your operation acquires resources, it should clean them up in its own finally path. Aborting a signal is a cancellation request to compatible work, not a substitute for that work’s cleanup. Catch or report an error result at the call site; don’t silently treat every failure as a timeout. [S1]

Assuming fetchData accepts an abort signal and returns a Promise, a caller could branch on the result:

const result = await withTimeout(
  signal => fetchData({ signal }),
  3000
);

if (result.status === "success") {
  render(result.value);
} else if (result.status === "timeout") {
  showMessage("The operation took too long.");
} else {
  reportError(result.error);
}

Treat this as a pattern, not a guarantee that a particular API supports cancellation. The cited guidance covers compatible operations and the limits of Promise cancellation; it does not establish how any specific library responds to an abort signal. Check that library’s documentation before relying on cancellation. [S1] [S2]