page.waitForTimeout is not a function in Puppeteer

Why this error happens

If you see an error like:

1
TypeError: page.waitForTimeout is not a function

your code is probably running on the old version of Puppeteer.

page.waitForTimeout() was removed, so older examples and blog posts that still use it will fail after an upgrade.

What to use instead

In most cases, the correct replacement is not another sleep function. It is an explicit wait for the thing you actually need.

Use:

• page.waitForSelector() when you need an element to appear;
• page.waitForNavigation() when a click or submit triggers navigation;
• page.waitForResponse() when you need a specific API call to finish;
• page.waitForFunction() when you need a client-side condition to become true;
• page.waitForNetworkIdle() when you want the page to become quiet after navigation.

If you are looking for page.goto(..., { waitUntil: ... }) guidance, read Puppeteer waitUntil: how to wait for page load.

Replacements for common cases

Wait for a selector instead of sleeping

1
await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30_000 });
2
await page.waitForSelector(".price", {
3
    visible: true,
4
    timeout: 10_000,
5
});

Wait after a click that navigates

1
const [response] = await Promise.all([
2
    page.waitForNavigation({
3
        waitUntil: ["domcontentloaded", "networkidle2"],
4
        timeout: 30_000,
5
    }),
6
    page.click("a.next-page"),
7
]);

Wait for a specific API response

1
await page.click("button.refresh");
2

3
await page.waitForResponse((response) => {
4
    return response.url().includes("/api/data") && response.ok();
5
});

Wait for a client-side condition

1
await page.waitForFunction(() => {
2
    return document.querySelectorAll(".result-card").length >= 10;
3
});

Wait for the network to calm down

1
await page.goto(url, { waitUntil: "domcontentloaded", timeout: 30_000 });
2

3
await page.waitForNetworkIdle({
4
    idleTime: 500,
5
    timeout: 10_000,
6
});

If you still need a fixed delay

Sometimes a short delay is still the simplest fallback, especially for one-off scripts.

Use a standard JavaScript promise:

1
await new Promise((resolve) => setTimeout(resolve, 2000));

That is the closest drop-in replacement for page.waitForTimeout(2000), but it is usually the weakest solution:

• it can still be too short on slow pages;
• it can waste time on fast pages;
• it does not describe what the code is actually waiting for.

Migration example

Old code:

1
await page.goto(url);
2
await page.waitForTimeout(5000);
3
await page.screenshot({ path: "page.png" });

Better modern version:

1
await page.goto(url, {
2
    waitUntil: "domcontentloaded",
3
    timeout: 30_000,
4
});
5

6
await page.waitForNetworkIdle({
7
    idleTime: 500,
8
    timeout: 10_000,
9
});
10

11
await page.screenshot({ path: "page.png" });

Best version, when you know the exact ready signal:

1
await page.goto(url, {
2
    waitUntil: "domcontentloaded",
3
    timeout: 30_000,
4
});
5

6
await page.waitForSelector(".chart-container", {
7
    visible: true,
8
    timeout: 10_000,
9
});
10

11
await page.screenshot({ path: "page.png" });

Summary

page.waitForTimeout() is gone in Puppeteer.

You can replace it with:

• an explicit Puppeteer wait method for the event you care about;
• new Promise((resolve) => setTimeout(resolve, ms)) if you really need a plain delay.

For navigation readiness and waitUntil options, see Puppeteer waitUntil: how to wait for page load.