The Chrome DevTools Protocol.

Audits domain allows investigation of page violations and possible improvements.

Defines events for background web platform features.

The Browser domain defines methods and events for browser managing.

A domain for interacting with Cast, Presentation API, and Remote Playback API functionalities.

This domain is deprecated - use Runtime or Log instead.

This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles) have an associated id used in subsequent operations on the related object. Each object type has a specific id structure, and those are not interchangeable between objects of different kinds. CSS objects can be loaded using the get*ForNode() calls (which accept a DOM node id). A client can also keep track of stylesheets via the styleSheetAdded/styleSheetRemoved events and subsequently load the required stylesheet contents using the getStyleSheet[Text]() methods.

Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing breakpoints, stepping through execution, exploring stack traces, etc.

This domain exposes DOM read/write operations. Each DOM Node is represented with its mirror object that has an id. This id can be used to get additional information on the Node, resolve it into the JavaScript object wrapper, etc. It is important that client receives DOM events only for the nodes that are known to the client. Backend keeps track of the nodes that were sent to the client and never sends the same node twice. It is client's responsibility to collect information about the nodes that were sent to the client.Note that iframe owner elements will return corresponding document elements as their child nodes.

DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript execution will stop on these operations as if there was a regular breakpoint set.

This domain facilitates obtaining document snapshots with DOM, layout, and style information.

Query and modify DOM storage.

This domain emulates different environments for the page.

EventBreakpoints permits setting breakpoints on particular operations and events in targets that run JavaScript but do not have a DOM. JavaScript execution will stop on these operations as if there was a regular breakpoint set.

A domain for letting clients substitute browser's network layer with client code.

This domain provides experimental commands only supported in headless mode.

Input/Output operations for streams produced by DevTools.

Provides access to log entries.

This domain allows detailed inspection of media elements

Network domain allows tracking network activities of the page. It exposes information about http, file, data and other requests and responses, their headers, bodies, timing, etc.

This domain provides various functionality related to drawing atop the inspected page.

Actions and events related to the inspected page belong to the page domain.

Reporting of performance timeline events, as specified in https://w3c.github.io/performance-timeline/#dom-performanceobserver.

Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects. Evaluation results are returned as mirror object that expose object type, string representation and unique identifier that can be used for further object reference. Original objects are maintained in memory unless they are either explicitly released or are released along with the other objects in their object group.

This domain is deprecated.

Security

The SystemInfo domain defines methods and events for querying low-level system information.

Supports additional targets discovery and allows to attach to them.

The Tethering domain defines methods and events for browser port binding.

This domain allows inspection of Web Audio API. https://webaudio.github.io/web-audio-api/

This domain allows configuring virtual authenticators to test the WebAuthn API.

The Chrome DevTools Protocol.

Audits domain allows investigation of page violations and possible improvements.

Defines events for background web platform features.

The Browser domain defines methods and events for browser managing.

A domain for interacting with Cast, Presentation API, and Remote Playback API functionalities.

This domain is deprecated - use Runtime or Log instead.

This domain exposes CSS read/write operations. All CSS objects (stylesheets, rules, and styles) have an associated id used in subsequent operations on the related object. Each object type has a specific id structure, and those are not interchangeable between objects of different kinds. CSS objects can be loaded using the get*ForNode() calls (which accept a DOM node id). A client can also keep track of stylesheets via the styleSheetAdded/styleSheetRemoved events and subsequently load the required stylesheet contents using the getStyleSheet[Text]() methods.

Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing breakpoints, stepping through execution, exploring stack traces, etc.

This domain exposes DOM read/write operations. Each DOM Node is represented with its mirror object that has an id. This id can be used to get additional information on the Node, resolve it into the JavaScript object wrapper, etc. It is important that client receives DOM events only for the nodes that are known to the client. Backend keeps track of the nodes that were sent to the client and never sends the same node twice. It is client's responsibility to collect information about the nodes that were sent to the client.Note that iframe owner elements will return corresponding document elements as their child nodes.

DOM debugging allows setting breakpoints on particular DOM operations and events. JavaScript execution will stop on these operations as if there was a regular breakpoint set.

This domain facilitates obtaining document snapshots with DOM, layout, and style information.

Query and modify DOM storage.

This domain emulates different environments for the page.

EventBreakpoints permits setting breakpoints on particular operations and events in targets that run JavaScript but do not have a DOM. JavaScript execution will stop on these operations as if there was a regular breakpoint set.

A domain for letting clients substitute browser's network layer with client code.

This domain provides experimental commands only supported in headless mode.

Input/Output operations for streams produced by DevTools.

Provides access to log entries.

This domain allows detailed inspection of media elements

Network domain allows tracking network activities of the page. It exposes information about http, file, data and other requests and responses, their headers, bodies, timing, etc.

This domain provides various functionality related to drawing atop the inspected page.

Actions and events related to the inspected page belong to the page domain.

Reporting of performance timeline events, as specified in https://w3c.github.io/performance-timeline/#dom-performanceobserver.

Runtime domain exposes JavaScript runtime by means of remote evaluation and mirror objects. Evaluation results are returned as mirror object that expose object type, string representation and unique identifier that can be used for further object reference. Original objects are maintained in memory unless they are either explicitly released or are released along with the other objects in their object group.

This domain is deprecated.

Security

The SystemInfo domain defines methods and events for querying low-level system information.

Supports additional targets discovery and allows to attach to them.

The Tethering domain defines methods and events for browser port binding.

This domain allows inspection of Web Audio API. https://webaudio.github.io/web-audio-api/

This domain allows configuring virtual authenticators to test the WebAuthn API.

Mappings from protocol event and command names to the types required for them.

The Accessibility class provides methods for inspecting Chromium's accessibility tree. The accessibility tree is used by assistive technology such as screen readers or switches.

A Browser is created when Puppeteer connects to a Chromium instance, either through PuppeteerNode.launch or Puppeteer.connect.

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 | Browser.newPage creates a page in the default browser context.

The CDPSession instances are used to talk raw Chrome Devtools Protocol.

ConsoleMessage objects are dispatched by page via the 'console' event.

The Coverage class provides methods to gathers information about parts of JavaScript and CSS that were used by the page.

Dialog instances are dispatched by the Page via the dialog event.

ElementHandle represents an in-page DOM element.

The EventEmitter class that many Puppeteer classes extend.

This class represents a context for JavaScript execution. A [Page] might have many execution contexts:

• each frame has "default" execution context that is always created after frame is attached to DOM. This context is returned by the Frame.executionContext method.
• Extension's content scripts create additional execution contexts.

File choosers let you react to the page requesting for a file.

At every point of time, page exposes its current frame tree via the Page.mainFrame | page.mainFrame and Frame.childFrames | frame.childFrames methods.

Represents an HTTP request sent by a page.

The HTTPResponse class represents responses which are received by the Page class.

Represents an in-page JavaScript object. JSHandles can be created with the Page.evaluateHandle | page.evaluateHandle method.

Keyboard provides an api for managing a virtual keyboard. The high level api is Keyboard."type", which takes raw characters and generates proper keydown, keypress/input, and keyup events on your page.

The Mouse class operates in main-frame CSS pixels relative to the top-left corner of the viewport.

Page provides methods to interact with a single tab or extension background page in Chromium.

ProtocolError is emitted whenever there is an error from the protocol.

The main Puppeteer class.

The SecurityDetails class represents the security details of a response that was received over a secure connection.

TimeoutError is emitted whenever certain operations are terminated due to timeout.

The Touchscreen class exposes touchscreen events.

The Tracing class exposes the tracing audit interface.

The WebWorker class represents a WebWorker.

All the events a Browser | browser instance may emit.

All the events that a page instance may emit.

Internal events that the CDPSession class emits.

Internal events that the Connection class emits.

Users should never call this directly; it's called when calling puppeteer.connect.

The default cooperative request interception resolution priority

We use symbols to prevent external parties listening to these events. They are internal to Puppeteer.

We use symbols to prevent any external parties listening to these events. They are internal to Puppeteer.

Generic browser options that can be passed when launching any browser or when connecting to an existing browser instance.

BrowserContext options.

Launcher options that only apply to Chrome.

Settings that are common to the Puppeteer class, regardless of environment.

The CoverageEntry class represents one entry of the coverage report.

Set of configurable options for CSS coverage.

Contains two functions queryOne and queryAll that can be Puppeteer.registerCustomQueryHandler | registered as alternative querying strategies. The functions queryOne and queryAll are executed in the page context. queryOne should take an Element and a selector string as argument and return a single Element or null if no element is found. queryAll takes the same arguments but should instead return a NodeListOf<any> or Array<any> with all the elements that match the given query selector.

A node in the accessibility tree.

A single computed AX property.

A single source for a computed AX property.

The loadComplete event mirrors the load complete event sent by the browser to assistive technology when the web page has finished loading.

The nodesUpdated event is sent every time a previously requested node has changed the in tree.

Animation instance.

Event for when an animation has been cancelled.

Event for each animation that has been created.

AnimationEffect instance

Event for animation that has been started.

Keyframes Rule

Keyframe Style

Information about a cookie that is affected by an inspector issue.

Information about the frame affected by an inspector issue.

Information about a request that is affected by an inspector issue.

Details for issues around "Attribution Reporting API" usage. Explainer: https://github.com/WICG/conversion-measurement-api

Details for a request that has been blocked with the BLOCKED_BY_RESPONSE code. Currently only used for COEP/COOP, but may be extended to include some CSP errors in the future.

This issue tracks client hints related issues. It's used to deprecate old features, encourage the use of new ones, and provide general guidance.

This information is currently necessary, as the front-end has a difficult time finding a specific cookie. With this, we can convey specific error information without the cookie.

Details for a CORS related issue, e.g. a warning or error related to CORS RFC1918 enforcement.

This issue tracks information needed to print a deprecation message. The formatting is inherited from the old console.log version, see more at: https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/frame/deprecation.cc TODO(crbug.com/1264960): Re-work format to add i18n support per: https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/public/devtools_protocol/README.md

Depending on the concrete errorType, different properties are set.

An inspector issue reported from the back-end.

This struct holds a list of optional fields with additional information specific to the kind of issue. When adding a new issue code, please also add a new optional field to this type.

Details for issues about documents in Quirks Mode or Limited Quirks Mode that affects page layouting.

Details for a issue arising from an SAB being instantiated in, or transferred to a context that is not cross-origin isolated.

Called with all existing backgroundServiceEvents when enabled, and all new events afterwards if enabled and recording.

A key-value pair for additional event information to pass along.

Called when the recording state for the service has been updated.

Browser window bounds information

Chrome histogram bucket.

Fired when download makes progress. Last call has |done| == true.

Fired when page is about to start a download.

Chrome histogram.

Definition of PermissionDescriptor defined in the Permissions API: https://w3c.github.io/permissions/#dictdef-permissiondescriptor.

Cache identifier.

Cached response

Data entry.

This is fired whenever the outstanding issue/error message changes. |issueMessage| is empty if there is no issue.

This is fired whenever the list of available sinks changes. A sink is a device or a software surface that you can cast to.

Console message.

Issued when new console message is added.

CSS container query rule descriptor.

CSS keyframe rule representation.

CSS keyframes rule representation.

CSS Layer at-rule descriptor.

CSS Layer data.

CSS media rule descriptor.

CSS property declaration data.

CSS rule representation.

CSS style representation.

CSS stylesheet metainformation.

CSS Supports at-rule descriptor.

Properties of a web font: https://www.w3.org/TR/2008/REC-CSS2-20080411/fonts.html#font-descriptions and additional information such as platformFontFamily and fontVariationAxes.

Fires whenever a web font is updated. A non-empty font parameter indicates a successfully loaded web font

Information about font variation axes for variable fonts

Inherited pseudo element matches from pseudos of an ancestor node.

Inherited CSS rule collection from ancestor node.

Media query descriptor.

Media query expression descriptor.

Information about amount of glyphs that were rendered with given font.

CSS rule collection for a single pseudo style.

Match data for a CSS rule.

CSS coverage information.

Selector list data.

Text range within a resource. All numbers are zero-based.

A descriptor of operation to mutate style declaration text.

Fired whenever an active document stylesheet is added.

Fired whenever a stylesheet is changed as a result of the client operation.

Fired whenever an active document stylesheet is removed.

Data for a simple selector (these are delimited by commas in a selector list).

Database object.

Database error.

Fired when breakpoint is resolved to an actual script and location.

JavaScript call frame. Array of call frames form the call stack.

Debug symbols available for a wasm script.

Location in the source code.

Location range within one script.

Fired when the virtual machine stopped on breakpoint or exception or any other stop criteria.

Scope description.

Fired when virtual machine fails to parse the script.

Fired when virtual machine parses script. This event is also fired for all known and uncollected scripts upon enabling debugger.

Location in the source code.

Search match for resource.

Fired when Element's attribute is modified.

Fired when Element's attribute is removed.

Backend node with a friendly name.

Box model.

Mirrors DOMCharacterDataModified event.

Fired when Container's child node count has changed.

Mirrors DOMNodeInserted event.

Mirrors DOMNodeRemoved event.

Called when distribution is changed.

Fired when Element's inline style is modified via a CSS property modification.

DOM interaction is implemented in terms of mirror objects that represent the actual DOM nodes. DOMNode is a base node mirror type.

Called when a pseudo element is added to an element.

Called when a pseudo element is removed from an element.

Rectangle.

A structure holding an RGBA color.

Fired when backend wants to provide client with the missing DOM structure. This happens upon most of the calls requesting node ids.

Called when shadow root is popped from the element.

Called when shadow root is pushed into the element.

CSS Shape Outside details.

Object event listener.

A subset of the full ComputedStyle as defined by the request whitelist.

Document snapshot.

A Node in the DOM tree.

Details of post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions.

Details of an element in the DOM tree with a LayoutObject.

Table of details of an element in the DOM tree with a LayoutObject.

A name/value pair.

Table containing nodes.

Data that is only present on rare nodes.

Table of details of the post layout rendered text positions. The exact layout should not be regarded as stable and may change between versions.

DOM Storage identifier.

Screen orientation.

Used to specify User Agent Cient Hints to emulate. See https://wicg.github.io/ua-client-hints

Used to specify User Agent Cient Hints to emulate. See https://wicg.github.io/ua-client-hints Missing optional values will be filled in by the target with what it would normally use.

Authorization challenge for HTTP status code 401 or 407.

Response to an AuthChallenge.

Issued when the domain is enabled with handleAuthRequests set to true. The request is paused until client responds with continueWithAuth.

Response HTTP header entry

Issued when the domain is enabled and the request URL matches the specified filter. The request is paused until the client responds with one of continueRequest, failRequest or fulfillRequest. The stage of the request can be determined by presence of responseErrorReason and responseStatusCode -- the request is at the response stage if either of these fields is present and in the request stage otherwise.

Issued when the target starts or stops needing BeginFrames. Deprecated. Issue beginFrame unconditionally instead and use result from beginFrame to detect whether the frames were suppressed.

Encoding options for a screenshot.

If heap objects tracking has been started then backend may send update for one or more fragments

If heap objects tracking has been started then backend regularly sends a current value for last seen object id and corresponding timestamp. If the were changes in the heap since last event then one or more heapStatsUpdate events will be sent before a new lastSeenObjectId event.

Sampling profile.

Sampling Heap Profile node. Holds callsite information, allocation statistics and child nodes.

A single sample from a sampling profile.

Database with an array of object stores.

Data entry.

Key.

Key path.

Key range.

Object store.

Object store index.

Emitted only when Input.setInterceptDrags is enabled. Use this data with Input.dispatchDragEvent to restore normal drag and drop behavior.

Fired when remote debugging connection is about to be terminated. Contains detach reason.

Information about a compositing layer.

Serialized fragment of layer picture along with its offset within the layer.

Rectangle where scrolling happens on the main thread.

Sticky position constraints.

Issued when new message was logged.

Log entry.

Violation configuration setting.

Corresponds to kMediaError

Send a list of any errors that need to be delivered.

Corresponds to kMediaEventTriggered

Send events as a list, allowing them to be batched on the browser for less congestion. If batched, events must ALWAYS be in chronological order.

Have one type per entry in MediaLogRecord::Type Corresponds to kMessage

Send a list of any messages that need to be delivered.

This can be called multiple times, and can be used to set / override / remove player properties. A null propValue indicates removal.

Corresponds to kMediaPropertyChange

Called whenever a player is created, or when a new agent joins and receives a list of active players. If an agent is restored, it will receive the full list of player ids and all events again.

Executable module information

Array of heap profile samples.

Heap profile sample.

Authorization challenge for HTTP status code 401 or 407.

Response to an AuthChallenge.

A cookie with was not sent with a request with the corresponding reason.

A cookie which was not stored from a response with the corresponding reason.

Information about the cached resource.

Cookie object

Cookie parameter object

Fired when data chunk was received over the network.

Fired when EventSource message is received.

Request / response headers as keys / values of JSON object.

Information about the request initiator.

Fired when HTTP request has failed to load.

Fired when HTTP request has finished loading.

An options object that may be extended later to better support CORS, CORB and streaming.

An object providing the result of a network resource load.

Post data entry for HTTP request

An object representing a report generated by the Reporting API.

Is sent whenever a new report is added. And after 'enableReportingApi' for all existing reports.

HTTP request data.

Details of an intercepted HTTP request, which must be either allowed, blocked, modified or mocked. Deprecated, use Fetch.requestPaused instead.

Request pattern for interception.

Fired if request ended up loading from cache.

Fired when page is about to send HTTP request.

Fired when additional information about a requestWillBeSent event is available from the network stack. Not every requestWillBeSent event will have an additional requestWillBeSentExtraInfo fired for it, and there is no guarantee whether requestWillBeSent or requestWillBeSentExtraInfo will be fired first for the same request.

Fired when resource loading priority is changed

Timing information for the request.

HTTP response data.

Fired when HTTP response is available.

Fired when additional information about a responseReceived event is available from the network stack. Not every responseReceived event will have an additional responseReceivedExtraInfo for it, and responseReceivedExtraInfo may be fired before or after responseReceived.

Security details about a request.

Details of a signed certificate timestamp (SCT).

Information about a signed exchange response.

Information about a signed exchange header. https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#cbor-representation

Information about a signed exchange response.

Fired when a signed exchange was received over the network

Information about a signed exchange signature. https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html#rfc.section.3.1

Fired when request for resources within a .wbn file failed.

Fired when handling requests for resources within a .wbn file. Note: this will only be fired for resources that are requested by the webpage.

Fired once when parsing the .wbn file has failed.

Fired once when parsing the .wbn file has succeeded. The event contains the information about the web bundle contents.

Fired exactly once for each Trust Token operation. Depending on the type of the operation and whether the operation succeeded or failed, the event is fired before the corresponding request was sent or after the response was received.

Determines what type of Trust Token operation is executed and depending on the type, some additional parameters. The values are specified in third_party/blink/renderer/core/fetch/trust_token.idl.

Fired when WebSocket is closed.

Fired upon WebSocket creation.

WebSocket message data. This represents an entire WebSocket message, not just a fragmented frame as the name suggests.

Fired when WebSocket message error occurs.

Fired when WebSocket message is received.

Fired when WebSocket message is sent.

Fired when WebSocket handshake response becomes available.

WebSocket request data.

WebSocket response data.

Fired when WebSocket is about to initiate handshake.