puppeteer

method snapshot

snapshot: (options?: SnapshotOptions) => Promise<SerializedAXNode | null>;

• Captures the current state of the accessibility tree. The returned object represents the root accessible node of the page.

  Returns

  An AXNode object representing the snapshot.

  Remarks

  **NOTE** The Chromium accessibility tree contains nodes that go unused on most platforms and by most screen readers. Puppeteer will discard them as well for an easier to process tree, unless interestingOnly is set to false.

  Example 1

  An example of dumping the entire accessibility tree:

  const snapshot = await page.accessibility.snapshot();
  console.log(snapshot);

  Example 2

  An example of logging the focused node's name:

  const snapshot = await page.accessibility.snapshot();
  const node = findFocusedNode(snapshot);
  console.log(node && node.name);
  
  function findFocusedNode(node) {
    if (node.focused) return node;
    for (const child of node.children || []) {
      const foundNode = findFocusedNode(child);
      return foundNode;
    }
    return null;
  }

method browserContexts

browserContexts: () => BrowserContext[];

• Returns an array of all open browser contexts. In a newly created browser, this will return a single instance of BrowserContext.

method close

close: () => Promise<void>;

• Closes Chromium and all of its pages (if any were opened). The Browser object itself is considered to be disposed and cannot be used anymore.

method createIncognitoBrowserContext

createIncognitoBrowserContext: (
    options?: BrowserContextOptions
) => Promise<BrowserContext>;

• Creates a new incognito browser context. This won't share cookies/cache with other browser contexts.

  Example 1

  (async () => {
    const browser = await puppeteer.launch();
    // Create a new incognito browser context.
    const context = await browser.createIncognitoBrowserContext();
    // Create a new page in a pristine context.
    const page = await context.newPage();
    // Do stuff
    await page.goto('https://example.com');
  })();

method defaultBrowserContext

defaultBrowserContext: () => BrowserContext;

• Returns the default browser context. The default browser context cannot be closed.

method disconnect

disconnect: () => void;

• Disconnects Puppeteer from the browser, but leaves the Chromium process running. After calling disconnect, the Browser object is considered disposed and cannot be used anymore.

method isConnected

isConnected: () => boolean;

• Indicates that the browser is connected.

method newPage

newPage: () => Promise<Page>;

• Promise which resolves to a new Page object. The Page is created in a default browser context.

method pages

pages: () => Promise<Page[]>;

• An array of all open pages inside the Browser.

  Remarks

  In case of multiple browser contexts, returns an array with all the pages in all browser contexts. Non-visible pages, such as "background_page", will not be listed here. You can find them using Target.page.

method process

process: () => ChildProcess | null;

• The spawned browser process. Returns null if the browser instance was created with Puppeteer.connect.

method target

target: () => Target;

• The target associated with the browser.

method targets

targets: () => Target[];

• All active targets inside the Browser. In case of multiple browser contexts, returns an array with all the targets in all browser contexts.

method userAgent

userAgent: () => Promise<string>;

• The browser's original user agent. Pages can override the browser user agent with Page.setUserAgent.

method version

version: () => Promise<string>;

• A string representing the browser name and version.

  Remarks

  For headless Chromium, this is similar to HeadlessChrome/61.0.3153.0. For non-headless, this is similar to Chrome/61.0.3153.0.

  The format of browser.version() might change with future releases of Chromium.

method waitForTarget

waitForTarget: (
    predicate: (x: Target) => boolean | Promise<boolean>,
    options?: WaitForTargetOptions
) => Promise<Target>;

• Searches for a target in all browser contexts.

  Parameter predicate

  A function to be run for every target.

  Returns

  The first target found that matches the predicate function.

  Example 1

  An example of finding a target for a page opened via window.open:

  await page.evaluate(() => window.open('https://www.example.com/'));
  const newWindowTarget = await browser.waitForTarget(
    target => target.url() === 'https://www.example.com/'
  );

method wsEndpoint

wsEndpoint: () => string;

• The browser websocket endpoint which can be used as an argument to Puppeteer.connect.

  Returns

  The Browser websocket url.

  Remarks

  The format is ws://${host}:${port}/devtools/browser/<id>.

  You can find the webSocketDebuggerUrl from http://${host}:${port}/json/version. Learn more about the devtools protocol and the browser endpoint.

property id

readonly id: string;

method browser

browser: () => Browser;

• The browser this browser context belongs to.

method clearPermissionOverrides

clearPermissionOverrides: () => Promise<void>;

• Clears all permission overrides for the browser context.

  Example 1

  const context = browser.defaultBrowserContext();
  context.overridePermissions('https://example.com', ['clipboard-read']);
  // do stuff ..
  context.clearPermissionOverrides();

method close

close: () => Promise<void>;

• Closes the browser context. All the targets that belong to the browser context will be closed.

  Remarks

  Only incognito browser contexts can be closed.

method isIncognito

isIncognito: () => boolean;

• Returns whether BrowserContext is incognito. The default browser context is the only non-incognito browser context.

  Remarks

  The default browser context cannot be closed.

method newPage

newPage: () => Promise<Page>;

• Creates a new page in the browser context.

method overridePermissions

overridePermissions: (
    origin: string,
    permissions: Permission[]
) => Promise<void>;

• Parameter origin

  The origin to grant permissions to, e.g. "https://example.com".

  Parameter permissions

  An array of permissions to grant. All permissions that are not listed here will be automatically denied.

  Example 1

  const context = browser.defaultBrowserContext();
  await context.overridePermissions('https://html5demos.com', [
    'geolocation',
  ]);

method pages

pages: () => Promise<Page[]>;

• An array of all pages inside the browser context.

  Returns

  Promise which resolves to an array of all open pages. Non visible pages, such as "background_page", will not be listed here. You can find them using the target page.

method targets

targets: () => Target[];

• An array of all active targets inside the browser context.

method waitForTarget

waitForTarget: (
    predicate: (x: Target) => boolean | Promise<boolean>,
    options?: { timeout?: number }
) => Promise<Target>;

• This searches for a target in this specific browser context.

  Parameter predicate

  A function to be run for every target

  Parameter options

  An object of options. Accepts a timeout, which is the maximum wait time in milliseconds. Pass 0 to disable the timeout. Defaults to 30 seconds.

  Returns

  Promise which resolves to the first target found that matches the predicate function.

  Example 1

  An example of finding a target for a page opened via window.open:

  await page.evaluate(() => window.open('https://www.example.com/'));
  const newWindowTarget = await browserContext.waitForTarget(
    target => target.url() === 'https://www.example.com/'
  );

constructor

constructor(options: BrowserFetcherOptions);

• Constructs a browser fetcher for the given options.

method canDownload

canDownload: (revision: string) => Promise<boolean>;

• Initiates a HEAD request to check if the revision is available.

  Parameter revision

  The revision to check availability for.

  Returns

  A promise that resolves to true if the revision could be downloaded from the host.

  Remarks

  This method is affected by the current product.

method download

download: (
    revision: string,
    progressCallback?: (x: number, y: number) => void
) => Promise<BrowserFetcherRevisionInfo | undefined>;

• Initiates a GET request to download the revision from the host.

  Parameter revision

  The revision to download.

  Parameter progressCallback

  A function that will be called with two arguments: How many bytes have been downloaded and the total number of bytes of the download.

  Returns

  A promise with revision information when the revision is downloaded and extracted.

  Remarks

  This method is affected by the current product.

method host

host: () => string;

• Returns

  The download host being used.

method localRevisions

localRevisions: () => string[];

• Returns

  A list of all revision strings (for the current product) available locally on disk.

  Remarks

  This method is affected by the current product.

method platform

platform: () => Platform;

• Returns

  Returns the current Platform, which is one of mac, linux, win32 or win64.

method product

product: () => Product;

• Returns

  Returns the current Product, which is one of chrome or firefox.

method remove

remove: (revision: string) => Promise<void>;

• Parameter revision

  A revision to remove for the current product.

  Returns

  A promise that resolves when the revision has been removes or throws if the revision has not been downloaded.

  Remarks

  This method is affected by the current product.

method revisionInfo

revisionInfo: (revision: string) => BrowserFetcherRevisionInfo;

• Parameter revision

  The revision to get info for.

  Returns

  The revision info for the given revision.

method connection

connection: () => Connection | undefined;

method detach

detach: () => Promise<void>;

• Detaches the cdpSession from the target. Once detached, the cdpSession object won't emit any events and can't be used to send messages.

method id

id: () => string;

• Returns the session's id.

method send

send: <T extends string | number | symbol>(
    method: T,
    ...paramArgs: ProtocolMapping.Commands
) => Promise<ProtocolMapping.Commands[T]['returnType']>;

constructor

constructor(url: string, transport: ConnectionTransport, delay?: number);

method createSession

createSession: (targetInfo: Protocol.Target.TargetInfo) => Promise<CDPSession>;

• Parameter targetInfo

  The target info

  Returns

  The CDP session that is created

method dispose

dispose: () => void;

method fromSession

static fromSession: (session: CDPSession) => Connection | undefined;

method send

send: <T extends string | number | symbol>(
    method: T,
    ...paramArgs: ProtocolMapping.Commands
) => Promise<ProtocolMapping.Commands[T]['returnType']>;

method session

session: (sessionId: string) => CDPSession | null;

• Parameter sessionId

  The session id

  Returns

  The current CDP session if it exists

method url

url: () => string;

constructor

constructor(
    type: ConsoleMessageType,
    text: string,
    args: JSHandle<unknown>[],
    stackTraceLocations: ConsoleMessageLocation[]
);

• Modifiers

  • @public

method args

args: () => JSHandle[];

• Returns

  An array of arguments passed to the console.

method location

location: () => ConsoleMessageLocation;

• Returns

  The location of the console message.

method stackTrace

stackTrace: () => ConsoleMessageLocation[];

• Returns

  The array of locations on the stack of the console message.

method text

text: () => string;

• Returns

  The text of the console message.

method type

type: () => ConsoleMessageType;

• Returns

  The type of the console message.

constructor

constructor(client: CDPSession);

method startCSSCoverage

startCSSCoverage: (options?: CSSCoverageOptions) => Promise<void>;

• Parameter options

  Set of configurable options for coverage, defaults to resetOnNavigation : true

  Returns

  Promise that resolves when coverage is started.

method startJSCoverage

startJSCoverage: (options?: JSCoverageOptions) => Promise<void>;

• Parameter options

  Set of configurable options for coverage defaults to resetOnNavigation : true, reportAnonymousScripts : false, includeRawScriptCoverage : false, useBlockCoverage : true

  Returns

  Promise that resolves when coverage is started.

  Remarks

  Anonymous scripts are ones that don't have an associated url. These are scripts that are dynamically created on the page using eval or new Function. If reportAnonymousScripts is set to true, anonymous scripts URL will start with debugger://VM (unless a magic //# sourceURL comment is present, in which case that will the be URL).

method stopCSSCoverage

stopCSSCoverage: () => Promise<CoverageEntry[]>;

• Returns

  Promise that resolves to the array of coverage reports for all stylesheets.

  Remarks

  CSS Coverage doesn't include dynamically injected style tags without sourceURLs.

method stopJSCoverage

stopJSCoverage: () => Promise<JSCoverageEntry[]>;

• Returns

  Promise that resolves to the array of coverage reports for all scripts.

  Remarks

  JavaScript Coverage doesn't include anonymous scripts by default. However, scripts with sourceURLs are reported.

constructor

constructor(client: CDPSession);

method start

start: (options?: { resetOnNavigation?: boolean }) => Promise<void>;

method stop

stop: () => Promise<CoverageEntry[]>;