---
sidebar_label: API
---

# API Reference

## Classes

| Class                                             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| ------------------------------------------------- |   |
| [Accessibility](./puppeteer.accessibility.md)     | The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by assistive technology such as [screen readers](https://en.wikipedia.org/wiki/Screen_reader) or [switches](https://en.wikipedia.org/wiki/Switch_access).                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [Browser](./puppeteer.browser.md)                 | A Browser is created when Puppeteer connects to a Chromium instance, either through [PuppeteerNode.launch()](./puppeteer.puppeteernode.launch.md) or [Puppeteer.connect()](./puppeteer.puppeteer.connect.md).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [BrowserContext](./puppeteer.browsercontext.md)   | BrowserContexts provide a way to operate multiple independent browser sessions. When a browser is launched, it has a single BrowserContext used by default. The method [Browser.newPage](./puppeteer.browser.newpage.md) creates a page in the default browser context.                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [BrowserFetcher](./puppeteer.browserfetcher.md)   | BrowserFetcher can download and manage different versions of Chromium and Firefox.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [CDPSession](./puppeteer.cdpsession.md)           | The <code>CDPSession</code> instances are used to talk raw Chrome Devtools Protocol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| [Connection](./puppeteer.connection.md)           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [ConsoleMessage](./puppeteer.consolemessage.md)   | ConsoleMessage objects are dispatched by page via the 'console' event.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [Coverage](./puppeteer.coverage.md)               | The Coverage class provides methods to gathers information about parts of JavaScript and CSS that were used by the page.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [CSSCoverage](./puppeteer.csscoverage.md)         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [CustomError](./puppeteer.customerror.md)         |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [Dialog](./puppeteer.dialog.md)                   | Dialog instances are dispatched by the [Page](./puppeteer.page.md) via the <code>dialog</code> event.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| [ElementHandle](./puppeteer.elementhandle.md)     | ElementHandle represents an in-page DOM element.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| [EventEmitter](./puppeteer.eventemitter.md)       | The EventEmitter class that many Puppeteer classes extend.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [FileChooser](./puppeteer.filechooser.md)         | File choosers let you react to the page requesting for a file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| [Frame](./puppeteer.frame.md)                     | <p>Represents a DOM frame.</p><p>To understand frames, you can think of frames as <code>&lt;iframe&gt;</code> elements. Just like iframes, frames can be nested, and when JavaScript is executed in a frame, the JavaScript does not effect frames inside the ambient frame the JavaScript executes in.</p>                                                                                                                                                                                                                                                                                                                                                                                                             |
| [HTTPRequest](./puppeteer.httprequest.md)         | Represents an HTTP request sent by a page.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [HTTPResponse](./puppeteer.httpresponse.md)       | The HTTPResponse class represents responses which are received by the [Page](./puppeteer.page.md) class.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [JSCoverage](./puppeteer.jscoverage.md)           |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [JSHandle](./puppeteer.jshandle.md)               | <p>Represents a reference to a JavaScript object. Instances can be created using [Page.evaluateHandle()](./puppeteer.page.evaluatehandle.md).</p><p>Handles prevent the referenced JavaScript object from being garbage-collected unless the handle is purposely [disposed](./puppeteer.jshandle.dispose.md). JSHandles are auto-disposed when their associated frame is navigated away or the parent context gets destroyed.</p><p>Handles can be used as arguments for any evaluation function such as [Page.$eval()](./puppeteer.page._eval.md), [Page.evaluate()](./puppeteer.page.evaluate.md), and [Page.evaluateHandle()](./puppeteer.page.evaluatehandle.md). They are resolved to their referenced object.</p> |
| [Keyboard](./puppeteer.keyboard.md)               | Keyboard provides an api for managing a virtual keyboard. The high level api is [Keyboard.type()](./puppeteer.keyboard.type.md), which takes raw characters and generates proper keydown, keypress/input, and keyup events on your page.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| [Mouse](./puppeteer.mouse.md)                     | The Mouse class operates in main-frame CSS pixels relative to the top-left corner of the viewport.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [Page](./puppeteer.page.md)                       | <p>Page provides methods to interact with a single tab or [extension background page](https://developer.chrome.com/extensions/background_pages) in Chromium.</p><p>:::note</p><p>One Browser instance might have multiple Page instances.</p><p>:::</p>                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| [ProtocolError](./puppeteer.protocolerror.md)     | ProtocolError is emitted whenever there is an error from the protocol.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [Puppeteer](./puppeteer.puppeteer.md)             | <p>The main Puppeteer class.</p><p>IMPORTANT: if you are using Puppeteer in a Node environment, you will get an instance of [PuppeteerNode](./puppeteer.puppeteernode.md) when you import or require <code>puppeteer</code>. That class extends <code>Puppeteer</code>, so has all the methods documented below as well as all that are defined on [PuppeteerNode](./puppeteer.puppeteernode.md).</p>                                                                                                                                                                                                                                                                                                                   |
| [PuppeteerNode](./puppeteer.puppeteernode.md)     | <p>Extends the main [Puppeteer](./puppeteer.puppeteer.md) class with Node specific behaviour for fetching and downloading browsers.</p><p>If you're using Puppeteer in a Node environment, this is the class you'll get when you run <code>require('puppeteer')</code> (or the equivalent ES <code>import</code>).</p>                                                                                                                                                                                                                                                                                                                                                                                                  |
| [SecurityDetails](./puppeteer.securitydetails.md) | The SecurityDetails class represents the security details of a response that was received over a secure connection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| [Target](./puppeteer.target.md)                   |                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| [TimeoutError](./puppeteer.timeouterror.md)       | TimeoutError is emitted whenever certain operations are terminated due to timeout.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| [Touchscreen](./puppeteer.touchscreen.md)         | The Touchscreen class exposes touchscreen events.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [Tracing](./puppeteer.tracing.md)                 | The Tracing class exposes the tracing audit interface.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [WebWorker](./puppeteer.webworker.md)             | This class represents a [WebWorker](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |

## Enumerations

| Enumeration                                                               | Description                                                           |
| ------------------------------------------------------------------------- | --------------------------------------------------------------------- |
| [BrowserContextEmittedEvents](./puppeteer.browsercontextemittedevents.md) |                                                                       |
| [BrowserEmittedEvents](./puppeteer.browseremittedevents.md)               | All the events a [browser instance](./puppeteer.browser.md) may emit. |
| [InterceptResolutionAction](./puppeteer.interceptresolutionaction.md)     |                                                                       |
| [PageEmittedEvents](./puppeteer.pageemittedevents.md)                     | All the events that a page instance may emit.                         |

## Functions

| Function                                                                               | Description                                                            |
| -------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| [clearCustomQueryHandlers()](./puppeteer.clearcustomqueryhandlers.md)                  | Clears all registered handlers.                                        |
| [customQueryHandlerNames()](./puppeteer.customqueryhandlernames.md)                    |                                                                        |
| [registerCustomQueryHandler(name, handler)](./puppeteer.registercustomqueryhandler.md) | Registers a [custom query handler](./puppeteer.customqueryhandler.md). |
| [unregisterCustomQueryHandler(name)](./puppeteer.unregistercustomqueryhandler.md)      |                                                                        |

## Interfaces

| Interface                                                                   | Description                                                                                                                                                                                         |
| --------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [BoundingBox](./puppeteer.boundingbox.md)                                   |                                                                                                                                                                                                     |
| [BoxModel](./puppeteer.boxmodel.md)                                         |                                                                                                                                                                                                     |
| [BrowserConnectOptions](./puppeteer.browserconnectoptions.md)               | Generic browser options that can be passed when launching any browser or when connecting to an existing browser instance.                                                                           |
| [BrowserContextOptions](./puppeteer.browsercontextoptions.md)               | BrowserContext options.                                                                                                                                                                             |
| [BrowserFetcherOptions](./puppeteer.browserfetcheroptions.md)               |                                                                                                                                                                                                     |
| [BrowserFetcherRevisionInfo](./puppeteer.browserfetcherrevisioninfo.md)     |                                                                                                                                                                                                     |
| [BrowserLaunchArgumentOptions](./puppeteer.browserlaunchargumentoptions.md) | Launcher options that only apply to Chrome.                                                                                                                                                         |
| [CDPSessionOnMessageObject](./puppeteer.cdpsessiononmessageobject.md)       |                                                                                                                                                                                                     |
| [ClickOptions](./puppeteer.clickoptions.md)                                 |                                                                                                                                                                                                     |
| [CommonEventEmitter](./puppeteer.commoneventemitter.md)                     |                                                                                                                                                                                                     |
| [ConnectionCallback](./puppeteer.connectioncallback.md)                     |                                                                                                                                                                                                     |
| [ConnectionTransport](./puppeteer.connectiontransport.md)                   |                                                                                                                                                                                                     |
| [ConnectOptions](./puppeteer.connectoptions.md)                             |                                                                                                                                                                                                     |
| [ConsoleMessageLocation](./puppeteer.consolemessagelocation.md)             |                                                                                                                                                                                                     |
| [ContinueRequestOverrides](./puppeteer.continuerequestoverrides.md)         |                                                                                                                                                                                                     |
| [CoverageEntry](./puppeteer.coverageentry.md)                               | The CoverageEntry class represents one entry of the coverage report.                                                                                                                                |
| [Credentials](./puppeteer.credentials.md)                                   |                                                                                                                                                                                                     |
| [CSSCoverageOptions](./puppeteer.csscoverageoptions.md)                     | Set of configurable options for CSS coverage.                                                                                                                                                       |
| [CustomQueryHandler](./puppeteer.customqueryhandler.md)                     |                                                                                                                                                                                                     |
| [Device](./puppeteer.device.md)                                             |                                                                                                                                                                                                     |
| [FrameAddScriptTagOptions](./puppeteer.frameaddscripttagoptions.md)         |                                                                                                                                                                                                     |
| [FrameAddStyleTagOptions](./puppeteer.frameaddstyletagoptions.md)           |                                                                                                                                                                                                     |
| [FrameWaitForFunctionOptions](./puppeteer.framewaitforfunctionoptions.md)   |                                                                                                                                                                                                     |
| [GeolocationOptions](./puppeteer.geolocationoptions.md)                     |                                                                                                                                                                                                     |
| [InterceptResolutionState](./puppeteer.interceptresolutionstate.md)         |                                                                                                                                                                                                     |
| [InternalNetworkConditions](./puppeteer.internalnetworkconditions.md)       |                                                                                                                                                                                                     |
| [JSCoverageEntry](./puppeteer.jscoverageentry.md)                           | The CoverageEntry class for JavaScript                                                                                                                                                              |
| [JSCoverageOptions](./puppeteer.jscoverageoptions.md)                       | Set of configurable options for JS coverage.                                                                                                                                                        |
| [LaunchOptions](./puppeteer.launchoptions.md)                               | Generic launch options that can be passed when launching any browser.                                                                                                                               |
| [MediaFeature](./puppeteer.mediafeature.md)                                 |                                                                                                                                                                                                     |
| [Metrics](./puppeteer.metrics.md)                                           |                                                                                                                                                                                                     |
| [MouseOptions](./puppeteer.mouseoptions.md)                                 |                                                                                                                                                                                                     |
| [MouseWheelOptions](./puppeteer.mousewheeloptions.md)                       |                                                                                                                                                                                                     |
| [NetworkConditions](./puppeteer.networkconditions.md)                       |                                                                                                                                                                                                     |
| [Offset](./puppeteer.offset.md)                                             |                                                                                                                                                                                                     |
| [PageEventObject](./puppeteer.pageeventobject.md)                           | <p>Denotes the objects received by callback functions for page events.</p><p>See [PageEmittedEvents](./puppeteer.pageemittedevents.md) for more detail on the events and when they are emitted.</p> |
| [PDFMargin](./puppeteer.pdfmargin.md)                                       |                                                                                                                                                                                                     |
| [PDFOptions](./puppeteer.pdfoptions.md)                                     | Valid options to configure PDF generation via [Page.pdf()](./puppeteer.page.pdf.md).                                                                                                                |
| [Point](./puppeteer.point.md)                                               |                                                                                                                                                                                                     |
| [PressOptions](./puppeteer.pressoptions.md)                                 |                                                                                                                                                                                                     |
| [ProductLauncher](./puppeteer.productlauncher.md)                           | Describes a launcher - a class that is able to create and launch a browser instance.                                                                                                                |
| [PuppeteerErrors](./puppeteer.puppeteererrors.md)                           |                                                                                                                                                                                                     |
| [PuppeteerLaunchOptions](./puppeteer.puppeteerlaunchoptions.md)             |                                                                                                                                                                                                     |
| [RemoteAddress](./puppeteer.remoteaddress.md)                               |                                                                                                                                                                                                     |
| [ResponseForRequest](./puppeteer.responseforrequest.md)                     | Required response data to fulfill a request with.                                                                                                                                                   |
| [ScreenshotClip](./puppeteer.screenshotclip.md)                             |                                                                                                                                                                                                     |
| [ScreenshotOptions](./puppeteer.screenshotoptions.md)                       |                                                                                                                                                                                                     |
| [SerializedAXNode](./puppeteer.serializedaxnode.md)                         | Represents a Node and the properties of it that are relevant to Accessibility.                                                                                                                      |
| [SnapshotOptions](./puppeteer.snapshotoptions.md)                           |                                                                                                                                                                                                     |
| [TracingOptions](./puppeteer.tracingoptions.md)                             |                                                                                                                                                                                                     |
| [Viewport](./puppeteer.viewport.md)                                         | Sets the viewport of the page.                                                                                                                                                                      |
| [WaitForOptions](./puppeteer.waitforoptions.md)                             |                                                                                                                                                                                                     |
| [WaitForSelectorOptions](./puppeteer.waitforselectoroptions.md)             |                                                                                                                                                                                                     |
| [WaitForTargetOptions](./puppeteer.waitfortargetoptions.md)                 |                                                                                                                                                                                                     |
| [WaitTimeoutOptions](./puppeteer.waittimeoutoptions.md)                     |                                                                                                                                                                                                     |

## Variables

| Variable                                                                                      | Description                                                                                                                                                                                                                                                                                                                                                                     |
| --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [connect](./puppeteer.connect.md)                                                             |                                                                                                                                                                                                                                                                                                                                                                                 |
| [createBrowserFetcher](./puppeteer.createbrowserfetcher.md)                                   |                                                                                                                                                                                                                                                                                                                                                                                 |
| [DEFAULT_INTERCEPT_RESOLUTION_PRIORITY](./puppeteer.default_intercept_resolution_priority.md) | The default cooperative request interception resolution priority                                                                                                                                                                                                                                                                                                                |
| [defaultArgs](./puppeteer.defaultargs.md)                                                     |                                                                                                                                                                                                                                                                                                                                                                                 |
| [devices](./puppeteer.devices.md)                                                             | A list of devices to be used with <code>page.emulate(options)</code>. Actual list of devices can be found in [src/common/DeviceDescriptors.ts](https://github.com/puppeteer/puppeteer/blob/main/src/common/DeviceDescriptors.ts).                                                                                                                                               |
| [errors](./puppeteer.errors.md)                                                               | <p>Puppeteer methods might throw errors if they are unable to fulfill a request. For example, <code>page.waitForSelector(selector[, options])</code> might fail if the selector doesn't match any nodes during the given timeframe.</p><p>For certain types of errors Puppeteer uses specific error classes. These classes are available via <code>puppeteer.errors</code>.</p> |
| [EVALUATION_SCRIPT_URL](./puppeteer.evaluation_script_url.md)                                 |                                                                                                                                                                                                                                                                                                                                                                                 |
| [executablePath](./puppeteer.executablepath.md)                                               |                                                                                                                                                                                                                                                                                                                                                                                 |
| [launch](./puppeteer.launch.md)                                                               |                                                                                                                                                                                                                                                                                                                                                                                 |
| [networkConditions](./puppeteer.networkconditions.md)                                         | A list of network conditions to be used with <code>page.emulateNetworkConditions(networkConditions)</code>. Actual list of predefined conditions can be found in [src/common/NetworkConditions.ts](https://github.com/puppeteer/puppeteer/blob/main/src/common/NetworkConditions.ts).                                                                                           |

## Type Aliases

| Type Alias                                                                | Description                                                                                                                                             |
| ------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| [ActionResult](./puppeteer.actionresult.md)                               |                                                                                                                                                         |
| [Awaitable](./puppeteer.awaitable.md)                                     |                                                                                                                                                         |
| [ChromeReleaseChannel](./puppeteer.chromereleasechannel.md)               |                                                                                                                                                         |
| [ConsoleMessageType](./puppeteer.consolemessagetype.md)                   | The supported types for console messages.                                                                                                               |
| [DevicesMap](./puppeteer.devicesmap.md)                                   |                                                                                                                                                         |
| [ErrorCode](./puppeteer.errorcode.md)                                     |                                                                                                                                                         |
| [EvaluateFunc](./puppeteer.evaluatefunc.md)                               |                                                                                                                                                         |
| [EventType](./puppeteer.eventtype.md)                                     |                                                                                                                                                         |
| [FlattenHandle](./puppeteer.flattenhandle.md)                             |                                                                                                                                                         |
| [HandleFor](./puppeteer.handlefor.md)                                     |                                                                                                                                                         |
| [HandleOr](./puppeteer.handleor.md)                                       |                                                                                                                                                         |
| [Handler](./puppeteer.handler.md)                                         |                                                                                                                                                         |
| [InnerParams](./puppeteer.innerparams.md)                                 |                                                                                                                                                         |
| [InterceptResolutionStrategy](./puppeteer.interceptresolutionstrategy.md) |                                                                                                                                                         |
| [KeyInput](./puppeteer.keyinput.md)                                       | All the valid keys that can be passed to functions that take user input, such as [keyboard.press](./puppeteer.keyboard.press.md)                        |
| [LowerCasePaperFormat](./puppeteer.lowercasepaperformat.md)               |                                                                                                                                                         |
| [MouseButton](./puppeteer.mousebutton.md)                                 |                                                                                                                                                         |
| [NodeFor](./puppeteer.nodefor.md)                                         |                                                                                                                                                         |
| [PaperFormat](./puppeteer.paperformat.md)                                 | All the valid paper format types when printing a PDF.                                                                                                   |
| [Permission](./puppeteer.permission.md)                                   |                                                                                                                                                         |
| [Platform](./puppeteer.platform.md)                                       | Supported platforms.                                                                                                                                    |
| [Product](./puppeteer.product.md)                                         | Supported products.                                                                                                                                     |
| [ProtocolLifeCycleEvent](./puppeteer.protocollifecycleevent.md)           |                                                                                                                                                         |
| [PuppeteerLifeCycleEvent](./puppeteer.puppeteerlifecycleevent.md)         |                                                                                                                                                         |
| [PuppeteerNodeLaunchOptions](./puppeteer.puppeteernodelaunchoptions.md)   | Utility type exposed to enable users to define options that can be passed to <code>puppeteer.launch</code> without having to list the set of all types. |
| [ResourceType](./puppeteer.resourcetype.md)                               | Resource types for HTTPRequests as perceived by the rendering engine.                                                                                   |
| [TargetFilterCallback](./puppeteer.targetfiltercallback.md)               |                                                                                                                                                         |
