How to Get the Page from a Puppeteer Console Message

Short answer: Puppeteer’s ConsoleMessage does not have a documented method that returns the Page that emitted it. Register the console listener on the Page you want to monitor, then use that Page reference inside the callback. The callback receives the message; the closure identifies the page.

page.on('console', msg => {
  console.log('From page:', page.url());
  console.log('Message:', msg.text());
});

This works for one page or many. Puppeteer documents the console event as a Page event that supplies a ConsoleMessage; the message API documents methods such as args(), location(), stackTrace(), text(), and type(), but no originating-page accessor. See the PageEvent reference and ConsoleMessage API.

1. Attach the listener to the Page

Keep the Page object you already use to control the tab. Because the listener is attached to that specific object, its callback can refer to the same object when a console event arrives.

import puppeteer from 'puppeteer';

const browser = await puppeteer.launch();
const page = await browser.newPage();

page.on('console', msg => {
  console.log({
    pageUrl: page.url(),
    type: msg.type(),
    text: msg.text(),
  });
});

await page.goto('https://example.com');
await page.evaluate(() => console.log('Hello from the page'));

await browser.close();

Install the listener before navigation or before triggering the page code you want to observe. Otherwise, an earlier console event may already have happened. Puppeteer’s Page API documents registering event handlers on a Page; the callback shown here closes over that Page reference. See the Page class documentation.

2. Identify messages from several tabs

Add a listener to every Page you want to monitor. Each callback keeps the Page from its own loop iteration, so log the page URL alongside the message.

for (const page of pages) {
  page.on('console', msg => {
    console.log(`[${page.url()}] ${msg.type()}: ${msg.text()}`);
  });
}

In modern JavaScript, a const declaration in the loop gives each iteration its own binding. If the listener setup is inside a function or a more complex loop, a handler factory makes the association explicit:

function logConsoleFor(page) {
  return msg => {
    console.log(`[${page.url()}] ${msg.type()}: ${msg.text()}`);
  };
}

for (const page of pages) {
  page.on('console', logConsoleFor(page));
}

If pages are created dynamically, attach the listener immediately after creating or acquiring each Page. For example:

browser.on('targetcreated', async target => {
  if (target.type() !== 'page') return;

  const page = await target.page();
  if (!page) return;

  page.on('console', msg => {
    console.log(`[${page.url()}] ${msg.type()}: ${msg.text()}`);
  });
});

Use the page collection or target handling pattern that fits how your application creates tabs. The key remains the same: attach the callback to the Page and retain that Page reference in the callback’s scope.

3. Read message details separately from page identity

Use the message object for information about the console entry. Use the captured Page for information about the tab.

What you need	Use
Page currently associated with the listener	page, captured in the callback
Current page URL	page.url()
Rendered console text	msg.text()
Console message kind	msg.type()
Arguments from the console call	msg.args()
Source location for the message	msg.location()
Stack locations associated with it	msg.stackTrace()

msg.location() describes where the console message originated in page code; it is not a Page object. Likewise, msg.args() gives the console-call arguments, not a reference to the event emitter. The documented ConsoleMessage methods do not include page().

4. Remove listeners when they are no longer needed

If a Page is long-lived or listeners are installed repeatedly, retain the handler function so it can be removed. This avoids duplicate log lines and unnecessary callbacks.

function makeConsoleHandler(page) {
  return msg => {
    console.log(`[${page.url()}] ${msg.type()}: ${msg.text()}`);
  };
}

const onConsole = makeConsoleHandler(page);
page.on('console', onConsole);

// Later, when this handler is no longer needed:
page.off('console', onConsole);

Use the event removal method supported by the Puppeteer version and emitter setup in your project. If your code uses removeListener instead, pass the same event name and exact handler reference that you registered.

5. Troubleshooting

Symptom	Likely cause	Fix
msg.page is not a function	ConsoleMessage has no documented page() method.	Capture the Page in the listener closure and use page.url() or other Page methods.
Messages have no URL or show the wrong tab	The handler was shared across pages while referring to a mutable variable, or the listener was attached to a different Page than expected.	Register one callback per Page and capture that Page with a loop binding or handler factory.
No console output appears	The listener was added after the message occurred, the page did not emit a console call, or the code under observation did not run.	Attach the listener before navigation or evaluation, then trigger a known console call to confirm the event path.
Output appears more than once	The setup registered multiple listeners, often after repeated navigation or setup.	Register once per Page or remove the previous handler before replacing it.
The URL is empty or unexpected	The Page may not have navigated yet, may be on a new document, or may have changed URL before the callback reads it.	Log at the time the event arrives and check your navigation timing. The closure identifies the Page instance, while page.url() reports its current URL.
Object arguments are hard to inspect	msg.text() is a text representation and may not preserve the structure you need.	Inspect msg.args() for the original console arguments; handle remote objects according to your Puppeteer version and use case.

6. Performance, reliability, and cost

A console listener is event-driven; it does not poll the page. Keep the callback lightweight if a page emits many messages, especially when monitoring multiple tabs. Avoid doing slow synchronous work for each event. If processing is asynchronous, decide how to handle overlapping work and errors so a burst of console messages does not create an unbounded queue.

For reliable attribution, bind one Page per handler and register early. A page’s URL can change during navigation, so the callback’s Page reference identifies the tab while page.url() gives its current URL when the handler runs. If you need the URL at a particular lifecycle moment, record it at that moment rather than assuming it is immutable.

This method uses the Puppeteer objects already in your process and does not require an additional screenshot service or per-message API call. Browser execution and hosting costs depend on your own environment and workload.

7. Or skip the browser setup

If your goal is a screenshot rather than console debugging, ScreenshotNeo returns a PNG, JPEG, WebP, or PDF from one GET request. It is a website screenshot API and MCP server for developers. The API documentation covers its options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp

import requests

r = requests.get(
    "https://api.screenshotneo.com/v1/shot",
    params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"},
    timeout=90,
)
open("shot.webp", "wb").write(r.content)

const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });
const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);
if (!res.ok) throw new Error(`Screenshot request failed: ${res.status}`);
await Bun.write('shot.webp', res);

• Cookie banners are accepted like a visitor and removed, along with known newsletter popups and chat widgets, before the shot; each step can be turned off.
• Bot checks, blank pages, timeouts, failed loads, and cache hits cost nothing. Response headers report the page verdict and billing status.
• An MCP server provides take_screenshot, get_page_info, and capture_pdf tools for AI agents and MCP clients.
• The Free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 screenshots; every feature is on every plan.

Create a free ScreenshotNeo account for 1,000 screenshots a month with no card.

8. FAQ

Can I get the Page from ConsoleMessage directly?

There is no documented originating-Page method on ConsoleMessage. Keep the Page reference from the listener registration.

Does msg.location() identify the tab?

No. It gives message source-location information. Use the Page captured by the listener to identify the tab.

How do I tell which of several tabs logged a message?

Attach a separate listener to each Page and include that captured Page’s URL or another identifier in the log line.