Skip to main content
Module

x/puppeteer/mod.ts>ProtocolMapping.Commands

A port of puppeteer running on Deno
Latest
interface ProtocolMapping.Commands
import { type ProtocolMapping } from "https://deno.land/x/puppeteer@16.2.0/mod.ts";
const { Commands } = ProtocolMapping;

Properties

Console.clearMessages: { paramsType: []; returnType: void; }

Does nothing.

Console.disable: { paramsType: []; returnType: void; }

Disables console domain, prevents further console messages from being reported to the client.

Console.enable: { paramsType: []; returnType: void; }

Enables console domain, sends the messages collected so far to the client by means of the messageAdded notification.

Debugger.continueToLocation: { paramsType: [Protocol.Debugger.ContinueToLocationRequest]; returnType: void; }

Continues execution until specific location is reached.

Debugger.disable: { paramsType: []; returnType: void; }

Disables debugger for given page.

Debugger.enable: { paramsType: [Protocol.Debugger.EnableRequest]; returnType: Protocol.Debugger.EnableResponse; }

Enables debugger for the given page. Clients should not assume that the debugging has been enabled until the result for this command is received.

Debugger.evaluateOnCallFrame: { paramsType: [Protocol.Debugger.EvaluateOnCallFrameRequest]; returnType: Protocol.Debugger.EvaluateOnCallFrameResponse; }

Evaluates expression on a given call frame.

Debugger.getPossibleBreakpoints: { paramsType: [Protocol.Debugger.GetPossibleBreakpointsRequest]; returnType: Protocol.Debugger.GetPossibleBreakpointsResponse; }

Returns possible locations for breakpoint. scriptId in start and end range locations should be the same.

Debugger.getScriptSource: { paramsType: [Protocol.Debugger.GetScriptSourceRequest]; returnType: Protocol.Debugger.GetScriptSourceResponse; }

Returns source for the script with given id.

Debugger.getWasmBytecode: { paramsType: [Protocol.Debugger.GetWasmBytecodeRequest]; returnType: Protocol.Debugger.GetWasmBytecodeResponse; }

This command is deprecated. Use getScriptSource instead.

Debugger.getStackTrace: { paramsType: [Protocol.Debugger.GetStackTraceRequest]; returnType: Protocol.Debugger.GetStackTraceResponse; }

Returns stack trace with given stackTraceId.

Debugger.pause: { paramsType: []; returnType: void; }

Stops on the next JavaScript statement.

Debugger.pauseOnAsyncCall: { paramsType: [Protocol.Debugger.PauseOnAsyncCallRequest]; returnType: void; }
Debugger.removeBreakpoint: { paramsType: [Protocol.Debugger.RemoveBreakpointRequest]; returnType: void; }

Removes JavaScript breakpoint.

Debugger.restartFrame: { paramsType: [Protocol.Debugger.RestartFrameRequest]; returnType: Protocol.Debugger.RestartFrameResponse; }

Restarts particular call frame from the beginning. The old, deprecated behavior of restartFrame is to stay paused and allow further CDP commands after a restart was scheduled. This can cause problems with restarting, so we now continue execution immediatly after it has been scheduled until we reach the beginning of the restarted frame.

To stay back-wards compatible, restartFrame now expects a mode parameter to be present. If the mode parameter is missing, restartFrame errors out.

The various return values are deprecated and callFrames is always empty. Use the call frames from the Debugger#paused events instead, that fires once V8 pauses at the beginning of the restarted function.

Debugger.resume: { paramsType: [Protocol.Debugger.ResumeRequest]; returnType: void; }

Resumes JavaScript execution.

Debugger.searchInContent: { paramsType: [Protocol.Debugger.SearchInContentRequest]; returnType: Protocol.Debugger.SearchInContentResponse; }

Searches for given string in script content.

Debugger.setAsyncCallStackDepth: { paramsType: [Protocol.Debugger.SetAsyncCallStackDepthRequest]; returnType: void; }

Enables or disables async call stacks tracking.

Debugger.setBlackboxPatterns: { paramsType: [Protocol.Debugger.SetBlackboxPatternsRequest]; returnType: void; }

Replace previous blackbox patterns with passed ones. Forces backend to skip stepping/pausing in scripts with url matching one of the patterns. VM will try to leave blackboxed script by performing 'step in' several times, finally resorting to 'step out' if unsuccessful.

Debugger.setBlackboxedRanges: { paramsType: [Protocol.Debugger.SetBlackboxedRangesRequest]; returnType: void; }

Makes backend skip steps in the script in blackboxed ranges. VM will try leave blacklisted scripts by performing 'step in' several times, finally resorting to 'step out' if unsuccessful. Positions array contains positions where blackbox state is changed. First interval isn't blackboxed. Array should be sorted.

Debugger.setBreakpoint: { paramsType: [Protocol.Debugger.SetBreakpointRequest]; returnType: Protocol.Debugger.SetBreakpointResponse; }

Sets JavaScript breakpoint at a given location.

Debugger.setInstrumentationBreakpoint: { paramsType: [Protocol.Debugger.SetInstrumentationBreakpointRequest]; returnType: Protocol.Debugger.SetInstrumentationBreakpointResponse; }

Sets instrumentation breakpoint.

Debugger.setBreakpointByUrl: { paramsType: [Protocol.Debugger.SetBreakpointByUrlRequest]; returnType: Protocol.Debugger.SetBreakpointByUrlResponse; }

Sets JavaScript breakpoint at given location specified either by URL or URL regex. Once this command is issued, all existing parsed scripts will have breakpoints resolved and returned in locations property. Further matching script parsing will result in subsequent breakpointResolved events issued. This logical breakpoint will survive page reloads.

Debugger.setBreakpointOnFunctionCall: { paramsType: [Protocol.Debugger.SetBreakpointOnFunctionCallRequest]; returnType: Protocol.Debugger.SetBreakpointOnFunctionCallResponse; }

Sets JavaScript breakpoint before each call to the given function. If another function was created from the same source as a given one, calling it will also trigger the breakpoint.

Debugger.setBreakpointsActive: { paramsType: [Protocol.Debugger.SetBreakpointsActiveRequest]; returnType: void; }

Activates / deactivates all breakpoints on the page.

Debugger.setPauseOnExceptions: { paramsType: [Protocol.Debugger.SetPauseOnExceptionsRequest]; returnType: void; }

Defines pause on exceptions state. Can be set to stop on all exceptions, uncaught exceptions or no exceptions. Initial pause on exceptions state is none.

Debugger.setReturnValue: { paramsType: [Protocol.Debugger.SetReturnValueRequest]; returnType: void; }

Changes return value in top frame. Available only at return break position.

Debugger.setScriptSource: { paramsType: [Protocol.Debugger.SetScriptSourceRequest]; returnType: Protocol.Debugger.SetScriptSourceResponse; }

Edits JavaScript source live.

In general, functions that are currently on the stack can not be edited with a single exception: If the edited function is the top-most stack frame and that is the only activation of that function on the stack. In this case the live edit will be successful and a Debugger.restartFrame for the top-most function is automatically triggered.

Debugger.setSkipAllPauses: { paramsType: [Protocol.Debugger.SetSkipAllPausesRequest]; returnType: void; }

Makes page not interrupt on any pauses (breakpoint, exception, dom exception etc).

Debugger.setVariableValue: { paramsType: [Protocol.Debugger.SetVariableValueRequest]; returnType: void; }

Changes value of variable in a callframe. Object-based scopes are not supported and must be mutated manually.

Debugger.stepInto: { paramsType: [Protocol.Debugger.StepIntoRequest]; returnType: void; }

Steps into the function call.

Debugger.stepOut: { paramsType: []; returnType: void; }

Steps out of the function call.

Debugger.stepOver: { paramsType: [Protocol.Debugger.StepOverRequest]; returnType: void; }

Steps over the statement.

HeapProfiler.addInspectedHeapObject: { paramsType: [Protocol.HeapProfiler.AddInspectedHeapObjectRequest]; returnType: void; }

Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).

HeapProfiler.collectGarbage: { paramsType: []; returnType: void; }
HeapProfiler.disable: { paramsType: []; returnType: void; }
HeapProfiler.enable: { paramsType: []; returnType: void; }
HeapProfiler.getHeapObjectId: { paramsType: [Protocol.HeapProfiler.GetHeapObjectIdRequest]; returnType: Protocol.HeapProfiler.GetHeapObjectIdResponse; }
HeapProfiler.getObjectByHeapObjectId: { paramsType: [Protocol.HeapProfiler.GetObjectByHeapObjectIdRequest]; returnType: Protocol.HeapProfiler.GetObjectByHeapObjectIdResponse; }
HeapProfiler.getSamplingProfile: { paramsType: []; returnType: Protocol.HeapProfiler.GetSamplingProfileResponse; }
HeapProfiler.startSampling: { paramsType: [Protocol.HeapProfiler.StartSamplingRequest]; returnType: void; }
HeapProfiler.startTrackingHeapObjects: { paramsType: [Protocol.HeapProfiler.StartTrackingHeapObjectsRequest]; returnType: void; }
HeapProfiler.stopSampling: { paramsType: []; returnType: Protocol.HeapProfiler.StopSamplingResponse; }
HeapProfiler.stopTrackingHeapObjects: { paramsType: [Protocol.HeapProfiler.StopTrackingHeapObjectsRequest]; returnType: void; }
HeapProfiler.takeHeapSnapshot: { paramsType: [Protocol.HeapProfiler.TakeHeapSnapshotRequest]; returnType: void; }
Profiler.disable: { paramsType: []; returnType: void; }
Profiler.enable: { paramsType: []; returnType: void; }
Profiler.getBestEffortCoverage: { paramsType: []; returnType: Protocol.Profiler.GetBestEffortCoverageResponse; }

Collect coverage data for the current isolate. The coverage data may be incomplete due to garbage collection.

Profiler.setSamplingInterval: { paramsType: [Protocol.Profiler.SetSamplingIntervalRequest]; returnType: void; }

Changes CPU profiler sampling interval. Must be called before CPU profiles recording started.

Profiler.start: { paramsType: []; returnType: void; }
Profiler.startPreciseCoverage: { paramsType: [Protocol.Profiler.StartPreciseCoverageRequest]; returnType: Protocol.Profiler.StartPreciseCoverageResponse; }

Enable precise code coverage. Coverage data for JavaScript executed before enabling precise code coverage may be incomplete. Enabling prevents running optimized code and resets execution counters.

Profiler.startTypeProfile: { paramsType: []; returnType: void; }

Enable type profile.

Profiler.stop: { paramsType: []; returnType: Protocol.Profiler.StopResponse; }
Profiler.stopPreciseCoverage: { paramsType: []; returnType: void; }

Disable precise code coverage. Disabling releases unnecessary execution count records and allows executing optimized code.

Profiler.stopTypeProfile: { paramsType: []; returnType: void; }

Disable type profile. Disabling releases type profile data collected so far.

Profiler.takePreciseCoverage: { paramsType: []; returnType: Protocol.Profiler.TakePreciseCoverageResponse; }

Collect coverage data for the current isolate, and resets execution counters. Precise code coverage needs to have started.

Profiler.takeTypeProfile: { paramsType: []; returnType: Protocol.Profiler.TakeTypeProfileResponse; }

Collect type profile.

Runtime.awaitPromise: { paramsType: [Protocol.Runtime.AwaitPromiseRequest]; returnType: Protocol.Runtime.AwaitPromiseResponse; }

Add handler to promise with given promise object id.

Runtime.callFunctionOn: { paramsType: [Protocol.Runtime.CallFunctionOnRequest]; returnType: Protocol.Runtime.CallFunctionOnResponse; }

Calls function with given declaration on the given object. Object group of the result is inherited from the target object.

Runtime.compileScript: { paramsType: [Protocol.Runtime.CompileScriptRequest]; returnType: Protocol.Runtime.CompileScriptResponse; }

Compiles expression.

Runtime.disable: { paramsType: []; returnType: void; }

Disables reporting of execution contexts creation.

Runtime.discardConsoleEntries: { paramsType: []; returnType: void; }

Discards collected exceptions and console API calls.

Runtime.enable: { paramsType: []; returnType: void; }

Enables reporting of execution contexts creation by means of executionContextCreated event. When the reporting gets enabled the event will be sent immediately for each existing execution context.

Runtime.evaluate: { paramsType: [Protocol.Runtime.EvaluateRequest]; returnType: Protocol.Runtime.EvaluateResponse; }

Evaluates expression on global object.

Runtime.getIsolateId: { paramsType: []; returnType: Protocol.Runtime.GetIsolateIdResponse; }

Returns the isolate id.

Runtime.getHeapUsage: { paramsType: []; returnType: Protocol.Runtime.GetHeapUsageResponse; }

Returns the JavaScript heap usage. It is the total usage of the corresponding isolate not scoped to a particular Runtime.

Runtime.getProperties: { paramsType: [Protocol.Runtime.GetPropertiesRequest]; returnType: Protocol.Runtime.GetPropertiesResponse; }

Returns properties of a given object. Object group of the result is inherited from the target object.

Runtime.globalLexicalScopeNames: { paramsType: [Protocol.Runtime.GlobalLexicalScopeNamesRequest]; returnType: Protocol.Runtime.GlobalLexicalScopeNamesResponse; }

Returns all let, const and class variables from global scope.

Runtime.queryObjects: { paramsType: [Protocol.Runtime.QueryObjectsRequest]; returnType: Protocol.Runtime.QueryObjectsResponse; }
Runtime.releaseObject: { paramsType: [Protocol.Runtime.ReleaseObjectRequest]; returnType: void; }

Releases remote object with given id.

Runtime.releaseObjectGroup: { paramsType: [Protocol.Runtime.ReleaseObjectGroupRequest]; returnType: void; }

Releases all remote objects that belong to a given group.

Runtime.runIfWaitingForDebugger: { paramsType: []; returnType: void; }

Tells inspected instance to run if it was waiting for debugger to attach.

Runtime.runScript: { paramsType: [Protocol.Runtime.RunScriptRequest]; returnType: Protocol.Runtime.RunScriptResponse; }

Runs script with given id in a given context.

Runtime.setAsyncCallStackDepth: { paramsType: [Protocol.Runtime.SetAsyncCallStackDepthRequest]; returnType: void; }

Enables or disables async call stacks tracking.

Runtime.setCustomObjectFormatterEnabled: { paramsType: [Protocol.Runtime.SetCustomObjectFormatterEnabledRequest]; returnType: void; }
Runtime.setMaxCallStackSizeToCapture: { paramsType: [Protocol.Runtime.SetMaxCallStackSizeToCaptureRequest]; returnType: void; }
Runtime.terminateExecution: { paramsType: []; returnType: void; }

Terminate current or next JavaScript execution. Will cancel the termination when the outer-most script execution ends.

Runtime.addBinding: { paramsType: [Protocol.Runtime.AddBindingRequest]; returnType: void; }

If executionContextId is empty, adds binding with the given name on the global objects of all inspected contexts, including those created later, bindings survive reloads. Binding function takes exactly one argument, this argument should be string, in case of any other input, function throws an exception. Each binding function call produces Runtime.bindingCalled notification.

Runtime.removeBinding: { paramsType: [Protocol.Runtime.RemoveBindingRequest]; returnType: void; }

This method does not remove binding function from global object but unsubscribes current runtime agent from Runtime.bindingCalled notifications.

Runtime.getExceptionDetails: { paramsType: [Protocol.Runtime.GetExceptionDetailsRequest]; returnType: Protocol.Runtime.GetExceptionDetailsResponse; }

This method tries to lookup and populate exception details for a JavaScript Error object. Note that the stackTrace portion of the resulting exceptionDetails will only be populated if the Runtime domain was enabled at the time when the Error was thrown.

Schema.getDomains: { paramsType: []; returnType: Protocol.Schema.GetDomainsResponse; }

Returns supported domains.

Accessibility.disable: { paramsType: []; returnType: void; }

Disables the accessibility domain.

Accessibility.enable: { paramsType: []; returnType: void; }

Enables the accessibility domain which causes AXNodeIds to remain consistent between method calls. This turns on accessibility for the page, which can impact performance until accessibility is disabled.

Accessibility.getPartialAXTree: { paramsType: [Protocol.Accessibility.GetPartialAXTreeRequest]; returnType: Protocol.Accessibility.GetPartialAXTreeResponse; }

Fetches the accessibility node and partial accessibility tree for this DOM node, if it exists.

Accessibility.getFullAXTree: { paramsType: [Protocol.Accessibility.GetFullAXTreeRequest]; returnType: Protocol.Accessibility.GetFullAXTreeResponse; }

Fetches the entire accessibility tree for the root Document

Accessibility.getRootAXNode: { paramsType: [Protocol.Accessibility.GetRootAXNodeRequest]; returnType: Protocol.Accessibility.GetRootAXNodeResponse; }

Fetches the root node. Requires enable() to have been called previously.

Accessibility.getAXNodeAndAncestors: { paramsType: [Protocol.Accessibility.GetAXNodeAndAncestorsRequest]; returnType: Protocol.Accessibility.GetAXNodeAndAncestorsResponse; }

Fetches a node and all ancestors up to and including the root. Requires enable() to have been called previously.

Accessibility.getChildAXNodes: { paramsType: [Protocol.Accessibility.GetChildAXNodesRequest]; returnType: Protocol.Accessibility.GetChildAXNodesResponse; }

Fetches a particular accessibility node by AXNodeId. Requires enable() to have been called previously.

Accessibility.queryAXTree: { paramsType: [Protocol.Accessibility.QueryAXTreeRequest]; returnType: Protocol.Accessibility.QueryAXTreeResponse; }

Query a DOM node's accessibility subtree for accessible name and role. This command computes the name and role for all nodes in the subtree, including those that are ignored for accessibility, and returns those that mactch the specified name and role. If no DOM node is specified, or the DOM node does not exist, the command returns an error. If neither accessibleName or role is specified, it returns all the accessibility nodes in the subtree.

Animation.disable: { paramsType: []; returnType: void; }

Disables animation domain notifications.

Animation.enable: { paramsType: []; returnType: void; }

Enables animation domain notifications.

Animation.getCurrentTime: { paramsType: [Protocol.Animation.GetCurrentTimeRequest]; returnType: Protocol.Animation.GetCurrentTimeResponse; }

Returns the current time of the an animation.

Animation.getPlaybackRate: { paramsType: []; returnType: Protocol.Animation.GetPlaybackRateResponse; }

Gets the playback rate of the document timeline.

Animation.releaseAnimations: { paramsType: [Protocol.Animation.ReleaseAnimationsRequest]; returnType: void; }

Releases a set of animations to no longer be manipulated.

Animation.resolveAnimation: { paramsType: [Protocol.Animation.ResolveAnimationRequest]; returnType: Protocol.Animation.ResolveAnimationResponse; }

Gets the remote object of the Animation.

Animation.seekAnimations: { paramsType: [Protocol.Animation.SeekAnimationsRequest]; returnType: void; }

Seek a set of animations to a particular time within each animation.

Animation.setPaused: { paramsType: [Protocol.Animation.SetPausedRequest]; returnType: void; }

Sets the paused state of a set of animations.

Animation.setPlaybackRate: { paramsType: [Protocol.Animation.SetPlaybackRateRequest]; returnType: void; }

Sets the playback rate of the document timeline.

Animation.setTiming: { paramsType: [Protocol.Animation.SetTimingRequest]; returnType: void; }

Sets the timing of an animation node.

Audits.getEncodedResponse: { paramsType: [Protocol.Audits.GetEncodedResponseRequest]; returnType: Protocol.Audits.GetEncodedResponseResponse; }

Returns the response body and size if it were re-encoded with the specified settings. Only applies to images.

Audits.disable: { paramsType: []; returnType: void; }

Disables issues domain, prevents further issues from being reported to the client.

Audits.enable: { paramsType: []; returnType: void; }

Enables issues domain, sends the issues collected so far to the client by means of the issueAdded event.

Audits.checkContrast: { paramsType: [Protocol.Audits.CheckContrastRequest]; returnType: void; }

Runs the contrast check for the target page. Found issues are reported using Audits.issueAdded event.

BackgroundService.startObserving: { paramsType: [Protocol.BackgroundService.StartObservingRequest]; returnType: void; }

Enables event updates for the service.

BackgroundService.stopObserving: { paramsType: [Protocol.BackgroundService.StopObservingRequest]; returnType: void; }

Disables event updates for the service.

BackgroundService.setRecording: { paramsType: [Protocol.BackgroundService.SetRecordingRequest]; returnType: void; }

Set the recording state for the service.

BackgroundService.clearEvents: { paramsType: [Protocol.BackgroundService.ClearEventsRequest]; returnType: void; }

Clears all stored data for the service.

Browser.setPermission: { paramsType: [Protocol.Browser.SetPermissionRequest]; returnType: void; }

Set permission settings for given origin.

Browser.grantPermissions: { paramsType: [Protocol.Browser.GrantPermissionsRequest]; returnType: void; }

Grant specific permissions to the given origin and reject all others.

Browser.resetPermissions: { paramsType: [Protocol.Browser.ResetPermissionsRequest]; returnType: void; }

Reset all permission management for all origins.

Browser.setDownloadBehavior: { paramsType: [Protocol.Browser.SetDownloadBehaviorRequest]; returnType: void; }

Set the behavior when downloading a file.

Browser.cancelDownload: { paramsType: [Protocol.Browser.CancelDownloadRequest]; returnType: void; }

Cancel a download if in progress

Browser.close: { paramsType: []; returnType: void; }

Close browser gracefully.

Browser.crash: { paramsType: []; returnType: void; }

Crashes browser on the main thread.

Browser.crashGpuProcess: { paramsType: []; returnType: void; }

Crashes GPU process.

Browser.getVersion: { paramsType: []; returnType: Protocol.Browser.GetVersionResponse; }

Returns version information.

Browser.getBrowserCommandLine: { paramsType: []; returnType: Protocol.Browser.GetBrowserCommandLineResponse; }

Returns the command line switches for the browser process if, and only if --enable-automation is on the commandline.

Browser.getHistograms: { paramsType: [Protocol.Browser.GetHistogramsRequest]; returnType: Protocol.Browser.GetHistogramsResponse; }

Get Chrome histograms.

Browser.getHistogram: { paramsType: [Protocol.Browser.GetHistogramRequest]; returnType: Protocol.Browser.GetHistogramResponse; }

Get a Chrome histogram by name.

Browser.getWindowBounds: { paramsType: [Protocol.Browser.GetWindowBoundsRequest]; returnType: Protocol.Browser.GetWindowBoundsResponse; }

Get position and size of the browser window.

Browser.getWindowForTarget: { paramsType: [Protocol.Browser.GetWindowForTargetRequest]; returnType: Protocol.Browser.GetWindowForTargetResponse; }

Get the browser window that contains the devtools target.

Browser.setWindowBounds: { paramsType: [Protocol.Browser.SetWindowBoundsRequest]; returnType: void; }

Set position and/or size of the browser window.

Browser.setDockTile: { paramsType: [Protocol.Browser.SetDockTileRequest]; returnType: void; }

Set dock tile details, platform-specific.

Browser.executeBrowserCommand: { paramsType: [Protocol.Browser.ExecuteBrowserCommandRequest]; returnType: void; }

Invoke custom browser commands used by telemetry.

CSS.addRule: { paramsType: [Protocol.CSS.AddRuleRequest]; returnType: Protocol.CSS.AddRuleResponse; }

Inserts a new rule with the given ruleText in a stylesheet with given styleSheetId, at the position specified by location.

CSS.collectClassNames: { paramsType: [Protocol.CSS.CollectClassNamesRequest]; returnType: Protocol.CSS.CollectClassNamesResponse; }

Returns all class names from specified stylesheet.

CSS.createStyleSheet: { paramsType: [Protocol.CSS.CreateStyleSheetRequest]; returnType: Protocol.CSS.CreateStyleSheetResponse; }

Creates a new special "via-inspector" stylesheet in the frame with given frameId.

CSS.disable: { paramsType: []; returnType: void; }

Disables the CSS agent for the given page.

CSS.enable: { paramsType: []; returnType: void; }

Enables the CSS agent for the given page. Clients should not assume that the CSS agent has been enabled until the result of this command is received.

CSS.forcePseudoState: { paramsType: [Protocol.CSS.ForcePseudoStateRequest]; returnType: void; }

Ensures that the given node will have specified pseudo-classes whenever its style is computed by the browser.

CSS.getBackgroundColors: { paramsType: [Protocol.CSS.GetBackgroundColorsRequest]; returnType: Protocol.CSS.GetBackgroundColorsResponse; }
CSS.getComputedStyleForNode: { paramsType: [Protocol.CSS.GetComputedStyleForNodeRequest]; returnType: Protocol.CSS.GetComputedStyleForNodeResponse; }

Returns the computed style for a DOM node identified by nodeId.

CSS.getInlineStylesForNode: { paramsType: [Protocol.CSS.GetInlineStylesForNodeRequest]; returnType: Protocol.CSS.GetInlineStylesForNodeResponse; }

Returns the styles defined inline (explicitly in the "style" attribute and implicitly, using DOM attributes) for a DOM node identified by nodeId.

CSS.getMatchedStylesForNode: { paramsType: [Protocol.CSS.GetMatchedStylesForNodeRequest]; returnType: Protocol.CSS.GetMatchedStylesForNodeResponse; }

Returns requested styles for a DOM node identified by nodeId.

CSS.getMediaQueries: { paramsType: []; returnType: Protocol.CSS.GetMediaQueriesResponse; }

Returns all media queries parsed by the rendering engine.

CSS.getPlatformFontsForNode: { paramsType: [Protocol.CSS.GetPlatformFontsForNodeRequest]; returnType: Protocol.CSS.GetPlatformFontsForNodeResponse; }

Requests information about platform fonts which we used to render child TextNodes in the given node.

CSS.getStyleSheetText: { paramsType: [Protocol.CSS.GetStyleSheetTextRequest]; returnType: Protocol.CSS.GetStyleSheetTextResponse; }

Returns the current textual content for a stylesheet.

CSS.getLayersForNode: { paramsType: [Protocol.CSS.GetLayersForNodeRequest]; returnType: Protocol.CSS.GetLayersForNodeResponse; }

Returns all layers parsed by the rendering engine for the tree scope of a node. Given a DOM element identified by nodeId, getLayersForNode returns the root layer for the nearest ancestor document or shadow root. The layer root contains the full layer tree for the tree scope and their ordering.

CSS.trackComputedStyleUpdates: { paramsType: [Protocol.CSS.TrackComputedStyleUpdatesRequest]; returnType: void; }

Starts tracking the given computed styles for updates. The specified array of properties replaces the one previously specified. Pass empty array to disable tracking. Use takeComputedStyleUpdates to retrieve the list of nodes that had properties modified. The changes to computed style properties are only tracked for nodes pushed to the front-end by the DOM agent. If no changes to the tracked properties occur after the node has been pushed to the front-end, no updates will be issued for the node.

CSS.takeComputedStyleUpdates: { paramsType: []; returnType: Protocol.CSS.TakeComputedStyleUpdatesResponse; }

Polls the next batch of computed style updates.

CSS.setEffectivePropertyValueForNode: { paramsType: [Protocol.CSS.SetEffectivePropertyValueForNodeRequest]; returnType: void; }

Find a rule with the given active property for the given node and set the new value for this property

CSS.setKeyframeKey: { paramsType: [Protocol.CSS.SetKeyframeKeyRequest]; returnType: Protocol.CSS.SetKeyframeKeyResponse; }

Modifies the keyframe rule key text.

CSS.setMediaText: { paramsType: [Protocol.CSS.SetMediaTextRequest]; returnType: Protocol.CSS.SetMediaTextResponse; }

Modifies the rule selector.

CSS.setContainerQueryText: { paramsType: [Protocol.CSS.SetContainerQueryTextRequest]; returnType: Protocol.CSS.SetContainerQueryTextResponse; }

Modifies the expression of a container query.

CSS.setSupportsText: { paramsType: [Protocol.CSS.SetSupportsTextRequest]; returnType: Protocol.CSS.SetSupportsTextResponse; }

Modifies the expression of a supports at-rule.

CSS.setScopeText: { paramsType: [Protocol.CSS.SetScopeTextRequest]; returnType: Protocol.CSS.SetScopeTextResponse; }

Modifies the expression of a scope at-rule.

CSS.setRuleSelector: { paramsType: [Protocol.CSS.SetRuleSelectorRequest]; returnType: Protocol.CSS.SetRuleSelectorResponse; }

Modifies the rule selector.

CSS.setStyleSheetText: { paramsType: [Protocol.CSS.SetStyleSheetTextRequest]; returnType: Protocol.CSS.SetStyleSheetTextResponse; }

Sets the new stylesheet text.

CSS.setStyleTexts: { paramsType: [Protocol.CSS.SetStyleTextsRequest]; returnType: Protocol.CSS.SetStyleTextsResponse; }

Applies specified style edits one after another in the given order.

CSS.startRuleUsageTracking: { paramsType: []; returnType: void; }

Enables the selector recording.

CSS.stopRuleUsageTracking: { paramsType: []; returnType: Protocol.CSS.StopRuleUsageTrackingResponse; }

Stop tracking rule usage and return the list of rules that were used since last call to takeCoverageDelta (or since start of coverage instrumentation)

CSS.takeCoverageDelta: { paramsType: []; returnType: Protocol.CSS.TakeCoverageDeltaResponse; }

Obtain list of rules that became used since last call to this method (or since start of coverage instrumentation)

CSS.setLocalFontsEnabled: { paramsType: [Protocol.CSS.SetLocalFontsEnabledRequest]; returnType: void; }

Enables/disables rendering of local CSS fonts (enabled by default).

CacheStorage.deleteCache: { paramsType: [Protocol.CacheStorage.DeleteCacheRequest]; returnType: void; }

Deletes a cache.

CacheStorage.deleteEntry: { paramsType: [Protocol.CacheStorage.DeleteEntryRequest]; returnType: void; }

Deletes a cache entry.

CacheStorage.requestCacheNames: { paramsType: [Protocol.CacheStorage.RequestCacheNamesRequest]; returnType: Protocol.CacheStorage.RequestCacheNamesResponse; }

Requests cache names.

CacheStorage.requestCachedResponse: { paramsType: [Protocol.CacheStorage.RequestCachedResponseRequest]; returnType: Protocol.CacheStorage.RequestCachedResponseResponse; }

Fetches cache entry.

CacheStorage.requestEntries: { paramsType: [Protocol.CacheStorage.RequestEntriesRequest]; returnType: Protocol.CacheStorage.RequestEntriesResponse; }

Requests data from cache.

Cast.enable: { paramsType: [Protocol.Cast.EnableRequest]; returnType: void; }

Starts observing for sinks that can be used for tab mirroring, and if set, sinks compatible with |presentationUrl| as well. When sinks are found, a |sinksUpdated| event is fired. Also starts observing for issue messages. When an issue is added or removed, an |issueUpdated| event is fired.

Cast.disable: { paramsType: []; returnType: void; }

Stops observing for sinks and issues.

Cast.setSinkToUse: { paramsType: [Protocol.Cast.SetSinkToUseRequest]; returnType: void; }

Sets a sink to be used when the web page requests the browser to choose a sink via Presentation API, Remote Playback API, or Cast SDK.

Cast.startDesktopMirroring: { paramsType: [Protocol.Cast.StartDesktopMirroringRequest]; returnType: void; }

Starts mirroring the desktop to the sink.

Cast.startTabMirroring: { paramsType: [Protocol.Cast.StartTabMirroringRequest]; returnType: void; }

Starts mirroring the tab to the sink.

Cast.stopCasting: { paramsType: [Protocol.Cast.StopCastingRequest]; returnType: void; }

Stops the active Cast session on the sink.

DOM.collectClassNamesFromSubtree: { paramsType: [Protocol.DOM.CollectClassNamesFromSubtreeRequest]; returnType: Protocol.DOM.CollectClassNamesFromSubtreeResponse; }

Collects class names for the node with given id and all of it's child nodes.

DOM.copyTo: { paramsType: [Protocol.DOM.CopyToRequest]; returnType: Protocol.DOM.CopyToResponse; }

Creates a deep copy of the specified node and places it into the target container before the given anchor.

DOM.describeNode: { paramsType: [Protocol.DOM.DescribeNodeRequest]; returnType: Protocol.DOM.DescribeNodeResponse; }

Describes node given its id, does not require domain to be enabled. Does not start tracking any objects, can be used for automation.

DOM.scrollIntoViewIfNeeded: { paramsType: [Protocol.DOM.ScrollIntoViewIfNeededRequest]; returnType: void; }

Scrolls the specified rect of the given node into view if not already visible. Note: exactly one between nodeId, backendNodeId and objectId should be passed to identify the node.

DOM.disable: { paramsType: []; returnType: void; }

Disables DOM agent for the given page.

DOM.discardSearchResults: { paramsType: [Protocol.DOM.DiscardSearchResultsRequest]; returnType: void; }

Discards search results from the session with the given id. getSearchResults should no longer be called for that search.

DOM.enable: { paramsType: [Protocol.DOM.EnableRequest]; returnType: void; }

Enables DOM agent for the given page.

DOM.focus: { paramsType: [Protocol.DOM.FocusRequest]; returnType: void; }

Focuses the given element.

DOM.getAttributes: { paramsType: [Protocol.DOM.GetAttributesRequest]; returnType: Protocol.DOM.GetAttributesResponse; }

Returns attributes for the specified node.

DOM.getBoxModel: { paramsType: [Protocol.DOM.GetBoxModelRequest]; returnType: Protocol.DOM.GetBoxModelResponse; }

Returns boxes for the given node.

DOM.getContentQuads: { paramsType: [Protocol.DOM.GetContentQuadsRequest]; returnType: Protocol.DOM.GetContentQuadsResponse; }

Returns quads that describe node position on the page. This method might return multiple quads for inline nodes.

DOM.getDocument: { paramsType: [Protocol.DOM.GetDocumentRequest]; returnType: Protocol.DOM.GetDocumentResponse; }

Returns the root DOM node (and optionally the subtree) to the caller.

DOM.getFlattenedDocument: { paramsType: [Protocol.DOM.GetFlattenedDocumentRequest]; returnType: Protocol.DOM.GetFlattenedDocumentResponse; }

Returns the root DOM node (and optionally the subtree) to the caller. Deprecated, as it is not designed to work well with the rest of the DOM agent. Use DOMSnapshot.captureSnapshot instead.

DOM.getNodesForSubtreeByStyle: { paramsType: [Protocol.DOM.GetNodesForSubtreeByStyleRequest]; returnType: Protocol.DOM.GetNodesForSubtreeByStyleResponse; }

Finds nodes with a given computed style in a subtree.

DOM.getNodeForLocation: { paramsType: [Protocol.DOM.GetNodeForLocationRequest]; returnType: Protocol.DOM.GetNodeForLocationResponse; }

Returns node id at given location. Depending on whether DOM domain is enabled, nodeId is either returned or not.

DOM.getOuterHTML: { paramsType: [Protocol.DOM.GetOuterHTMLRequest]; returnType: Protocol.DOM.GetOuterHTMLResponse; }

Returns node's HTML markup.

DOM.getRelayoutBoundary: { paramsType: [Protocol.DOM.GetRelayoutBoundaryRequest]; returnType: Protocol.DOM.GetRelayoutBoundaryResponse; }

Returns the id of the nearest ancestor that is a relayout boundary.

DOM.getSearchResults: { paramsType: [Protocol.DOM.GetSearchResultsRequest]; returnType: Protocol.DOM.GetSearchResultsResponse; }

Returns search results from given fromIndex to given toIndex from the search with the given identifier.

DOM.hideHighlight: { paramsType: []; returnType: void; }

Hides any highlight.

DOM.highlightNode: { paramsType: []; returnType: void; }

Highlights DOM node.

DOM.highlightRect: { paramsType: []; returnType: void; }

Highlights given rectangle.

DOM.markUndoableState: { paramsType: []; returnType: void; }

Marks last undoable state.

DOM.moveTo: { paramsType: [Protocol.DOM.MoveToRequest]; returnType: Protocol.DOM.MoveToResponse; }

Moves node into the new container, places it before the given anchor.

DOM.performSearch: { paramsType: [Protocol.DOM.PerformSearchRequest]; returnType: Protocol.DOM.PerformSearchResponse; }

Searches for a given string in the DOM tree. Use getSearchResults to access search results or cancelSearch to end this search session.

DOM.pushNodeByPathToFrontend: { paramsType: [Protocol.DOM.PushNodeByPathToFrontendRequest]; returnType: Protocol.DOM.PushNodeByPathToFrontendResponse; }

Requests that the node is sent to the caller given its path. // FIXME, use XPath

DOM.pushNodesByBackendIdsToFrontend: { paramsType: [Protocol.DOM.PushNodesByBackendIdsToFrontendRequest]; returnType: Protocol.DOM.PushNodesByBackendIdsToFrontendResponse; }

Requests that a batch of nodes is sent to the caller given their backend node ids.

DOM.querySelector: { paramsType: [Protocol.DOM.QuerySelectorRequest]; returnType: Protocol.DOM.QuerySelectorResponse; }

Executes querySelector on a given node.

DOM.querySelectorAll: { paramsType: [Protocol.DOM.QuerySelectorAllRequest]; returnType: Protocol.DOM.QuerySelectorAllResponse; }

Executes querySelectorAll on a given node.

DOM.getTopLayerElements: { paramsType: []; returnType: Protocol.DOM.GetTopLayerElementsResponse; }

Returns NodeIds of current top layer elements. Top layer is rendered closest to the user within a viewport, therefore its elements always appear on top of all other content.

DOM.redo: { paramsType: []; returnType: void; }

Re-does the last undone action.

DOM.removeAttribute: { paramsType: [Protocol.DOM.RemoveAttributeRequest]; returnType: void; }

Removes attribute with given name from an element with given id.

DOM.removeNode: { paramsType: [Protocol.DOM.RemoveNodeRequest]; returnType: void; }

Removes node with given id.

DOM.requestChildNodes: { paramsType: [Protocol.DOM.RequestChildNodesRequest]; returnType: void; }

Requests that children of the node with given id are returned to the caller in form of setChildNodes events where not only immediate children are retrieved, but all children down to the specified depth.

DOM.requestNode: { paramsType: [Protocol.DOM.RequestNodeRequest]; returnType: Protocol.DOM.RequestNodeResponse; }

Requests that the node is sent to the caller given the JavaScript node object reference. All nodes that form the path from the node to the root are also sent to the client as a series of setChildNodes notifications.

DOM.resolveNode: { paramsType: [Protocol.DOM.ResolveNodeRequest]; returnType: Protocol.DOM.ResolveNodeResponse; }

Resolves the JavaScript node object for a given NodeId or BackendNodeId.

DOM.setAttributeValue: { paramsType: [Protocol.DOM.SetAttributeValueRequest]; returnType: void; }

Sets attribute for an element with given id.

DOM.setAttributesAsText: { paramsType: [Protocol.DOM.SetAttributesAsTextRequest]; returnType: void; }

Sets attributes on element with given id. This method is useful when user edits some existing attribute value and types in several attribute name/value pairs.

DOM.setFileInputFiles: { paramsType: [Protocol.DOM.SetFileInputFilesRequest]; returnType: void; }

Sets files for the given file input element.

DOM.setNodeStackTracesEnabled: { paramsType: [Protocol.DOM.SetNodeStackTracesEnabledRequest]; returnType: void; }

Sets if stack traces should be captured for Nodes. See Node.getNodeStackTraces. Default is disabled.

DOM.getNodeStackTraces: { paramsType: [Protocol.DOM.GetNodeStackTracesRequest]; returnType: Protocol.DOM.GetNodeStackTracesResponse; }

Gets stack traces associated with a Node. As of now, only provides stack trace for Node creation.

DOM.getFileInfo: { paramsType: [Protocol.DOM.GetFileInfoRequest]; returnType: Protocol.DOM.GetFileInfoResponse; }

Returns file information for the given File wrapper.

DOM.setInspectedNode: { paramsType: [Protocol.DOM.SetInspectedNodeRequest]; returnType: void; }

Enables console to refer to the node with given id via $x (see Command Line API for more details $x functions).

DOM.setNodeName: { paramsType: [Protocol.DOM.SetNodeNameRequest]; returnType: Protocol.DOM.SetNodeNameResponse; }

Sets node name for a node with given id.

DOM.setNodeValue: { paramsType: [Protocol.DOM.SetNodeValueRequest]; returnType: void; }

Sets node value for a node with given id.

DOM.setOuterHTML: { paramsType: [Protocol.DOM.SetOuterHTMLRequest]; returnType: void; }

Sets node HTML markup, returns new node id.

DOM.undo: { paramsType: []; returnType: void; }

Undoes the last performed action.

DOM.getFrameOwner: { paramsType: [Protocol.DOM.GetFrameOwnerRequest]; returnType: Protocol.DOM.GetFrameOwnerResponse; }

Returns iframe node that owns iframe with the given domain.

DOM.getContainerForNode: { paramsType: [Protocol.DOM.GetContainerForNodeRequest]; returnType: Protocol.DOM.GetContainerForNodeResponse; }

Returns the container of the given node based on container query conditions. If containerName is given, it will find the nearest container with a matching name; otherwise it will find the nearest container regardless of its container name.

DOM.getQueryingDescendantsForContainer: { paramsType: [Protocol.DOM.GetQueryingDescendantsForContainerRequest]; returnType: Protocol.DOM.GetQueryingDescendantsForContainerResponse; }

Returns the descendants of a container query container that have container queries against this container.

DOMDebugger.getEventListeners: { paramsType: [Protocol.DOMDebugger.GetEventListenersRequest]; returnType: Protocol.DOMDebugger.GetEventListenersResponse; }

Returns event listeners of the given object.

DOMDebugger.removeDOMBreakpoint: { paramsType: [Protocol.DOMDebugger.RemoveDOMBreakpointRequest]; returnType: void; }

Removes DOM breakpoint that was set using setDOMBreakpoint.

DOMDebugger.removeEventListenerBreakpoint: { paramsType: [Protocol.DOMDebugger.RemoveEventListenerBreakpointRequest]; returnType: void; }

Removes breakpoint on particular DOM event.

DOMDebugger.removeInstrumentationBreakpoint: { paramsType: [Protocol.DOMDebugger.RemoveInstrumentationBreakpointRequest]; returnType: void; }

Removes breakpoint on particular native event.

DOMDebugger.removeXHRBreakpoint: { paramsType: [Protocol.DOMDebugger.RemoveXHRBreakpointRequest]; returnType: void; }

Removes breakpoint from XMLHttpRequest.

DOMDebugger.setBreakOnCSPViolation: { paramsType: [Protocol.DOMDebugger.SetBreakOnCSPViolationRequest]; returnType: void; }

Sets breakpoint on particular CSP violations.

DOMDebugger.setDOMBreakpoint: { paramsType: [Protocol.DOMDebugger.SetDOMBreakpointRequest]; returnType: void; }

Sets breakpoint on particular operation with DOM.

DOMDebugger.setEventListenerBreakpoint: { paramsType: [Protocol.DOMDebugger.SetEventListenerBreakpointRequest]; returnType: void; }

Sets breakpoint on particular DOM event.

DOMDebugger.setInstrumentationBreakpoint: { paramsType: [Protocol.DOMDebugger.SetInstrumentationBreakpointRequest]; returnType: void; }

Sets breakpoint on particular native event.

DOMDebugger.setXHRBreakpoint: { paramsType: [Protocol.DOMDebugger.SetXHRBreakpointRequest]; returnType: void; }

Sets breakpoint on XMLHttpRequest.

EventBreakpoints.setInstrumentationBreakpoint: { paramsType: [Protocol.EventBreakpoints.SetInstrumentationBreakpointRequest]; returnType: void; }

Sets breakpoint on particular native event.

EventBreakpoints.removeInstrumentationBreakpoint: { paramsType: [Protocol.EventBreakpoints.RemoveInstrumentationBreakpointRequest]; returnType: void; }

Removes breakpoint on particular native event.

DOMSnapshot.disable: { paramsType: []; returnType: void; }

Disables DOM snapshot agent for the given page.

DOMSnapshot.enable: { paramsType: []; returnType: void; }

Enables DOM snapshot agent for the given page.

DOMSnapshot.getSnapshot: { paramsType: [Protocol.DOMSnapshot.GetSnapshotRequest]; returnType: Protocol.DOMSnapshot.GetSnapshotResponse; }

Returns a document snapshot, including the full DOM tree of the root node (including iframes, template contents, and imported documents) in a flattened array, as well as layout and white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is flattened.

DOMSnapshot.captureSnapshot: { paramsType: [Protocol.DOMSnapshot.CaptureSnapshotRequest]; returnType: Protocol.DOMSnapshot.CaptureSnapshotResponse; }

Returns a document snapshot, including the full DOM tree of the root node (including iframes, template contents, and imported documents) in a flattened array, as well as layout and white-listed computed style information for the nodes. Shadow DOM in the returned DOM tree is flattened.

DOMStorage.clear: { paramsType: [Protocol.DOMStorage.ClearRequest]; returnType: void; }
DOMStorage.disable: { paramsType: []; returnType: void; }

Disables storage tracking, prevents storage events from being sent to the client.

DOMStorage.enable: { paramsType: []; returnType: void; }

Enables storage tracking, storage events will now be delivered to the client.

DOMStorage.getDOMStorageItems: { paramsType: [Protocol.DOMStorage.GetDOMStorageItemsRequest]; returnType: Protocol.DOMStorage.GetDOMStorageItemsResponse; }
DOMStorage.removeDOMStorageItem: { paramsType: [Protocol.DOMStorage.RemoveDOMStorageItemRequest]; returnType: void; }
DOMStorage.setDOMStorageItem: { paramsType: [Protocol.DOMStorage.SetDOMStorageItemRequest]; returnType: void; }
Database.disable: { paramsType: []; returnType: void; }

Disables database tracking, prevents database events from being sent to the client.

Database.enable: { paramsType: []; returnType: void; }

Enables database tracking, database events will now be delivered to the client.

Database.executeSQL: { paramsType: [Protocol.Database.ExecuteSQLRequest]; returnType: Protocol.Database.ExecuteSQLResponse; }
Database.getDatabaseTableNames: { paramsType: [Protocol.Database.GetDatabaseTableNamesRequest]; returnType: Protocol.Database.GetDatabaseTableNamesResponse; }
DeviceOrientation.clearDeviceOrientationOverride: { paramsType: []; returnType: void; }

Clears the overridden Device Orientation.

DeviceOrientation.setDeviceOrientationOverride: { paramsType: [Protocol.DeviceOrientation.SetDeviceOrientationOverrideRequest]; returnType: void; }

Overrides the Device Orientation.

Emulation.canEmulate: { paramsType: []; returnType: Protocol.Emulation.CanEmulateResponse; }

Tells whether emulation is supported.

Emulation.clearDeviceMetricsOverride: { paramsType: []; returnType: void; }

Clears the overridden device metrics.

Emulation.clearGeolocationOverride: { paramsType: []; returnType: void; }

Clears the overridden Geolocation Position and Error.

Emulation.resetPageScaleFactor: { paramsType: []; returnType: void; }

Requests that page scale factor is reset to initial values.

Emulation.setFocusEmulationEnabled: { paramsType: [Protocol.Emulation.SetFocusEmulationEnabledRequest]; returnType: void; }

Enables or disables simulating a focused and active page.

Emulation.setAutoDarkModeOverride: { paramsType: [Protocol.Emulation.SetAutoDarkModeOverrideRequest]; returnType: void; }

Automatically render all web contents using a dark theme.

Emulation.setCPUThrottlingRate: { paramsType: [Protocol.Emulation.SetCPUThrottlingRateRequest]; returnType: void; }

Enables CPU throttling to emulate slow CPUs.

Emulation.setDefaultBackgroundColorOverride: { paramsType: [Protocol.Emulation.SetDefaultBackgroundColorOverrideRequest]; returnType: void; }

Sets or clears an override of the default background color of the frame. This override is used if the content does not specify one.

Emulation.setDeviceMetricsOverride: { paramsType: [Protocol.Emulation.SetDeviceMetricsOverrideRequest]; returnType: void; }

Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media query results).

Emulation.setScrollbarsHidden: { paramsType: [Protocol.Emulation.SetScrollbarsHiddenRequest]; returnType: void; }
Emulation.setDocumentCookieDisabled: { paramsType: [Protocol.Emulation.SetDocumentCookieDisabledRequest]; returnType: void; }
Emulation.setEmitTouchEventsForMouse: { paramsType: [Protocol.Emulation.SetEmitTouchEventsForMouseRequest]; returnType: void; }
Emulation.setEmulatedMedia: { paramsType: [Protocol.Emulation.SetEmulatedMediaRequest]; returnType: void; }

Emulates the given media type or media feature for CSS media queries.

Emulation.setEmulatedVisionDeficiency: { paramsType: [Protocol.Emulation.SetEmulatedVisionDeficiencyRequest]; returnType: void; }

Emulates the given vision deficiency.

Emulation.setGeolocationOverride: { paramsType: [Protocol.Emulation.SetGeolocationOverrideRequest]; returnType: void; }

Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position unavailable.

Emulation.setIdleOverride: { paramsType: [Protocol.Emulation.SetIdleOverrideRequest]; returnType: void; }

Overrides the Idle state.

Emulation.clearIdleOverride: { paramsType: []; returnType: void; }

Clears Idle state overrides.

Emulation.setNavigatorOverrides: { paramsType: [Protocol.Emulation.SetNavigatorOverridesRequest]; returnType: void; }

Overrides value returned by the javascript navigator object.

Emulation.setPageScaleFactor: { paramsType: [Protocol.Emulation.SetPageScaleFactorRequest]; returnType: void; }

Sets a specified page scale factor.

Emulation.setScriptExecutionDisabled: { paramsType: [Protocol.Emulation.SetScriptExecutionDisabledRequest]; returnType: void; }

Switches script execution in the page.

Emulation.setTouchEmulationEnabled: { paramsType: [Protocol.Emulation.SetTouchEmulationEnabledRequest]; returnType: void; }

Enables touch on platforms which do not support them.

Emulation.setVirtualTimePolicy: { paramsType: [Protocol.Emulation.SetVirtualTimePolicyRequest]; returnType: Protocol.Emulation.SetVirtualTimePolicyResponse; }

Turns on virtual time for all frames (replacing real-time with a synthetic time source) and sets the current virtual time policy. Note this supersedes any previous time budget.

Emulation.setLocaleOverride: { paramsType: [Protocol.Emulation.SetLocaleOverrideRequest]; returnType: void; }

Overrides default host system locale with the specified one.

Emulation.setTimezoneOverride: { paramsType: [Protocol.Emulation.SetTimezoneOverrideRequest]; returnType: void; }

Overrides default host system timezone with the specified one.

Emulation.setVisibleSize: { paramsType: [Protocol.Emulation.SetVisibleSizeRequest]; returnType: void; }

Resizes the frame/viewport of the page. Note that this does not affect the frame's container (e.g. browser window). Can be used to produce screenshots of the specified size. Not supported on Android.

Emulation.setDisabledImageTypes: { paramsType: [Protocol.Emulation.SetDisabledImageTypesRequest]; returnType: void; }
Emulation.setHardwareConcurrencyOverride: { paramsType: [Protocol.Emulation.SetHardwareConcurrencyOverrideRequest]; returnType: void; }
Emulation.setUserAgentOverride: { paramsType: [Protocol.Emulation.SetUserAgentOverrideRequest]; returnType: void; }

Allows overriding user agent with the given string.

Emulation.setAutomationOverride: { paramsType: [Protocol.Emulation.SetAutomationOverrideRequest]; returnType: void; }

Allows overriding the automation flag.

HeadlessExperimental.beginFrame: { paramsType: [Protocol.HeadlessExperimental.BeginFrameRequest]; returnType: Protocol.HeadlessExperimental.BeginFrameResponse; }

Sends a BeginFrame to the target and returns when the frame was completed. Optionally captures a screenshot from the resulting frame. Requires that the target was created with enabled BeginFrameControl. Designed for use with --run-all-compositor-stages-before-draw, see also https://goo.gle/chrome-headless-rendering for more background.

HeadlessExperimental.disable: { paramsType: []; returnType: void; }

Disables headless events for the target.

HeadlessExperimental.enable: { paramsType: []; returnType: void; }

Enables headless events for the target.

IO.close: { paramsType: [Protocol.IO.CloseRequest]; returnType: void; }

Close the stream, discard any temporary backing storage.

IO.read: { paramsType: [Protocol.IO.ReadRequest]; returnType: Protocol.IO.ReadResponse; }

Read a chunk of the stream

IO.resolveBlob: { paramsType: [Protocol.IO.ResolveBlobRequest]; returnType: Protocol.IO.ResolveBlobResponse; }

Return UUID of Blob object specified by a remote object id.

IndexedDB.clearObjectStore: { paramsType: [Protocol.IndexedDB.ClearObjectStoreRequest]; returnType: void; }

Clears all entries from an object store.

IndexedDB.deleteDatabase: { paramsType: [Protocol.IndexedDB.DeleteDatabaseRequest]; returnType: void; }

Deletes a database.

IndexedDB.deleteObjectStoreEntries: { paramsType: [Protocol.IndexedDB.DeleteObjectStoreEntriesRequest]; returnType: void; }

Delete a range of entries from an object store

IndexedDB.disable: { paramsType: []; returnType: void; }

Disables events from backend.

IndexedDB.enable: { paramsType: []; returnType: void; }

Enables events from backend.

IndexedDB.requestData: { paramsType: [Protocol.IndexedDB.RequestDataRequest]; returnType: Protocol.IndexedDB.RequestDataResponse; }

Requests data from object store or index.

IndexedDB.getMetadata: { paramsType: [Protocol.IndexedDB.GetMetadataRequest]; returnType: Protocol.IndexedDB.GetMetadataResponse; }

Gets metadata of an object store

IndexedDB.requestDatabase: { paramsType: [Protocol.IndexedDB.RequestDatabaseRequest]; returnType: Protocol.IndexedDB.RequestDatabaseResponse; }

Requests database with given name in given frame.

IndexedDB.requestDatabaseNames: { paramsType: [Protocol.IndexedDB.RequestDatabaseNamesRequest]; returnType: Protocol.IndexedDB.RequestDatabaseNamesResponse; }

Requests database names for given security origin.

Input.dispatchDragEvent: { paramsType: [Protocol.Input.DispatchDragEventRequest]; returnType: void; }

Dispatches a drag event into the page.

Input.dispatchKeyEvent: { paramsType: [Protocol.Input.DispatchKeyEventRequest]; returnType: void; }

Dispatches a key event to the page.

Input.insertText: { paramsType: [Protocol.Input.InsertTextRequest]; returnType: void; }

This method emulates inserting text that doesn't come from a key press, for example an emoji keyboard or an IME.

Input.imeSetComposition: { paramsType: [Protocol.Input.ImeSetCompositionRequest]; returnType: void; }

This method sets the current candidate text for ime. Use imeCommitComposition to commit the final text. Use imeSetComposition with empty string as text to cancel composition.

Input.dispatchMouseEvent: { paramsType: [Protocol.Input.DispatchMouseEventRequest]; returnType: void; }

Dispatches a mouse event to the page.

Input.dispatchTouchEvent: { paramsType: [Protocol.Input.DispatchTouchEventRequest]; returnType: void; }

Dispatches a touch event to the page.

Input.emulateTouchFromMouseEvent: { paramsType: [Protocol.Input.EmulateTouchFromMouseEventRequest]; returnType: void; }

Emulates touch event from the mouse event parameters.

Input.setIgnoreInputEvents: { paramsType: [Protocol.Input.SetIgnoreInputEventsRequest]; returnType: void; }

Ignores input events (useful while auditing page).

Input.setInterceptDrags: { paramsType: [Protocol.Input.SetInterceptDragsRequest]; returnType: void; }

Prevents default drag and drop behavior and instead emits Input.dragIntercepted events. Drag and drop behavior can be directly controlled via Input.dispatchDragEvent.

Input.synthesizePinchGesture: { paramsType: [Protocol.Input.SynthesizePinchGestureRequest]; returnType: void; }

Synthesizes a pinch gesture over a time period by issuing appropriate touch events.

Input.synthesizeScrollGesture: { paramsType: [Protocol.Input.SynthesizeScrollGestureRequest]; returnType: void; }

Synthesizes a scroll gesture over a time period by issuing appropriate touch events.

Input.synthesizeTapGesture: { paramsType: [Protocol.Input.SynthesizeTapGestureRequest]; returnType: void; }

Synthesizes a tap gesture over a time period by issuing appropriate touch events.

Inspector.disable: { paramsType: []; returnType: void; }

Disables inspector domain notifications.

Inspector.enable: { paramsType: []; returnType: void; }

Enables inspector domain notifications.

LayerTree.compositingReasons: { paramsType: [Protocol.LayerTree.CompositingReasonsRequest]; returnType: Protocol.LayerTree.CompositingReasonsResponse; }

Provides the reasons why the given layer was composited.

LayerTree.disable: { paramsType: []; returnType: void; }

Disables compositing tree inspection.

LayerTree.enable: { paramsType: []; returnType: void; }

Enables compositing tree inspection.

LayerTree.loadSnapshot: { paramsType: [Protocol.LayerTree.LoadSnapshotRequest]; returnType: Protocol.LayerTree.LoadSnapshotResponse; }

Returns the snapshot identifier.

LayerTree.makeSnapshot: { paramsType: [Protocol.LayerTree.MakeSnapshotRequest]; returnType: Protocol.LayerTree.MakeSnapshotResponse; }

Returns the layer snapshot identifier.

LayerTree.profileSnapshot: { paramsType: [Protocol.LayerTree.ProfileSnapshotRequest]; returnType: Protocol.LayerTree.ProfileSnapshotResponse; }
LayerTree.releaseSnapshot: { paramsType: [Protocol.LayerTree.ReleaseSnapshotRequest]; returnType: void; }

Releases layer snapshot captured by the back-end.

LayerTree.replaySnapshot: { paramsType: [Protocol.LayerTree.ReplaySnapshotRequest]; returnType: Protocol.LayerTree.ReplaySnapshotResponse; }

Replays the layer snapshot and returns the resulting bitmap.

LayerTree.snapshotCommandLog: { paramsType: [Protocol.LayerTree.SnapshotCommandLogRequest]; returnType: Protocol.LayerTree.SnapshotCommandLogResponse; }

Replays the layer snapshot and returns canvas log.

Log.clear: { paramsType: []; returnType: void; }

Clears the log.

Log.disable: { paramsType: []; returnType: void; }

Disables log domain, prevents further log entries from being reported to the client.

Log.enable: { paramsType: []; returnType: void; }

Enables log domain, sends the entries collected so far to the client by means of the entryAdded notification.

Log.startViolationsReport: { paramsType: [Protocol.Log.StartViolationsReportRequest]; returnType: void; }

start violation reporting.

Log.stopViolationsReport: { paramsType: []; returnType: void; }

Stop violation reporting.

Memory.getDOMCounters: { paramsType: []; returnType: Protocol.Memory.GetDOMCountersResponse; }
Memory.prepareForLeakDetection: { paramsType: []; returnType: void; }
Memory.forciblyPurgeJavaScriptMemory: { paramsType: []; returnType: void; }

Simulate OomIntervention by purging V8 memory.

Memory.setPressureNotificationsSuppressed: { paramsType: [Protocol.Memory.SetPressureNotificationsSuppressedRequest]; returnType: void; }

Enable/disable suppressing memory pressure notifications in all processes.

Memory.simulatePressureNotification: { paramsType: [Protocol.Memory.SimulatePressureNotificationRequest]; returnType: void; }

Simulate a memory pressure notification in all processes.

Memory.startSampling: { paramsType: [Protocol.Memory.StartSamplingRequest]; returnType: void; }

Start collecting native memory profile.

Memory.stopSampling: { paramsType: []; returnType: void; }

Stop collecting native memory profile.

Memory.getAllTimeSamplingProfile: { paramsType: []; returnType: Protocol.Memory.GetAllTimeSamplingProfileResponse; }

Retrieve native memory allocations profile collected since renderer process startup.

Memory.getBrowserSamplingProfile: { paramsType: []; returnType: Protocol.Memory.GetBrowserSamplingProfileResponse; }

Retrieve native memory allocations profile collected since browser process startup.

Memory.getSamplingProfile: { paramsType: []; returnType: Protocol.Memory.GetSamplingProfileResponse; }

Retrieve native memory allocations profile collected since last startSampling call.

Network.setAcceptedEncodings: { paramsType: [Protocol.Network.SetAcceptedEncodingsRequest]; returnType: void; }

Sets a list of content encodings that will be accepted. Empty list means no encoding is accepted.

Network.clearAcceptedEncodingsOverride: { paramsType: []; returnType: void; }

Clears accepted encodings set by setAcceptedEncodings

Network.canClearBrowserCache: { paramsType: []; returnType: Protocol.Network.CanClearBrowserCacheResponse; }

Tells whether clearing browser cache is supported.

Network.canClearBrowserCookies: { paramsType: []; returnType: Protocol.Network.CanClearBrowserCookiesResponse; }

Tells whether clearing browser cookies is supported.

Network.canEmulateNetworkConditions: { paramsType: []; returnType: Protocol.Network.CanEmulateNetworkConditionsResponse; }

Tells whether emulation of network conditions is supported.

Network.clearBrowserCache: { paramsType: []; returnType: void; }

Clears browser cache.

Network.clearBrowserCookies: { paramsType: []; returnType: void; }

Clears browser cookies.

Network.continueInterceptedRequest: { paramsType: [Protocol.Network.ContinueInterceptedRequestRequest]; returnType: void; }

Response to Network.requestIntercepted which either modifies the request to continue with any modifications, or blocks it, or completes it with the provided response bytes. If a network fetch occurs as a result which encounters a redirect an additional Network.requestIntercepted event will be sent with the same InterceptionId. Deprecated, use Fetch.continueRequest, Fetch.fulfillRequest and Fetch.failRequest instead.

Network.deleteCookies: { paramsType: [Protocol.Network.DeleteCookiesRequest]; returnType: void; }

Deletes browser cookies with matching name and url or domain/path pair.

Network.disable: { paramsType: []; returnType: void; }

Disables network tracking, prevents network events from being sent to the client.

Network.emulateNetworkConditions: { paramsType: [Protocol.Network.EmulateNetworkConditionsRequest]; returnType: void; }

Activates emulation of network conditions.

Network.enable: { paramsType: [Protocol.Network.EnableRequest]; returnType: void; }

Enables network tracking, network events will now be delivered to the client.

Network.getAllCookies: { paramsType: []; returnType: Protocol.Network.GetAllCookiesResponse; }

Returns all browser cookies. Depending on the backend support, will return detailed cookie information in the cookies field.

Network.getCertificate: { paramsType: [Protocol.Network.GetCertificateRequest]; returnType: Protocol.Network.GetCertificateResponse; }

Returns the DER-encoded certificate.

Network.getCookies: { paramsType: [Protocol.Network.GetCookiesRequest]; returnType: Protocol.Network.GetCookiesResponse; }

Returns all browser cookies for the current URL. Depending on the backend support, will return detailed cookie information in the cookies field.

Network.getResponseBody: { paramsType: [Protocol.Network.GetResponseBodyRequest]; returnType: Protocol.Network.GetResponseBodyResponse; }

Returns content served for the given request.

Network.getRequestPostData: { paramsType: [Protocol.Network.GetRequestPostDataRequest]; returnType: Protocol.Network.GetRequestPostDataResponse; }

Returns post data sent with the request. Returns an error when no data was sent with the request.

Network.getResponseBodyForInterception: { paramsType: [Protocol.Network.GetResponseBodyForInterceptionRequest]; returnType: Protocol.Network.GetResponseBodyForInterceptionResponse; }

Returns content served for the given currently intercepted request.

Network.takeResponseBodyForInterceptionAsStream: { paramsType: [Protocol.Network.TakeResponseBodyForInterceptionAsStreamRequest]; returnType: Protocol.Network.TakeResponseBodyForInterceptionAsStreamResponse; }

Returns a handle to the stream representing the response body. Note that after this command, the intercepted request can't be continued as is -- you either need to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified.

Network.replayXHR: { paramsType: [Protocol.Network.ReplayXHRRequest]; returnType: void; }

This method sends a new XMLHttpRequest which is identical to the original one. The following parameters should be identical: method, url, async, request body, extra headers, withCredentials attribute, user, password.

Network.searchInResponseBody: { paramsType: [Protocol.Network.SearchInResponseBodyRequest]; returnType: Protocol.Network.SearchInResponseBodyResponse; }

Searches for given string in response content.

Network.setBlockedURLs: { paramsType: [Protocol.Network.SetBlockedURLsRequest]; returnType: void; }

Blocks URLs from loading.

Network.setBypassServiceWorker: { paramsType: [Protocol.Network.SetBypassServiceWorkerRequest]; returnType: void; }

Toggles ignoring of service worker for each request.

Network.setCacheDisabled: { paramsType: [Protocol.Network.SetCacheDisabledRequest]; returnType: void; }

Toggles ignoring cache for each request. If true, cache will not be used.

Network.setCookie: { paramsType: [Protocol.Network.SetCookieRequest]; returnType: Protocol.Network.SetCookieResponse; }

Sets a cookie with the given cookie data; may overwrite equivalent cookies if they exist.

Network.setCookies: { paramsType: [Protocol.Network.SetCookiesRequest]; returnType: void; }

Sets given cookies.

Network.setExtraHTTPHeaders: { paramsType: [Protocol.Network.SetExtraHTTPHeadersRequest]; returnType: void; }

Specifies whether to always send extra HTTP headers with the requests from this page.

Network.setAttachDebugStack: { paramsType: [Protocol.Network.SetAttachDebugStackRequest]; returnType: void; }

Specifies whether to attach a page script stack id in requests

Network.setRequestInterception: { paramsType: [Protocol.Network.SetRequestInterceptionRequest]; returnType: void; }

Sets the requests to intercept that match the provided patterns and optionally resource types. Deprecated, please use Fetch.enable instead.

Network.setUserAgentOverride: { paramsType: [Protocol.Network.SetUserAgentOverrideRequest]; returnType: void; }

Allows overriding user agent with the given string.

Network.getSecurityIsolationStatus: { paramsType: [Protocol.Network.GetSecurityIsolationStatusRequest]; returnType: Protocol.Network.GetSecurityIsolationStatusResponse; }

Returns information about the COEP/COOP isolation status.

Network.enableReportingApi: { paramsType: [Protocol.Network.EnableReportingApiRequest]; returnType: void; }

Enables tracking for the Reporting API, events generated by the Reporting API will now be delivered to the client. Enabling triggers 'reportingApiReportAdded' for all existing reports.

Network.loadNetworkResource: { paramsType: [Protocol.Network.LoadNetworkResourceRequest]; returnType: Protocol.Network.LoadNetworkResourceResponse; }

Fetches the resource and returns the content.

Overlay.disable: { paramsType: []; returnType: void; }

Disables domain notifications.

Overlay.enable: { paramsType: []; returnType: void; }

Enables domain notifications.

Overlay.getHighlightObjectForTest: { paramsType: [Protocol.Overlay.GetHighlightObjectForTestRequest]; returnType: Protocol.Overlay.GetHighlightObjectForTestResponse; }

For testing.

Overlay.getGridHighlightObjectsForTest: { paramsType: [Protocol.Overlay.GetGridHighlightObjectsForTestRequest]; returnType: Protocol.Overlay.GetGridHighlightObjectsForTestResponse; }

For Persistent Grid testing.

Overlay.getSourceOrderHighlightObjectForTest: { paramsType: [Protocol.Overlay.GetSourceOrderHighlightObjectForTestRequest]; returnType: Protocol.Overlay.GetSourceOrderHighlightObjectForTestResponse; }

For Source Order Viewer testing.

Overlay.hideHighlight: { paramsType: []; returnType: void; }

Hides any highlight.

Overlay.highlightFrame: { paramsType: [Protocol.Overlay.HighlightFrameRequest]; returnType: void; }

Highlights owner element of the frame with given id. Deprecated: Doesn't work reliablity and cannot be fixed due to process separatation (the owner node might be in a different process). Determine the owner node in the client and use highlightNode.

Overlay.highlightNode: { paramsType: [Protocol.Overlay.HighlightNodeRequest]; returnType: void; }

Highlights DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified.

Overlay.highlightQuad: { paramsType: [Protocol.Overlay.HighlightQuadRequest]; returnType: void; }

Highlights given quad. Coordinates are absolute with respect to the main frame viewport.

Overlay.highlightRect: { paramsType: [Protocol.Overlay.HighlightRectRequest]; returnType: void; }

Highlights given rectangle. Coordinates are absolute with respect to the main frame viewport.

Overlay.highlightSourceOrder: { paramsType: [Protocol.Overlay.HighlightSourceOrderRequest]; returnType: void; }

Highlights the source order of the children of the DOM node with given id or with the given JavaScript object wrapper. Either nodeId or objectId must be specified.

Overlay.setInspectMode: { paramsType: [Protocol.Overlay.SetInspectModeRequest]; returnType: void; }

Enters the 'inspect' mode. In this mode, elements that user is hovering over are highlighted. Backend then generates 'inspectNodeRequested' event upon element selection.

Overlay.setShowAdHighlights: { paramsType: [Protocol.Overlay.SetShowAdHighlightsRequest]; returnType: void; }

Highlights owner element of all frames detected to be ads.

Overlay.setPausedInDebuggerMessage: { paramsType: [Protocol.Overlay.SetPausedInDebuggerMessageRequest]; returnType: void; }
Overlay.setShowDebugBorders: { paramsType: [Protocol.Overlay.SetShowDebugBordersRequest]; returnType: void; }

Requests that backend shows debug borders on layers

Overlay.setShowFPSCounter: { paramsType: [Protocol.Overlay.SetShowFPSCounterRequest]; returnType: void; }

Requests that backend shows the FPS counter

Overlay.setShowGridOverlays: { paramsType: [Protocol.Overlay.SetShowGridOverlaysRequest]; returnType: void; }

Highlight multiple elements with the CSS Grid overlay.

Overlay.setShowFlexOverlays: { paramsType: [Protocol.Overlay.SetShowFlexOverlaysRequest]; returnType: void; }
Overlay.setShowScrollSnapOverlays: { paramsType: [Protocol.Overlay.SetShowScrollSnapOverlaysRequest]; returnType: void; }
Overlay.setShowContainerQueryOverlays: { paramsType: [Protocol.Overlay.SetShowContainerQueryOverlaysRequest]; returnType: void; }
Overlay.setShowPaintRects: { paramsType: [Protocol.Overlay.SetShowPaintRectsRequest]; returnType: void; }

Requests that backend shows paint rectangles

Overlay.setShowLayoutShiftRegions: { paramsType: [Protocol.Overlay.SetShowLayoutShiftRegionsRequest]; returnType: void; }

Requests that backend shows layout shift regions

Overlay.setShowScrollBottleneckRects: { paramsType: [Protocol.Overlay.SetShowScrollBottleneckRectsRequest]; returnType: void; }

Requests that backend shows scroll bottleneck rects

Overlay.setShowHitTestBorders: { paramsType: [Protocol.Overlay.SetShowHitTestBordersRequest]; returnType: void; }

Deprecated, no longer has any effect.

Overlay.setShowWebVitals: { paramsType: [Protocol.Overlay.SetShowWebVitalsRequest]; returnType: void; }

Request that backend shows an overlay with web vital metrics.

Overlay.setShowViewportSizeOnResize: { paramsType: [Protocol.Overlay.SetShowViewportSizeOnResizeRequest]; returnType: void; }

Paints viewport size upon main frame resize.

Overlay.setShowHinge: { paramsType: [Protocol.Overlay.SetShowHingeRequest]; returnType: void; }

Add a dual screen device hinge

Overlay.setShowIsolatedElements: { paramsType: [Protocol.Overlay.SetShowIsolatedElementsRequest]; returnType: void; }

Show elements in isolation mode with overlays.

Page.addScriptToEvaluateOnLoad: { paramsType: [Protocol.Page.AddScriptToEvaluateOnLoadRequest]; returnType: Protocol.Page.AddScriptToEvaluateOnLoadResponse; }

Deprecated, please use addScriptToEvaluateOnNewDocument instead.

Page.addScriptToEvaluateOnNewDocument: { paramsType: [Protocol.Page.AddScriptToEvaluateOnNewDocumentRequest]; returnType: Protocol.Page.AddScriptToEvaluateOnNewDocumentResponse; }

Evaluates given script in every frame upon creation (before loading frame's scripts).

Page.bringToFront: { paramsType: []; returnType: void; }

Brings page to front (activates tab).

Page.captureScreenshot: { paramsType: [Protocol.Page.CaptureScreenshotRequest]; returnType: Protocol.Page.CaptureScreenshotResponse; }

Capture page screenshot.

Page.captureSnapshot: { paramsType: [Protocol.Page.CaptureSnapshotRequest]; returnType: Protocol.Page.CaptureSnapshotResponse; }

Returns a snapshot of the page as a string. For MHTML format, the serialization includes iframes, shadow DOM, external resources, and element-inline styles.

Page.clearDeviceMetricsOverride: { paramsType: []; returnType: void; }

Clears the overridden device metrics.

Page.clearDeviceOrientationOverride: { paramsType: []; returnType: void; }

Clears the overridden Device Orientation.

Page.clearGeolocationOverride: { paramsType: []; returnType: void; }

Clears the overridden Geolocation Position and Error.

Page.createIsolatedWorld: { paramsType: [Protocol.Page.CreateIsolatedWorldRequest]; returnType: Protocol.Page.CreateIsolatedWorldResponse; }

Creates an isolated world for the given frame.

Page.deleteCookie: { paramsType: [Protocol.Page.DeleteCookieRequest]; returnType: void; }

Deletes browser cookie with given name, domain and path.

Page.disable: { paramsType: []; returnType: void; }

Disables page domain notifications.

Page.enable: { paramsType: []; returnType: void; }

Enables page domain notifications.

Page.getAppManifest: { paramsType: []; returnType: Protocol.Page.GetAppManifestResponse; }
Page.getInstallabilityErrors: { paramsType: []; returnType: Protocol.Page.GetInstallabilityErrorsResponse; }
Page.getManifestIcons: { paramsType: []; returnType: Protocol.Page.GetManifestIconsResponse; }
Page.getAppId: { paramsType: []; returnType: Protocol.Page.GetAppIdResponse; }

Returns the unique (PWA) app id. Only returns values if the feature flag 'WebAppEnableManifestId' is enabled

Page.getCookies: { paramsType: []; returnType: Protocol.Page.GetCookiesResponse; }

Returns all browser cookies. Depending on the backend support, will return detailed cookie information in the cookies field.

Page.getFrameTree: { paramsType: []; returnType: Protocol.Page.GetFrameTreeResponse; }

Returns present frame tree structure.

Page.getLayoutMetrics: { paramsType: []; returnType: Protocol.Page.GetLayoutMetricsResponse; }

Returns metrics relating to the layouting of the page, such as viewport bounds/scale.

Page.getNavigationHistory: { paramsType: []; returnType: Protocol.Page.GetNavigationHistoryResponse; }

Returns navigation history for the current page.

Page.resetNavigationHistory: { paramsType: []; returnType: void; }

Resets navigation history for the current page.

Page.getResourceContent: { paramsType: [Protocol.Page.GetResourceContentRequest]; returnType: Protocol.Page.GetResourceContentResponse; }

Returns content of the given resource.

Page.getResourceTree: { paramsType: []; returnType: Protocol.Page.GetResourceTreeResponse; }

Returns present frame / resource tree structure.

Page.handleJavaScriptDialog: { paramsType: [Protocol.Page.HandleJavaScriptDialogRequest]; returnType: void; }

Accepts or dismisses a JavaScript initiated dialog (alert, confirm, prompt, or onbeforeunload).

Page.navigate: { paramsType: [Protocol.Page.NavigateRequest]; returnType: Protocol.Page.NavigateResponse; }

Navigates current page to the given URL.

Page.navigateToHistoryEntry: { paramsType: [Protocol.Page.NavigateToHistoryEntryRequest]; returnType: void; }

Navigates current page to the given history entry.

Page.printToPDF: { paramsType: [Protocol.Page.PrintToPDFRequest]; returnType: Protocol.Page.PrintToPDFResponse; }

Print page as PDF.

Page.reload: { paramsType: [Protocol.Page.ReloadRequest]; returnType: void; }

Reloads given page optionally ignoring the cache.

Page.removeScriptToEvaluateOnLoad: { paramsType: [Protocol.Page.RemoveScriptToEvaluateOnLoadRequest]; returnType: void; }

Deprecated, please use removeScriptToEvaluateOnNewDocument instead.

Page.removeScriptToEvaluateOnNewDocument: { paramsType: [Protocol.Page.RemoveScriptToEvaluateOnNewDocumentRequest]; returnType: void; }

Removes given script from the list.

Page.screencastFrameAck: { paramsType: [Protocol.Page.ScreencastFrameAckRequest]; returnType: void; }

Acknowledges that a screencast frame has been received by the frontend.

Page.searchInResource: { paramsType: [Protocol.Page.SearchInResourceRequest]; returnType: Protocol.Page.SearchInResourceResponse; }

Searches for given string in resource content.

Page.setAdBlockingEnabled: { paramsType: [Protocol.Page.SetAdBlockingEnabledRequest]; returnType: void; }

Enable Chrome's experimental ad filter on all sites.

Page.setBypassCSP: { paramsType: [Protocol.Page.SetBypassCSPRequest]; returnType: void; }

Enable page Content Security Policy by-passing.

Page.getPermissionsPolicyState: { paramsType: [Protocol.Page.GetPermissionsPolicyStateRequest]; returnType: Protocol.Page.GetPermissionsPolicyStateResponse; }

Get Permissions Policy state on given frame.

Page.getOriginTrials: { paramsType: [Protocol.Page.GetOriginTrialsRequest]; returnType: Protocol.Page.GetOriginTrialsResponse; }

Get Origin Trials on given frame.

Page.setDeviceMetricsOverride: { paramsType: [Protocol.Page.SetDeviceMetricsOverrideRequest]; returnType: void; }

Overrides the values of device screen dimensions (window.screen.width, window.screen.height, window.innerWidth, window.innerHeight, and "device-width"/"device-height"-related CSS media query results).

Page.setDeviceOrientationOverride: { paramsType: [Protocol.Page.SetDeviceOrientationOverrideRequest]; returnType: void; }

Overrides the Device Orientation.

Page.setFontFamilies: { paramsType: [Protocol.Page.SetFontFamiliesRequest]; returnType: void; }

Set generic font families.

Page.setFontSizes: { paramsType: [Protocol.Page.SetFontSizesRequest]; returnType: void; }

Set default font sizes.

Page.setDocumentContent: { paramsType: [Protocol.Page.SetDocumentContentRequest]; returnType: void; }

Sets given markup as the document's HTML.

Page.setDownloadBehavior: { paramsType: [Protocol.Page.SetDownloadBehaviorRequest]; returnType: void; }

Set the behavior when downloading a file.

Page.setGeolocationOverride: { paramsType: [Protocol.Page.SetGeolocationOverrideRequest]; returnType: void; }

Overrides the Geolocation Position or Error. Omitting any of the parameters emulates position unavailable.

Page.setLifecycleEventsEnabled: { paramsType: [Protocol.Page.SetLifecycleEventsEnabledRequest]; returnType: void; }

Controls whether page will emit lifecycle events.

Page.setTouchEmulationEnabled: { paramsType: [Protocol.Page.SetTouchEmulationEnabledRequest]; returnType: void; }

Toggles mouse event-based touch event emulation.

Page.startScreencast: { paramsType: [Protocol.Page.StartScreencastRequest]; returnType: void; }

Starts sending each frame using the screencastFrame event.

Page.stopLoading: { paramsType: []; returnType: void; }

Force the page stop all navigations and pending resource fetches.

Page.crash: { paramsType: []; returnType: void; }

Crashes renderer on the IO thread, generates minidumps.

Page.close: { paramsType: []; returnType: void; }

Tries to close page, running its beforeunload hooks, if any.

Page.setWebLifecycleState: { paramsType: [Protocol.Page.SetWebLifecycleStateRequest]; returnType: void; }

Tries to update the web lifecycle state of the page. It will transition the page to the given state according to: https://github.com/WICG/web-lifecycle/

Page.stopScreencast: { paramsType: []; returnType: void; }

Stops sending each frame in the screencastFrame.

Page.produceCompilationCache: { paramsType: [Protocol.Page.ProduceCompilationCacheRequest]; returnType: void; }

Requests backend to produce compilation cache for the specified scripts. scripts are appeneded to the list of scripts for which the cache would be produced. The list may be reset during page navigation. When script with a matching URL is encountered, the cache is optionally produced upon backend discretion, based on internal heuristics. See also: Page.compilationCacheProduced.

Page.addCompilationCache: { paramsType: [Protocol.Page.AddCompilationCacheRequest]; returnType: void; }

Seeds compilation cache for given url. Compilation cache does not survive cross-process navigation.

Page.clearCompilationCache: { paramsType: []; returnType: void; }

Clears seeded compilation cache.

Page.setSPCTransactionMode: { paramsType: [Protocol.Page.SetSPCTransactionModeRequest]; returnType: void; }
Page.generateTestReport: { paramsType: [Protocol.Page.GenerateTestReportRequest]; returnType: void; }

Generates a report for testing.

Page.waitForDebugger: { paramsType: []; returnType: void; }

Pauses page execution. Can be resumed using generic Runtime.runIfWaitingForDebugger.

Page.setInterceptFileChooserDialog: { paramsType: [Protocol.Page.SetInterceptFileChooserDialogRequest]; returnType: void; }

Intercept file chooser requests and transfer control to protocol clients. When file chooser interception is enabled, native file chooser dialog is not shown. Instead, a protocol event Page.fileChooserOpened is emitted.

Performance.disable: { paramsType: []; returnType: void; }

Disable collecting and reporting metrics.

Performance.enable: { paramsType: [Protocol.Performance.EnableRequest]; returnType: void; }

Enable collecting and reporting metrics.

Performance.setTimeDomain: { paramsType: [Protocol.Performance.SetTimeDomainRequest]; returnType: void; }

Sets time domain to use for collecting and reporting duration metrics. Note that this must be called before enabling metrics collection. Calling this method while metrics collection is enabled returns an error.

Performance.getMetrics: { paramsType: []; returnType: Protocol.Performance.GetMetricsResponse; }

Retrieve current values of run-time metrics.

PerformanceTimeline.enable: { paramsType: [Protocol.PerformanceTimeline.EnableRequest]; returnType: void; }

Previously buffered events would be reported before method returns. See also: timelineEventAdded

Security.disable: { paramsType: []; returnType: void; }

Disables tracking security state changes.

Security.enable: { paramsType: []; returnType: void; }

Enables tracking security state changes.

Security.setIgnoreCertificateErrors: { paramsType: [Protocol.Security.SetIgnoreCertificateErrorsRequest]; returnType: void; }

Enable/disable whether all certificate errors should be ignored.

Security.handleCertificateError: { paramsType: [Protocol.Security.HandleCertificateErrorRequest]; returnType: void; }

Handles a certificate error that fired a certificateError event.

Security.setOverrideCertificateErrors: { paramsType: [Protocol.Security.SetOverrideCertificateErrorsRequest]; returnType: void; }

Enable/disable overriding certificate errors. If enabled, all certificate error events need to be handled by the DevTools client and should be answered with handleCertificateError commands.

ServiceWorker.deliverPushMessage: { paramsType: [Protocol.ServiceWorker.DeliverPushMessageRequest]; returnType: void; }
ServiceWorker.disable: { paramsType: []; returnType: void; }
ServiceWorker.dispatchSyncEvent: { paramsType: [Protocol.ServiceWorker.DispatchSyncEventRequest]; returnType: void; }
ServiceWorker.dispatchPeriodicSyncEvent: { paramsType: [Protocol.ServiceWorker.DispatchPeriodicSyncEventRequest]; returnType: void; }
ServiceWorker.enable: { paramsType: []; returnType: void; }
ServiceWorker.inspectWorker: { paramsType: [Protocol.ServiceWorker.InspectWorkerRequest]; returnType: void; }
ServiceWorker.setForceUpdateOnPageLoad: { paramsType: [Protocol.ServiceWorker.SetForceUpdateOnPageLoadRequest]; returnType: void; }
ServiceWorker.skipWaiting: { paramsType: [Protocol.ServiceWorker.SkipWaitingRequest]; returnType: void; }
ServiceWorker.startWorker: { paramsType: [Protocol.ServiceWorker.StartWorkerRequest]; returnType: void; }
ServiceWorker.stopAllWorkers: { paramsType: []; returnType: void; }
ServiceWorker.stopWorker: { paramsType: [Protocol.ServiceWorker.StopWorkerRequest]; returnType: void; }
ServiceWorker.unregister: { paramsType: [Protocol.ServiceWorker.UnregisterRequest]; returnType: void; }
ServiceWorker.updateRegistration: { paramsType: [Protocol.ServiceWorker.UpdateRegistrationRequest]; returnType: void; }
Storage.getStorageKeyForFrame: { paramsType: [Protocol.Storage.GetStorageKeyForFrameRequest]; returnType: Protocol.Storage.GetStorageKeyForFrameResponse; }

Returns a storage key given a frame id.

Storage.clearDataForOrigin: { paramsType: [Protocol.Storage.ClearDataForOriginRequest]; returnType: void; }

Clears storage for origin.

Storage.getCookies: { paramsType: [Protocol.Storage.GetCookiesRequest]; returnType: Protocol.Storage.GetCookiesResponse; }

Returns all browser cookies.

Storage.setCookies: { paramsType: [Protocol.Storage.SetCookiesRequest]; returnType: void; }

Sets given cookies.

Storage.clearCookies: { paramsType: [Protocol.Storage.ClearCookiesRequest]; returnType: void; }

Clears cookies.

Storage.getUsageAndQuota: { paramsType: [Protocol.Storage.GetUsageAndQuotaRequest]; returnType: Protocol.Storage.GetUsageAndQuotaResponse; }

Returns usage and quota in bytes.

Storage.overrideQuotaForOrigin: { paramsType: [Protocol.Storage.OverrideQuotaForOriginRequest]; returnType: void; }

Override quota for the specified origin

Storage.trackCacheStorageForOrigin: { paramsType: [Protocol.Storage.TrackCacheStorageForOriginRequest]; returnType: void; }

Registers origin to be notified when an update occurs to its cache storage list.

Storage.trackIndexedDBForOrigin: { paramsType: [Protocol.Storage.TrackIndexedDBForOriginRequest]; returnType: void; }

Registers origin to be notified when an update occurs to its IndexedDB.

Storage.untrackCacheStorageForOrigin: { paramsType: [Protocol.Storage.UntrackCacheStorageForOriginRequest]; returnType: void; }

Unregisters origin from receiving notifications for cache storage.

Storage.untrackIndexedDBForOrigin: { paramsType: [Protocol.Storage.UntrackIndexedDBForOriginRequest]; returnType: void; }

Unregisters origin from receiving notifications for IndexedDB.

Storage.getTrustTokens: { paramsType: []; returnType: Protocol.Storage.GetTrustTokensResponse; }

Returns the number of stored Trust Tokens per issuer for the current browsing context.

Storage.clearTrustTokens: { paramsType: [Protocol.Storage.ClearTrustTokensRequest]; returnType: Protocol.Storage.ClearTrustTokensResponse; }

Removes all Trust Tokens issued by the provided issuerOrigin. Leaves other stored data, including the issuer's Redemption Records, intact.

Storage.getInterestGroupDetails: { paramsType: [Protocol.Storage.GetInterestGroupDetailsRequest]; returnType: Protocol.Storage.GetInterestGroupDetailsResponse; }

Gets details for a named interest group.

Storage.setInterestGroupTracking: { paramsType: [Protocol.Storage.SetInterestGroupTrackingRequest]; returnType: void; }

Enables/Disables issuing of interestGroupAccessed events.

SystemInfo.getInfo: { paramsType: []; returnType: Protocol.SystemInfo.GetInfoResponse; }

Returns information about the system.

SystemInfo.getProcessInfo: { paramsType: []; returnType: Protocol.SystemInfo.GetProcessInfoResponse; }

Returns information about all running processes.

Target.activateTarget: { paramsType: [Protocol.Target.ActivateTargetRequest]; returnType: void; }

Activates (focuses) the target.

Target.attachToTarget: { paramsType: [Protocol.Target.AttachToTargetRequest]; returnType: Protocol.Target.AttachToTargetResponse; }

Attaches to the target with given id.

Target.attachToBrowserTarget: { paramsType: []; returnType: Protocol.Target.AttachToBrowserTargetResponse; }

Attaches to the browser target, only uses flat sessionId mode.

Target.closeTarget: { paramsType: [Protocol.Target.CloseTargetRequest]; returnType: Protocol.Target.CloseTargetResponse; }

Closes the target. If the target is a page that gets closed too.

Target.exposeDevToolsProtocol: { paramsType: [Protocol.Target.ExposeDevToolsProtocolRequest]; returnType: void; }

Inject object to the target's main frame that provides a communication channel with browser target.

Injected object will be available as window[bindingName].

The object has the follwing API:

  • binding.send(json) - a method to send messages over the remote debugging protocol
  • binding.onmessage = json => handleMessage(json) - a callback that will be called for the protocol notifications and command responses.
Target.createBrowserContext: { paramsType: [Protocol.Target.CreateBrowserContextRequest]; returnType: Protocol.Target.CreateBrowserContextResponse; }

Creates a new empty BrowserContext. Similar to an incognito profile but you can have more than one.

Target.getBrowserContexts: { paramsType: []; returnType: Protocol.Target.GetBrowserContextsResponse; }

Returns all browser contexts created with Target.createBrowserContext method.

Target.createTarget: { paramsType: [Protocol.Target.CreateTargetRequest]; returnType: Protocol.Target.CreateTargetResponse; }

Creates a new page.

Target.detachFromTarget: { paramsType: [Protocol.Target.DetachFromTargetRequest]; returnType: void; }

Detaches session with given id.

Target.disposeBrowserContext: { paramsType: [Protocol.Target.DisposeBrowserContextRequest]; returnType: void; }

Deletes a BrowserContext. All the belonging pages will be closed without calling their beforeunload hooks.

Target.getTargetInfo: { paramsType: [Protocol.Target.GetTargetInfoRequest]; returnType: Protocol.Target.GetTargetInfoResponse; }

Returns information about a target.

Target.getTargets: { paramsType: []; returnType: Protocol.Target.GetTargetsResponse; }

Retrieves a list of available targets.

Target.sendMessageToTarget: { paramsType: [Protocol.Target.SendMessageToTargetRequest]; returnType: void; }

Sends protocol message over session with given id. Consider using flat mode instead; see commands attachToTarget, setAutoAttach, and crbug.com/991325.

Target.setAutoAttach: { paramsType: [Protocol.Target.SetAutoAttachRequest]; returnType: void; }

Controls whether to automatically attach to new targets which are considered to be related to this one. When turned on, attaches to all existing related targets as well. When turned off, automatically detaches from all currently attached targets. This also clears all targets added by autoAttachRelated from the list of targets to watch for creation of related targets.

Target.autoAttachRelated: { paramsType: [Protocol.Target.AutoAttachRelatedRequest]; returnType: void; }

Adds the specified target to the list of targets that will be monitored for any related target creation (such as child frames, child workers and new versions of service worker) and reported through attachedToTarget. The specified target is also auto-attached. This cancels the effect of any previous setAutoAttach and is also cancelled by subsequent setAutoAttach. Only available at the Browser target.

Target.setDiscoverTargets: { paramsType: [Protocol.Target.SetDiscoverTargetsRequest]; returnType: void; }

Controls whether to discover available targets and notify via targetCreated/targetInfoChanged/targetDestroyed events.

Target.setRemoteLocations: { paramsType: [Protocol.Target.SetRemoteLocationsRequest]; returnType: void; }

Enables target discovery for the specified locations, when setDiscoverTargets was set to true.

Tethering.bind: { paramsType: [Protocol.Tethering.BindRequest]; returnType: void; }

Request browser port binding.

Tethering.unbind: { paramsType: [Protocol.Tethering.UnbindRequest]; returnType: void; }

Request browser port unbinding.

Tracing.end: { paramsType: []; returnType: void; }

Stop trace events collection.

Tracing.getCategories: { paramsType: []; returnType: Protocol.Tracing.GetCategoriesResponse; }

Gets supported tracing categories.

Tracing.recordClockSyncMarker: { paramsType: [Protocol.Tracing.RecordClockSyncMarkerRequest]; returnType: void; }

Record a clock sync marker in the trace.

Tracing.requestMemoryDump: { paramsType: [Protocol.Tracing.RequestMemoryDumpRequest]; returnType: Protocol.Tracing.RequestMemoryDumpResponse; }

Request a global memory dump.

Tracing.start: { paramsType: [Protocol.Tracing.StartRequest]; returnType: void; }

Start trace events collection.

Fetch.disable: { paramsType: []; returnType: void; }

Disables the fetch domain.

Fetch.enable: { paramsType: [Protocol.Fetch.EnableRequest]; returnType: void; }

Enables issuing of requestPaused events. A request will be paused until client calls one of failRequest, fulfillRequest or continueRequest/continueWithAuth.

Fetch.failRequest: { paramsType: [Protocol.Fetch.FailRequestRequest]; returnType: void; }

Causes the request to fail with specified reason.

Fetch.fulfillRequest: { paramsType: [Protocol.Fetch.FulfillRequestRequest]; returnType: void; }

Provides response to the request.

Fetch.continueRequest: { paramsType: [Protocol.Fetch.ContinueRequestRequest]; returnType: void; }

Continues the request, optionally modifying some of its parameters.

Fetch.continueWithAuth: { paramsType: [Protocol.Fetch.ContinueWithAuthRequest]; returnType: void; }

Continues a request supplying authChallengeResponse following authRequired event.

Fetch.continueResponse: { paramsType: [Protocol.Fetch.ContinueResponseRequest]; returnType: void; }

Continues loading of the paused response, optionally modifying the response headers. If either responseCode or headers are modified, all of them must be present.

Fetch.getResponseBody: { paramsType: [Protocol.Fetch.GetResponseBodyRequest]; returnType: Protocol.Fetch.GetResponseBodyResponse; }

Causes the body of the response to be received from the server and returned as a single string. May only be issued for a request that is paused in the Response stage and is mutually exclusive with takeResponseBodyForInterceptionAsStream. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior.

Fetch.takeResponseBodyAsStream: { paramsType: [Protocol.Fetch.TakeResponseBodyAsStreamRequest]; returnType: Protocol.Fetch.TakeResponseBodyAsStreamResponse; }

Returns a handle to the stream representing the response body. The request must be paused in the HeadersReceived stage. Note that after this command the request can't be continued as is -- client either needs to cancel it or to provide the response body. The stream only supports sequential read, IO.read will fail if the position is specified. This method is mutually exclusive with getResponseBody. Calling other methods that affect the request or disabling fetch domain before body is received results in an undefined behavior.

WebAudio.enable: { paramsType: []; returnType: void; }

Enables the WebAudio domain and starts sending context lifetime events.

WebAudio.disable: { paramsType: []; returnType: void; }

Disables the WebAudio domain.

WebAudio.getRealtimeData: { paramsType: [Protocol.WebAudio.GetRealtimeDataRequest]; returnType: Protocol.WebAudio.GetRealtimeDataResponse; }

Fetch the realtime data from the registered contexts.

WebAuthn.enable: { paramsType: [Protocol.WebAuthn.EnableRequest]; returnType: void; }

Enable the WebAuthn domain and start intercepting credential storage and retrieval with a virtual authenticator.

WebAuthn.disable: { paramsType: []; returnType: void; }

Disable the WebAuthn domain.

WebAuthn.addVirtualAuthenticator: { paramsType: [Protocol.WebAuthn.AddVirtualAuthenticatorRequest]; returnType: Protocol.WebAuthn.AddVirtualAuthenticatorResponse; }

Creates and adds a virtual authenticator.

WebAuthn.removeVirtualAuthenticator: { paramsType: [Protocol.WebAuthn.RemoveVirtualAuthenticatorRequest]; returnType: void; }

Removes the given authenticator.

WebAuthn.addCredential: { paramsType: [Protocol.WebAuthn.AddCredentialRequest]; returnType: void; }

Adds the credential to the specified authenticator.

WebAuthn.getCredential: { paramsType: [Protocol.WebAuthn.GetCredentialRequest]; returnType: Protocol.WebAuthn.GetCredentialResponse; }

Returns a single credential stored in the given virtual authenticator that matches the credential ID.

WebAuthn.getCredentials: { paramsType: [Protocol.WebAuthn.GetCredentialsRequest]; returnType: Protocol.WebAuthn.GetCredentialsResponse; }

Returns all the credentials stored in the given virtual authenticator.

WebAuthn.removeCredential: { paramsType: [Protocol.WebAuthn.RemoveCredentialRequest]; returnType: void; }

Removes a credential from the authenticator.

WebAuthn.clearCredentials: { paramsType: [Protocol.WebAuthn.ClearCredentialsRequest]; returnType: void; }

Clears all the credentials from the specified device.

WebAuthn.setUserVerified: { paramsType: [Protocol.WebAuthn.SetUserVerifiedRequest]; returnType: void; }

Sets whether User Verification succeeds or fails for an authenticator. The default is true.

WebAuthn.setAutomaticPresenceSimulation: { paramsType: [Protocol.WebAuthn.SetAutomaticPresenceSimulationRequest]; returnType: void; }

Sets whether tests of user presence will succeed immediately (if true) or fail to resolve (if false) for an authenticator. The default is true.

Media.enable: { paramsType: []; returnType: void; }

Enables the Media domain

Media.disable: { paramsType: []; returnType: void; }

Disables the Media domain.