WebDriver

WebDriver is a remote control interface that enables introspection and control of user agents. It provides a platform- and language-neutral wire protocol as a way for out-of-process programs to remotely instruct the behavior of web browsers.

Provided is a set of interfaces to discover and manipulate DOM elements in web documents and to control the behavior of a user agent. It is primarily intended to allow web authors to write tests that automate a user agent from a separate controlling process, but may also be used in such a way as to allow in-browser scripts to control a — possibly separate — browser.

Use GitHub w3c/webdriver for comments/issues.

Conformance

All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative. Everything else in this specification is normative.

The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this document are to be interpreted as described in [[!RFC2119]]. The key word “OPTIONALLY” in the normative parts of this document is to be interpreted with the same normative meaning as “MAY” and “OPTIONAL”.

Conformance requirements phrased as algorithms or specific steps may be implemented in any manner, so long as the end result is equivalent.

Dependencies

This specification relies on several other underlying specifications.

Web App Security

The following terms are defined in the Content Security Policy Level 3 specification: [[!CSP3]]

DOM

The following terms are defined in the Document Object Model specification: [[!DOM]]

The following attributes are defined in the Document Object Model specification: [[!DOM]]

textContent attribute

The following attributes are defined in the DOM Parsing and Serialisation specification: [[!DOM-PARSING]]

The following attributes are defined in the UI Events specification: [[!UI-EVENTS]]

The following attributes are defined in the UI Events Code specification: [[!UIEVENTS-CODE]]

Keyboard event code tables

The following attributes are defined in the UI Events Code specification: [[!UIEVENTS-KEY]]

Keyboard modifier keys

DOM Parsing

The following terms are defined in the DOM Parsing and Serialization Specification: [[!DOMPARSING]]

Fragment serializing algorithm

ECMAScript

The following terms are defined in the ECMAScript Language Specification: [[!ECMA-262]]

This specification also presumes that you are able to call some of the internal methods from the ECMAScript Language Specification:

The ECMAScript Language Specification also defines the following types, values, and operations that are used throughout this specification:

Fetch

The following terms are defined in the WHATWG Fetch specification: [[!FETCH]]

Fullscreen

The following terms are defined in the WHATWG Fullscreen specification: [[!FULLSCREEN]]

HTML

The following terms are defined in the HTML specification: [[!HTML]]

The HTML specification also defines a number of elements which this specification has special-cased behavior for:

The HTML specification also defines states of the input element:

The HTML specification also defines a range of different attributes:

The HTML Editing APIs specification defines the following terms: [[!EDITING]]

The following events are also defined in the HTML specification:

The “data” URL scheme specification defines the following terms: [[!RFC2397]]

data: URL

HTTP and related specifications

To be HTTP compliant, it is supposed that the implementation supports the relevant subsets of [[!RFC7230]], [[!RFC7231]], [[!RFC7232]], [[!RFC7234]], and [[!RFC7235]].

The following terms are defined in the Cookie specification: [[!RFC6265]]

The following terms are defined in the Hypertext Transfer Protocol (HTTP) Status Code Registry:

Status code registry

The following terms are defined in the Netscape Navigator Proxy Auto-Config File Format:

Proxy autoconfiguration

The specification uses URI Templates. [[!URI-TEMPLATE]]

Infra

The following terms are defined in the Infra standard: [[!INFRA]]

Interaction

The following terms are defined in the Page Visibility Specification [[!PAGE-VISIBILITY]]

Visibility state hidden
Visibility state being the visibilityState attribute on Document
Visibility state visible

Selenium

The following functions are defined within the Selenium project, at revision 1721e627e3b5ab90a06e82df1b088a33a8d11c20.

Styling

The following terms are defined in the CSS Values and Units Module Level 3 specification: [[!CSS3-VALUES]]

CSS pixels

The following properties are defined in the CSS Basic Box Model Level 3 specification: [[!CSS3-BOX]]

The visibility property

The following terms are defined in the CSS Device Adaptation Module Level 1 specification: [[!CSS-DEVICE-ADAPT]]

Initial viewport, sometimes here referred to as the viewport.

The following properties are defined in the CSS Display Module Level 3 specification: [[!CSS3-DISPLAY]]

The display property

The following terms are defined in the Geometry Interfaces Module Level 1 specification: [[!GEOMETRY-1]]

The following terms are defined in the CSS Cascading and Inheritance Level 4 specification: [[!CSS-CASCADE-4]]

Computed value

The following terms are defined in the CSS Object Model: [[!CSSOM]]:

Resolved value

The following functions are defined in the CSSOM View Module: [[!CSSOM-VIEW]]:

getBoundingClientRect
Element from point as elementFromPoint()
Elements from point as elementsFromPoint()
getClientRects
innerHeight
innerWidth
moveTo(x, y)
offsetLeft
offsetParent
offsetTop
outerHeight
outerWidth
screenX
screenY
scrollX
scrollY
scrollIntoView
ScrollIntoViewOptions
Logical scroll position "block"
Logical scroll position "inline"

SOCKS Proxy and related specification:

To be SOCKS Proxy and SOCKS authentication compliant, it is supposed that the implementation supports the relevant subsets of [[!RFC1928]] and [[!RFC1929]].

Unicode

The following terms are defined in the standard: [[!Unicode]]

Unicode Standard Annex #29

The following terms are defined in the standard: [[!UAX29]]

Grapheme cluster boundaries

Unicode Standard Annex #44

The following terms are defined in the standard: [[!UAX44]]

Unicode character property

URLs

The following terms are defined in the WHATWG URL standard: [[!URL]]

Web IDL

The IDL fragments in this specification must be interpreted as required for conforming IDL fragments, as described in the Web IDL specification. [[!WEBIDL]]

Promises Guide

The following terms are defined in the Promises Guide. [[!PROMISES-GUIDE]]

XML Namespaces

The following terms are defined in the Namespaces in XML [[!XML-NAMES]]

qualified element name

XPATH

The following terms are defined in the Document Object Model XPath standard [[!XPATH]]

Design Notes

This section is non-normative

The WebDriver standard attempts to follow a number of design goals:

Compatibility

This specification is derived from the popular Selenium WebDriver browser automation framework. Selenium is a long-lived project, and due to its age and breadth of use it has a wide range of expected functionality. This specification uses these expectations to inform its design. Where improvements or clarifications have been made, they have been made with care to allow existing users of Selenium WebDriver to avoid unexpected breakages.

Simplicity

The largest intended group of users of this specification are software developers and testers writing automated tests and other tooling, such as monitoring or load testing, that relies on automating a browser. As such, care has been taken to provide commands that simplify common tasks such as typing into and clicking elements.

Extensions

WebDriver provides a mechanism for others to define extensions to the protocol for the purposes of automating functionality that cannot be implemented entirely in ECMAScript. This allows other web standards to support the automation of new platform features. It also allows vendors to expose functionality that is specific to their browser.

Terminology

In equations, all numbers are integers, addition is represented by “+”, subtraction is represented by “−”, and bitwise OR by “|”. The characters “(” and “)” are used to provide logical grouping in these contexts.

The shorthand min(value, value[, value]) returns the smallest item of two or more values. Conversely, the shorthand max(value, value[, value]) returns the largest item of two or more values.

A Universally Unique IDentifier (UUID) is a 128 bits long URN that requires no central registration process. [[!RFC4122]]. Generating a UUID means Creating a UUID From Truly Random or Pseudo-Random Numbers [[!RFC4122]], and converting it to the string representation [[!RFC4122]].

The Unix Epoch is a value that approximates the number of seconds that have elapsed since the Epoch, as described by The Open Group Base Specifications Issue 7 section 4.15 (IEEE Std 1003.1).

An integer is a Number that is unchanged under the ToInteger operation.

The initial value of an ECMAScript property is the value defined by the platform for that property, i.e. the value it would have in the absence of any shadowing by content script.

The browser chrome is a non-normative term to refer to the representation through which the user interacts with the user agent itself, as distinct from the accessed web content. Examples of browser chrome elements include, but are not limited to, toolbars (such as the bookmark toolbar), menus (such as the file or context menu), buttons (such as the back and forward buttons), door hangers (such as security and certificate indicators), and decorations (such as operating system widget borders).

Interface

The webdriver-active flag is set to true when the user agent is under remote control. It is initially false.

Navigator includes NavigatorAutomationInformation;

Note that the NavigatorAutomationInformation interface should not be exposed on WorkerNavigator.

interface mixin NavigatorAutomationInformation {
	readonly attribute boolean webdriver;
};

webdriver: Returns true if webdriver-active flag is set, false otherwise.

Nodes

The WebDriver protocol consists of communication between:

Local end: The local end represents the client side of the protocol, which is usually in the form of language-specific libraries providing an API on top of the WebDriver protocol. This specification does not place any restrictions on the details of those libraries above the level of the wire protocol.
Remote end: The remote end hosts the server side of the protocol. Defining the behavior of a remote end in response to the WebDriver protocol forms the largest part of this specification.

For remote ends the standard defines two broad conformance classes, known as node types:

Intermediary node: Intermediary nodes are those that act as proxies, implementing both the local end and remote end of the protocol. However they are not expected to implement remote end steps directly. All nodes between a specific intermediary node and a local end are said to be downstream of that node. Conversely, any nodes between a specific intermediary node and an endpoint node are said to be upstream.
Endpoint node: An endpoint node is the final remote end in a chain of nodes that is not an intermediary node. The endpoint node is implemented by a user agent or a similar program.

All remote end node types must be black-box indistinguishable from a remote end, from the point of view of local end, and so are bound by the requirements on a remote end in terms of the wire protocol.

A remote end’s readiness state is the value corresponding to the first matching statement:

the maximum active sessions is equal to the length of the list of active sessions
the node is an intermediary node and is known to be in a state in which attempting to create a new session would fail: False
Otherwise: True

If the intermediary node is a multiplexer that manages multiple endpoint nodes, this might indicate its ability to purvey more sessions, for example if it has hit its maximum capacity.

Protocol

WebDriver remote ends must provide an HTTP compliant wire protocol where the endpoints map to different commands.

As this standard only defines the remote end protocol, it puts no demands to how local ends should be implemented. Local ends are only expected to be compatible to the extent that they can speak the remote end’s protocol; no requirements are made upon their exposed user-facing API.

Algorithms

Various parts of this specification are written in terms of step-by-step algorithms. The details of these algorithms do not have any normative significance; implementations are free to adopt any implementation strategy that produces equivalent output to the specification. In particular, algorithms in this document are optimised for readability rather than performance.

Where algorithms that return values are fallible, they are written in terms of returning either success or error. A success value has an associated data field which encapsulates the value returned, whereas an error response has an associated error code.

When calling a fallible algorithm, the construct “Let result be the result of trying to call algorithm” is equivalent to

Let temp be the result of calling algorithm.
If temp is an error return temp, otherwise let result be temp’s data field.

The result of getting a property with argument name is defined as being the same as the result of calling Object.[[\GetOwnProperty]](name).

Setting a property with arguments name and value is defined as being the same as calling Object.[[\Put]](name, value).

The result of JSON serialization with object of type JSON Object is defined as the result of calling JSON.[[\Stringify]](object).

The result of JSON deserialization with text is defined as the result of calling JSON.[[\Parse]](text).

Commands

The WebDriver protocol is organised into commands. Each HTTP request with a method and template defined in this specification represents a single command, and therefore each command produces a single HTTP response. In response to a command, a remote end will run a series of actions against the browser.

Each command defined in this specification has an associated list of remote end steps. This provides the sequence of actions that a remote end takes when it receives a particular command.

Processing Model

The remote end is an HTTP server reading requests from the client and writing responses, typically over a TCP socket. For the purposes of this specification we model the data transmission between a particular local end and remote end with a connection to which the remote end may write bytes and read bytes. However the exact details of how this connection works and how it is established are out of scope.

After such a connection has been established, a remote end MUST run the following steps:

Read bytes from the connection until a complete HTTP request can be constructed from the data. Let request be a request constructed from the received data, according to the requirements of [[!RFC7230]]. If it is not possible to construct a complete HTTP request, the remote end must either close the connection, return an HTTP response with status code 500, or return an error with error code unknown error.
Let request match be the result of the algorithm to match a request with request’s method and URL as arguments.
If request match is of type error, send an error with request match’s error code and jump to step 1.
Otherwise, let command and command parameters be request match’s data. Let url variables be a url variables dictionary mapping the command parameters to their corresponding values.
If session id is among the variables defined by command parameters:
This condition is intended to exclude the New Session and Status commands and any extension commands which do not operate on a particular session.
1. Let session id be the corresponding variable from command parameters.
2. Let the current session be the session with ID session id in the list of active sessions, or null if there is no such matching session.
3. If the current session is null send an error with error code invalid session id, then jump to step 1 in this overall algorithm.
4. If the current session is not null:
  1. Enqueue request in the current session's request queue.
  2. Wait until the first element in the current session's request queue is request:
  3. Dequeue request from the current session's request queue.
  4. If the list of active sessions no longer contains the current session, set the current session to null.
If request’s method is POST:
1. Let parse result be the result of parsing as JSON with request’s body as the argument. If this process throws an exception, return an error with error code invalid argument and jump back to step 1 in this overall algorithm.
2. If parse result is not an Object, send an error with error code invalid argument and jump back to step 1 in this overall algorithm.
  Otherwise, let parameters be parse result.
Otherwise, let parameters be null.
Wait for navigation to complete. If this returns an error return its value and jump to step 1 in this overall algorithm, otherwise continue.
Let response result be the return value obtained by running the remote end steps for command with an argument named url variables whose value is url variables and an additional argument named parameters whose value is parameters.
If response result is an error, send an error with error code equal to response result’s error code and jump back to step 1 in this overall algorithm.
Otherwise, if response result is a success, let response data be response result’s data.
Send a response with status 200 and response data.
Jump to step 1.

When required to send an error, with error code and an optional error data dictionary, a remote end must run the following steps:

Let http status and name be the error response data for error code.
Let message be an implementation-defined string containing a human-readable description of the reason for the error.
Let stacktrace be an implementation-defined string containing a stack trace report of the active stack frames at the time when the error occurred.
Let body be a new JSON Object initialised with the following properties:

"error"
name
"message"
message
"stacktrace"
stacktrace
If the error data dictionary contains any entries, set the "data" field on body to a new JSON Object populated with the dictionary.
Send a response with status and body as arguments.

When required to send a response, with arguments status and data, a remote end must run the following steps:

Let response be a new response.
Set response’s HTTP status to status, and status message to the string corresponding to the description of status in the status code registry.
Set the response’s header with name and value with the following values:

Content-Type
"application/json; charset=utf-8"
Cache-Control
"no-cache"
Let response’s body be a JSON Object with a key "value" set to the JSON serialization of data.
Let response bytes be the byte sequence resulting from serializing response according to the rules in [[!RFC7230]].
Write response bytes to the connection.

A url variable dictionary is defined as the mapping of a command's URI template variable names to their corresponding values.

Routing Requests

Request routing is the process of going from a HTTP request to the series of steps needed to implement the command represented by that request.

A remote end has an associated URL prefix, which is used as a prefix on all WebDriver-defined URLs on that remote end. This must either be undefined or a path-absolute URL.

In order to match a request given a method and URL, the following steps must be taken:

Let endpoints be a list containing each row in the table of endpoints.
Remove each entry from endpoints for which the concatenation of the URL prefix and the entry’s URI template does not match URL’s path.
If there are no entries in endpoints, return error with error code unknown command.
Remove each entry in endpoints for which the method column is not an exact case-sensitive match for method.
If there are no entries in endpoints, return error with error code unknown method.
There is now exactly one entry in endpoints; let entry be this entry.
Let parameters be the result of extracting the variables from URL using entry’s URI template.
Let command be entry’s command.
Return success with data command and parameters.

List of Endpoints

The following table of endpoints lists the method and URI template for each endpoint node command. Extension commands are implicitly appended to this table.

Method	URI Template	Command
POST	/session	New Session
DELETE	/session/{`session id`}	Delete Session
GET	/status	Status
GET	/session/{`session id`}/timeouts	Get Timeouts
POST	/session/{`session id`}/timeouts	Set Timeouts
POST	/session/{`session id`}/url	Navigate To
GET	/session/{`session id`}/url	Get Current URL
POST	/session/{`session id`}/back	Back
POST	/session/{`session id`}/forward	Forward
POST	/session/{`session id`}/refresh	Refresh
GET	/session/{`session id`}/title	Get Title
GET	/session/{`session id`}/window	Get Window Handle
DELETE	/session/{`session id`}/window	Close Window
POST	/session/{`session id`}/window	Switch To Window
GET	/session/{`session id`}/window/handles	Get Window Handles
POST	/session/{`session id`}/frame	Switch To Frame
POST	/session/{`session id`}/frame/parent	Switch To Parent Frame
GET	/session/{`session id`}/window/rect	Get Window Rect
POST	/session/{`session id`}/window/rect	Set Window Rect
POST	/session/{`session id`}/window/maximize	Maximize Window
POST	/session/{`session id`}/window/minimize	Minimize Window
POST	/session/{`session id`}/window/fullscreen	Fullscreen Window
GET	/session/{`session id`}/element/active	Get Active Element
POST	/session/{`session id`}/element	Find Element
POST	/session/{`session id`}/elements	Find Elements
POST	/session/{`session id`}/element/{element id}/element	Find Element From Element
POST	/session/{`session id`}/element/{element id}/elements	Find Elements From Element
GET	/session/{`session id`}/element/{`element id`}/selected	Is Element Selected
GET	/session/{`session id`}/element/{`element id`}/attribute/{`name`}	Get Element Attribute
GET	/session/{`session id`}/element/{`element id`}/property/{`name`}	Get Element Property
GET	/session/{`session id`}/element/{`element id`}/css/{`property name`}	Get Element CSS Value
GET	/session/{`session id`}/element/{`element id`}/text	Get Element Text
GET	/session/{`session id`}/element/{`element id`}/name	Get Element Tag Name
GET	/session/{`session id`}/element/{`element id`}/rect	Get Element Rect
GET	/session/{`session id`}/element/{`element id`}/enabled	Is Element Enabled
POST	/session/{`session id`}/element/{`element id`}/click	Element Click
POST	/session/{`session id`}/element/{`element id`}/clear	Element Clear
POST	/session/{`session id`}/element/{`element id`}/value	Element Send Keys
GET	/session/{`session id`}/source	Get Page Source
POST	/session/{`session id`}/execute/sync	Execute Script
POST	/session/{`session id`}/execute/async	Execute Async Script
GET	/session/{`session id`}/cookie	Get All Cookies
GET	/session/{`session id`}/cookie/{`name`}	Get Named Cookie
POST	/session/{`session id`}/cookie	Add Cookie
DELETE	/session/{`session id`}/cookie/{`name`}	Delete Cookie
DELETE	/session/{`session id`}/cookie	Delete All Cookies
POST	/session/{`session id`}/actions	Perform Actions
DELETE	/session/{`session id`}/actions	Release Actions
POST	/session/{`session id`}/alert/dismiss	Dismiss Alert
POST	/session/{`session id`}/alert/accept	Accept Alert
GET	/session/{`session id`}/alert/text	Get Alert Text
POST	/session/{`session id`}/alert/text	Send Alert Text
GET	/session/{`session id`}/screenshot	Take Screenshot
GET	/session/{`session id`}/element/{`element id`}/screenshot	Take Element Screenshot

Handling Errors

Errors are represented in the WebDriver protocol by an HTTP response with an HTTP status in the 4xx or 5xx range, and a JSON body containing details of the error. The body is a JSON Object and has a field named "value" whose value is an object bearing three, and sometimes four, fields:

"error", containing a string indicating the error code.
"message", containing an implementation-defined string with a human readable description of the kind of error that occurred.
"stacktrace", containing an implementation-defined string with a stack trace report of the active stack frames at the time when the error occurred.
Optionally "data", which is a JSON Object with additional error data helpful in diagnosing the error.

A GET request to /session/1234/url, where 1234 is not the session id of a current session would return an HTTP response with the status 404 and a body of the form:

{
	"value": {
		"error": "invalid session id",
		"message": "No active session with ID 1234",
		"stacktrace": ""
	}
}

Certain commands may also annotate errors with additional error data. Notably, this is the case for commands which invoke the user prompt handler, where the user prompt message may be included in a "text" field:

{
	"value": {
		"error": "unexpected alert open",
		"message": "",
		"stacktrace": "",
		"data": {
			"text": "Message from window.alert"
		}
	}
}

The following table lists each error code, its associated HTTP status, JSON error code, and a non-normative description of the error. The error response data for a particular error code is the values of the HTTP Status and JSON Error Code columns for the row corresponding to that error code.

Error Code	HTTP Status	JSON Error Code	Description
element click intercepted	400	`element click intercepted`	The Element Click command could not be completed because the element receiving the events is obscuring the element that was requested clicked.
element not interactable	400	`element not interactable`	A command could not be completed because the element is not pointer- or keyboard interactable.
insecure certificate	400	`insecure certificate`	Navigation caused the user agent to hit a certificate warning, which is usually the result of an expired or invalid TLS certificate.
invalid argument	400	`invalid argument`	The arguments passed to a command are either invalid or malformed.
invalid cookie domain	400	`invalid cookie domain`	An illegal attempt was made to set a cookie under a different domain than the current page.
invalid element state	400	`invalid element state`	A command could not be completed because the element is in an invalid state, e.g. attempting to clear an element that isn't both editable and resettable.
invalid selector	400	`invalid selector`	Argument was an invalid selector.
invalid session id	404	`invalid session id`	Occurs if the given session id is not in the list of active sessions, meaning the session either does not exist or that it’s not active.
javascript error	500	`javascript error`	An error occurred while executing JavaScript supplied by the user.
move target out of bounds	500	`move target out of bounds`	The target for mouse interaction is not in the browser’s viewport and cannot be brought into that viewport.
no such alert	404	`no such alert`	An attempt was made to operate on a modal dialog when one was not open.
no such cookie	404	`no such cookie`	No cookie matching the given path name was found amongst the associated cookies of the current browsing context’s active document.
no such element	404	`no such element`	An element could not be located on the page using the given search parameters.
no such frame	404	`no such frame`	A command to switch to a frame could not be satisfied because the frame could not be found.
no such window	404	`no such window`	A command to switch to a window could not be satisfied because the window could not be found.
script timeout	500	`script timeout`	A script did not complete before its timeout expired.
session not created	500	`session not created`	A new session could not be created.
stale element reference	404	`stale element reference`	A command failed because the referenced element is no longer attached to the DOM.
timeout	500	`timeout`	An operation did not complete before its timeout expired.
unable to set cookie	500	`unable to set cookie`	A command to set a cookie’s value could not be satisfied.
unable to capture screen	500	`unable to capture screen`	A screen capture was made impossible.
unexpected alert open	500	`unexpected alert open`	A modal dialog was open, blocking this operation.
unknown command	404	`unknown command`	A command could not be executed because the remote end is not aware of it.
unknown error	500	`unknown error`	An unknown error occurred in the remote end while processing the command.
unknown method	405	`unknown method`	The requested command matched a known URL but did not match an method for that URL.
unsupported operation	500	`unsupported operation`	Indicates that a command that should have executed properly cannot be supported for some reason.

An error data dictionary is a mapping of string keys to JSON serializable values that can optionally be included with error objects.

Protocol Extensions

Using the terminology defined in this section, others may define additional commands that seamlessly integrate with the standard protocol. This allows vendors to expose functionality that is specific to their user agent, and it also allows other web standards to define commands for automating new platform features.

Commands defined in this way are called extension commands and behave no differently than other commands; each has a dedicated HTTP endpoint and a set of remote end steps.

Each extension command has an associated extension command URI Template that is a URI Template string, and which should bear some resemblance to what the command performs. This value, along with the HTTP method and extension command, is added to the table of endpoints and thus follows the same rules for request routing as that of other built-in commands.

In order to avoid potential resource conflicts with other implementations, vendor-specific extension command URI Templates must begin with one or more path segments which uniquely identifies the vendor and UA. It is suggested that vendors use their vendor prefixes without additional characters as outlined in [[CSS21]], notably in section 4.1.2.2 on vendor keywords, as the name for this path element, and include a vendor-chosen UA identifier.

Remote ends may also introduce extension capabilities that are extra capabilities used to provide configuration or fulfill other vendor-specific needs. Extension capabilities’ key must contain a ":" (colon) character, denoting an implementation specific namespace. The value can be arbitrary JSON types.

As with extension commands, it is suggested that the key used to denote the extension capability namespace is based on the vendor keywords listed in [[!CSS21]] and precedes the first ":" character in the string.

Extension capabilities are typically used to provide UA or intermediary node specific configuration that is not handled by the table of standard capabilities.

An example new session request body might look like this:

{
  "capabilities": {
    "alwaysMatch": {
      // browser specific configuration
      "<prefix>:browserOptions": {
        "binary": "/usr/bin/browser-binary",
        "args": ["--start-page=http://example.com"],
      }
    }
  }
}

Capabilities

WebDriver capabilities are used to communicate the features supported by a given implementation. The local end may use capabilities to define which features it requires the remote end to satisfy when creating a new session. Likewise, the remote end uses capabilities to describe the full feature set for a session.

The following table of standard capabilities enumerates the capabilities each implementation MUST support. An implementation MAY define additional extension capabilities.

As an example, Mozilla could elect to hide new features behind capabilities with a "moz:" prefix:

{
	"browserName": "firefox",
	"browserVersion": "1234",
	"moz:experimental-webdriver": true
}

Capability	Key	Value Type	Description
Browser name	"`browserName`"	string	Identifies the user agent.
Browser version	"`browserVersion`"	string	Identifies the version of the user agent.
Platform name	"`platformName`"	string	Identifies the operating system of the endpoint node.
Accept insecure TLS certificates	"`acceptInsecureCerts`"	boolean	Indicates whether untrusted and self-signed TLS certificates are implicitly trusted on navigation for the duration of the session.
Page load strategy	"`pageLoadStrategy`"	string	Defines the current session’s page load strategy.
Proxy configuration	"`proxy`"	JSON Object	Defines the current session’s proxy configuration.
Window dimensioning/positioning	"`setWindowRect`"	boolean	Indicates whether the remote end supports all of the commands in Resizing and Positioning Windows.
Session timeouts configuration	"`timeouts`"	JSON Object	Describes the timeouts imposed on certain session operations.
Unhandled prompt behavior	"`unhandledPromptBehavior`"	string	Describes the current session’s user prompt handler. Defaults to the dismiss and notify state.

Proxy

The proxy configuration capability is a JSON Object nested within the primary capabilities. Implementations may define additional proxy configuration options, but they must not alter the semantics of those listed below.

Key	Value Type	Description	Valid values
`proxyType`	string	Indicates the type of proxy configuration.	"`pac`", "`direct`", "`autodetect`", "`system`", or "`manual`".
`proxyAutoconfigUrl`	string	Defines the URL for a proxy auto-config file if `proxyType` is equal to "`pac`".	Any URL.
`ftpProxy`	string	Defines the proxy host for FTP traffic when the `proxyType` is "`manual`".	A host and optional port for scheme "`ftp`".
`httpProxy`	string	Defines the proxy host for HTTP traffic when the `proxyType` is "`manual`".	A host and optional port for scheme "`http`".
`noProxy`	array	Lists the address for which the proxy should be bypassed when the `proxyType` is "`manual`".	A List containing any number of Strings.
`sslProxy`	string	Defines the proxy host for encrypted TLS traffic when the `proxyType` is "`manual`".	A host and optional port for scheme "`https`".
`socksProxy`	string	Defines the proxy host for a SOCKS proxy when the `proxyType` is "`manual`".	A host and optional port with an undefined scheme.
`socksVersion`	number	Defines the SOCKS proxy version when the `proxyType` is "`manual`".	Any integer between 0 and 255 inclusive.

A host and optional port for a scheme is defined as being a valid host, optionally followed by a colon and a valid port. The host may include credentials. If the port is omitted and scheme has a default port, this is the implied port. Otherwise, the port is left undefined.

A proxyType of "direct" indicates that the browser should not use a proxy at all.

A proxyType of "system" indicates that the browser should use the various proxies configured for the underlying Operating System.

A proxyType of "autodetect" indicates that the proxy to use should be detected in an implementation-specific way.

The remote end steps to deserialize as a proxy argument parameter are:

If parameter is not a JSON Object return an error with error code invalid argument.
Let proxy be a new, empty proxy configuration object.
For each enumerable own property in parameter run the following substeps:
1. Let key be the name of the property.
2. Let value be the result of getting a property named name from parameter.
3. If there is no matching key for key in the proxy configuration table return an error with error code invalid argument.
4. If value is not one of the valid values for that key, return an error with error code invalid argument.
5. Set a property key to value on proxy.
If proxy does not have an own property for "proxyType" return an error with error code invalid argument.
If the result of getting a property named proxyType from proxy equals "pac", and proxy does not have an own property for "proxyAutoconfigUrl" return an error with error code invalid argument.
If proxy has an own property for "socksProxy" and does not have an own property for "socksVersion" return an error with error code invalid argument.
Return success with data proxy.

A proxy configuration object is a JSON Object where each of its own properties matching keys in the proxy configuration meets the validity criteria for that key.

Processing Capabilities

To process capabilities with argument parameters, the endpoint node must take the following steps:

Let capabilities request be the result of getting the property "capabilities" from parameters.
1. If capabilities request is not a JSON object, return error with error code invalid argument.
Let required capabilities be the result of getting the property "alwaysMatch" from capabilities request.
1. If required capabilities is undefined, set the value to an empty JSON Object.
2. Let required capabilities be the result of trying to validate capabilities with argument required capabilities.
Let all first match capabilities be the result of getting the property "firstMatch" from capabilities request.
1. If all first match capabilities is undefined, set the value to a JSON List with a single entry of an empty JSON Object.
2. If all first match capabilities is not a JSON List with one or more entries, return error with error code invalid argument.
Let validated first match capabilities be an empty JSON List.
For each first match capabilities corresponding to an indexed property in all first match capabilities:
1. Let validated capabilities be the result of trying to validate capabilities with argument first match capabilities.
2. Append validated capabilities to validated first match capabilities.
Let merged capabilities be an empty List.
For each first match capabilities corresponding to an indexed property in validated first match capabilities:
1. Let merged be the result of trying to merge capabilities with required capabilities and first match capabilities as arguments.
2. Append merged to merged capabilities.
For each capabilities corresponding to an indexed property in merged capabilities:
1. Let matched capabilities be the result of trying to match capabilities with capabilities as an argument.
2. If matched capabilities is not null, return matched capabilities.
Return success with data null.

When required to validate capabilities with argument capability:

If capability is not a JSON Object return an error with error code invalid argument.
Let result be an empty JSON Object.
For each enumerable own property in capability, run the following substeps:
1. Let name be the name of the property.
2. Let value be the result of getting a property named name from capability.
3. Run the substeps of the first matching condition:
  
  value is null
  Let deserialized be set to null.
  name equals "acceptInsecureCerts"
  If value is not a boolean return an error with error code invalid argument. Otherwise, let deserialized be set to value
  name equals "browserName"
  name equals "browserVersion"
  name equals "platformName"
  If value is not a string return an error with error code invalid argument. Otherwise, let deserialized be set to value.
  name equals "pageLoadStrategy"
  Let deserialized be the result of trying to deserialize as a page load strategy with argument value.
  name equals "proxy"
  Let deserialized be the result of trying to deserialize as a proxy with argument value.
  name equals "timeouts"
  Let deserialized be the result of trying to deserialize as a timeout with argument value.
  name equals "unhandledPromptBehavior"
  Let deserialized be the result of trying to deserialize as an unhandled prompt behavior with argument value.
  name is the key of an extension capability
  Let deserialized be the result of trying to deserialize value in an implementation-specific way.
  The remote end is an endpoint node
  Return an error with error code invalid argument.
4. If deserialized is not null, set a property on result with name name and value deserialized.
Return success with data result.

When merging capabilities with JSON Object arguments primary and secondary, an endpoint node must take the following steps:

Let result be a new JSON Object.
For each enumerable own property in primary, run the following substeps:
1. Let name be the name of the property.
2. Let value be the result of getting a property named name from primary.
3. Set a property on result with name name and value value.
If secondary is undefined, return result.
For each enumerable own property in secondary, run the following substeps:
1. Let name be the name of the property.
2. Let value be the result of getting a property named name from secondary.
3. Let primary value be the result of getting the property name from primary.
4. If primary value is not undefined, return an error with error code invalid argument.
5. Set a property on result with name name and value value.
Return result.

When matching capabilities with JSON Object argument capabilities, an endpoint node must take the following steps:

Let matched capabilities be a JSON Object with the following entries:

"browserName"
Lowercase name of the user agent as a string.
"browserVersion"
The user agent version, as a string.
"platformName"
Lowercase name of the current platform as a string.
"acceptInsecureCerts"
Boolean initially set to false, indicating the session will not implicitly trust untrusted or self-signed TLS certificates on navigation.
"setWindowRect"
Boolean indicating whether the remote end supports all of the commands in Resizing and Positioning Windows.
Optionally add extension capabilities as entries to matched capabilities. The values of these may be elided, and there is no requirement that all extension capabilities be added.

This allows a remote end to add information that might be useful to a local end without unnecessarily bloating the response sent back to the user with (e.g.) an entire browser profile.
For example, an implementation could choose to indicate that a screenshot will be taken when returning an error by setting the capability se:screenshot-on-error to true.

For each name and value corresponding to capability's own properties:

Run the substeps of the first matching name:

"browserName"

If value is not a string equal to the "browserName" entry in matched capabilities, return success with data null.

There is a chance the remote end will need to start a browser process to correctly determine the browserName. Lightweight checks are preferred before this is done.

"browserVersion"

Compare value to the "browserVersion" entry in matched capabilities using an implementation-defined comparison algorithm. The comparison is to accept a value that places constraints on the version using the "<", "<=", ">", and ">=" operators.

If the two values do not match, return success with data null.

Version comparison is left as an implementation detail since each user agent will likely have conflicting methods of encoding the user agent version, and standardizing these schemes is beyond the scope of this standard.

There is a chance the remote end will need to start a browser process to correctly determine the browserVersion. Lightweight checks are preferred before this is done.

"platformName"

If value is not a string equal to the "platformName" entry in matched capabilities, return success with data null.

The following platform names are in common usage with well-understood semantics and, when matching capabilities, greatest interoperability can be achieved by honoring them as valid synonyms for well-known Operating Systems:

Key	System
"`linux`"	Any server or desktop system based upon the Linux kernel.
"`mac`"	Any version of Apple’s macOS.
"`windows`"	Any version of Microsoft Windows, including desktop and mobile versions.

This list is not exhaustive.

When returning capabilities from New Session, it is valid to return a more specific platformName, allowing users to correctly identify the Operating System the WebDriver implementation is running on.

"acceptInsecureCerts"

If value is true and the endpoint node does not support insecure TLS certificates, return success with data null.

If the endpoint node does not support insecure TLS certificates and this is the reason no match is ultimately made, it is useful to provide this information to the local end.

"proxy"

If the endpoint node does not allow the proxy it uses to be configured, or if the proxy configuration defined in value is not one that passes the endpoint node's implementation-specific validity checks, return success with data null.

A local end would only send this capability if it expected it to be honored and the configured proxy used. The intent is that if this is not possible a new session will not be established.

Otherwise

If name is the key of an extension capability,

let value be the result of trying implementation-specific steps to match on name with value. If the match is not successful, return success with data null.

Set a property on matched capabilities with name name and value value.

Return success with data matched capabilities.

Sessions

A session is equivalent to a single instantiation of a particular user agent, including all its child browsers. WebDriver gives each session a unique session ID that can be used to differentiate one session from another, allowing multiple user agents to be controlled from a single HTTP server, and allowing sessions to be routed via a multiplexer (known as an intermediary node).

A WebDriver session represents the connection between a local end and a specific remote end.

A session is started when a New Session is invoked. It is an error to send any commands before starting a session, or to continue to send commands after the session has been closed. Maintaining session continuity between commands to the remote end requires passing a session ID.

A session is torn down at some later point; either explicitly by invoking Delete Session, or implicitly when Close Window is called at the last remaining top-level browsing context.

An intermediary node will maintain an associated session for each active session. This is the session on the upstream neighbor that is created when the intermediary node executes the New Session command. Closing a session on an intermediary node will also close the session of the associated session.

All commands, except New Session and Status, have an associated current session, which is the session in which that command will run.

A remote end has an associated list of active sessions, which is a list of all sessions that are currently started. A remote end that is not an intermediary node has at most one active session at a given time.

A remote end has an associated maximum active sessions (an integer) that defines the number of active sessions that are supported. This may be “unlimited” for intermediary nodes, but must be exactly one for a remote end that is an endpoint node.

A session has an associated session ID (a string representation of a UUID) used to uniquely identify this session. Unless stated otherwise it is null.

A session has an associated current browsing context, which is the browsing context against which commands will run.

A session has an associated current top-level browsing context, which is the current browsing context if it itself is a top-level browsing context, and otherwise is the top-level browsing context of the current browsing context.

A session has an associated session script timeout that specifies a time to wait for scripts to run. If equal to null then session script timeout will be indefinite. Unless stated otherwise it is 30,000 milliseconds.

A session has an associated session page load timeout that specifies a time to wait for the page loading to complete. Unless stated otherwise it is 300,000 milliseconds.

A session has an associated session implicit wait timeout that specifies a time to wait in milliseconds for the element location strategy when retrieving elements and when waiting for an element to become interactable when performing element interaction . Unless stated otherwise it is zero milliseconds.

A session has an associated page loading strategy, which is one of the keywords from the table of page load strategies. Unless stated otherwise, it is normal.

A session has an associated secure TLS state that indicates whether untrusted or self-signed TLS certificates should be trusted for the duration of the WebDriver session. If it is unset, this indicates that certificate- or TLS errors that occur upon navigation should be suppressed. The state can be unset by providing an "acceptInsecureCerts" capability with the value true. Unless stated otherwise, it is set.

A session has an associated user prompt handler. Unless stated otherwise it is in the dismiss and notify state.

A session has an associated list of active input sources.

A session has an associated input state table.

A session has an associated input cancel list.

A session has an associated request queue which is a queue of requests that are currently awaiting processing.

When asked to close the session, a remote end must take the following steps:

Perform the following substeps based on the remote end's type:
Remote end is an endpoint node
1. Set the webdriver-active flag to false.
2. An endpoint node must close any top-level browsing contexts associated with the session, without prompting to unload.
Remote end is an intermediary node
1. Close the associated session. If this causes an error to occur, complete the remainder of this algorithm before returning the error.
Remove the current session from active sessions.
Perform any implementation-specific cleanup steps.
If an error has occurred in any of the steps above, return the error, otherwise return success with data null.

Closing a session might cause the associated browser process to be killed. It is assumed that any implementation-specific cleanup steps are performed after the response has been sent back to the client so that the connection is not prematurely closed.

New Session

HTTP Method	URI Template
POST	/session

The New Session command creates a new WebDriver session with the endpoint node. If the creation fails, a session not created error is returned.

If the remote end is an intermediary node, it MAY use the result of the capabilities processing algorithm to route the new session request to the appropriate endpoint node. An intermediary node MAY also define extension capabilities to assist in this process, however, these specific capabilities MUST NOT be forwarded to the endpoint node.

If the intermediary node requires additional information unrelated to user agent features, it is RECOMMENDED that this information be passed as top-level parameters, and not as part of the requested capabilities. An intermediary node MUST forward custom, top-level parameters (i.e. non-capabilities) to subsequent remote end nodes.

An intermediary node might require authentication on creating a new session. This authentication is an argument to the New Session command itself and not the user agent’s capabilities. Therefore, the authentication should be passed as a top-level parameter and not embedded in capabilities:

{
	"user": "alice",
	"password": "hunter2",
	"capabilities": {…}
}

However, because an intermediary node cannot forward extension capabilities specific to that implementation to an endpoint node, the following is also permitted by this specification:

{
    "capabilities": {
        "alwaysMatch": {
            "cloud:user": "alice",
            "cloud:password": "hunter2",
            "platformName": "linux"
        },
        "firstMatch": [
            {"browserName": "chrome"},
            {"browserName": "edge"}
        ]
    }
}

Once all capabilities are merged from this example, an endpoint node would receive New Session capabilities identical to:

[
    {"browserName": "chrome", "platformName": "linux"},
    {"browserName": "edge", "platformName": "linux"}
]

Keyword	Type	Description
"`script`"	session script timeout	Determines when to interrupt a script that is being evaluated.
"`pageLoad`"	session page load timeout	Provides the timeout limit used to interrupt navigation of the browsing context.
"`implicit`"	session implicit wait timeout	Gives the timeout of when to abort locating an element.

Keyword	Page load strategy state	Document readiness state
"`none`"	none
"`eager`"	eager	"`interactive`"
"`normal`"	normal	"`complete`"

State	Keyword	Default	Description
Maximized window state	"`maximized`"		The window is maximized.
Minimized window state	"`minimized`"		The window is iconified.
Normal window state	"`normal`"	✓	The window is shown normally.
Fullscreen window state	"`fullscreen`"		The window is in full screen mode.

State	Keyword
CSS selector	"`css selector`"
Link text selector	"`link text`"
Partial link text selector	"`partial link text`"
Tag name	"`tag name`"
XPath selector	"`xpath`"

Concept	RFC 6265 Field	JSON Key	Attribute Key	Optional	Description
Cookie name	`name`	"`name`"			The name of the cookie.
Cookie value	`value`	"`value`"			The cookie value.
Cookie path	`path`	"`path`"	"`Path`"	✓	The cookie path. Defaults to "`/`" if omitted when adding a cookie.
Cookie domain	`domain`	"`domain`"	"`Domain`"	✓	The domain the cookie is visible to. Defaults to the current browsing context’s active document’s URL domain if omitted when adding a cookie.
Cookie secure only	`secure-only-flag`	"`secure`"	"`Secure`"	✓	Whether the cookie is a secure cookie. Defaults to false if omitted when adding a cookie.
Cookie HTTP only	`http-only-flag`	"`httpOnly`"	"`HttpOnly`"	✓	Whether the cookie is an HTTP only cookie. Defaults to false if omitted when adding a cookie.
Cookie expiry time	`expiry-time`	"`expiry`"	"`Max-Age`"	✓	When the cookie expires, specified in seconds since Unix Epoch. Must not be set if omitted when adding a cookie.

Action	Non-normative Description
keyDown	Used to indicate that a particular key should be held down.
keyUp	Used to indicate that a depressed key should be released.

Action	Non-normative Description
pointerDown	Used to indicate that a pointer should be depressed in some way e.g. by holding a button down (for a mouse) or by coming into contact with the active surface (for a touch or pen device).
pointerUp	Used to indicate that a pointer should be released in some way e.g. by releasing a mouse button or moving a pen or touch device away from the active surface.
pointerMove	Used to indicate a location on the screen that a pointer should move to, either in its active (pressed) or inactive state.
pointerCancel	Used to cancel a pointer action.

`Action type`	Input state
"`none`"	null input state
"`key`"	key input state
"`pointer`"	pointer input state

`source type`	`subtype` property	Dispatch action algorithm
`"none"`	`"pause"`	Dispatch a pause action
`"key"`	`"pause"`	Dispatch a pause action
`"key"`	`"keyDown"`	Dispatch a keyDown action
`"key"`	`"keyUp"`	Dispatch a keyUp action
`"pointer"`	`"pause"`	Dispatch a pause action
`"pointer"`	`"pointerDown"`	Dispatch a pointerDown action
`"pointer"`	`"pointerUp"`	Dispatch a pointerUp action
`"pointer"`	`"pointerMove"`	Dispatch a pointerMove action
`"pointer"`	`"pointerCancel"`	Dispatch a pointerCancel action

`key`'s codepoint	Normalised key value
`\uE000`	`"Unidentified"`
`\uE001`	`"Cancel"`
`\uE002`	`"Help"`
`\uE003`	`"Backspace"`
`\uE004`	`"Tab"`
`\uE005`	`"Clear"`
`\uE006`	`"Return"`
`\uE007`	`"Enter"`
`\uE008`	`"Shift"`
`\uE009`	`"Control"`
`\uE00A`	`"Alt"`
`\uE00B`	`"Pause"`
`\uE00C`	`"Escape"`
`\uE00D`	`" "`
`\uE00E`	`"PageUp"`
`\uE00F`	`"PageDown"`
`\uE010`	`"End"`
`\uE011`	`"Home"`
`\uE012`	`"ArrowLeft"`
`\uE013`	`"ArrowUp"`
`\uE014`	`"ArrowRight"`
`\uE015`	`"ArrowDown"`
`\uE016`	`"Insert"`
`\uE017`	`"Delete"`
`\uE018`	`";"`
`\uE019`	`"="`
`\uE01A`	`"0"`
`\uE01B`	`"1"`
`\uE01C`	`"2"`
`\uE01D`	`"3"`
`\uE01E`	`"4"`
`\uE01F`	`"5"`
`\uE020`	`"6"`
`\uE021`	`"7"`
`\uE022`	`"8"`
`\uE023`	`"9"`
`\uE024`	`"*"`
`\uE025`	`"+"`
`\uE026`	`","`
`\uE027`	`"-"`
`\uE028`	`"."`
`\uE029`	`"/"`
`\uE031`	`"F1"`
`\uE032`	`"F2"`
`\uE033`	`"F3"`
`\uE034`	`"F4"`
`\uE035`	`"F5"`
`\uE036`	`"F6"`
`\uE037`	`"F7"`
`\uE038`	`"F8"`
`\uE039`	`"F9"`
`\uE03A`	`"F10"`
`\uE03B`	`"F11"`
`\uE03C`	`"F12"`
`\uE03D`	`"Meta"`
`\uE040`	`"ZenkakuHankaku"`
`\uE050`	`"Shift"`
`\uE051`	`"Control"`
`\uE052`	`"Alt"`
`\uE053`	`"Meta"`
`\uE054`	`"PageUp"`
`\uE055`	`"PageDown"`
`\uE056`	`"End"`
`\uE057`	`"Home"`
`\uE058`	`"ArrowLeft"`
`\uE059`	`"ArrowUp"`
`\uE05A`	`"ArrowRight"`
`\uE05B`	`"ArrowDown"`
`\uE05C`	`"Insert"`
`\uE05D`	`"Delete"`

Key	Alternate Key	code
"`"	`"~"`	`"Backquote"`
`"\"`	`"\|"`	`"Backslash"`
`"\uE003"`		`"Backspace"`
`"["`	`"{"`	`"BracketLeft"`
`"}"`	`"]"`	`"BracketRight"`
`","`	`"<"`	`"Comma"`
`"0"`	`")"`	`"Digit0"`
`"1"`	`"!"`	`"Digit1"`
`"2"`	`"@"`	`"Digit2"`
`"3"`	`"#"`	`"Digit3"`
`"4"`	`"$"`	`"Digit4"`
`"5"`	`"%"`	`"Digit5"`
`"6"`	`"^"`	`"Digit6"`
`"7"`	`"&"`	`"Digit7"`
`"8"`	`"*"`	`"Digit8"`
`"9"`	`"("`	`"Digit9"`
`"="`	`"+"`	`"Equal"`
`"<"`	`">"`	`"IntlBackslash"`
`"a"`	`"A"`	`"KeyA"`
`"b"`	`"B"`	`"KeyB"`
`"c"`	`"C"`	`"KeyC"`
`"d"`	`"D"`	`"KeyD"`
`"e"`	`"E"`	`"KeyE"`
`"f"`	`"F"`	`"KeyF"`
`"g"`	`"G"`	`"KeyG"`
`"h"`	`"H"`	`"KeyH"`
`"i"`	`"I"`	`"KeyI"`
`"j"`	`"J"`	`"KeyJ"`
`"k"`	`"K"`	`"KeyK"`
`"l"`	`"L"`	`"KeyL"`
`"m"`	`"M"`	`"KeyM"`
`"n"`	`"N"`	`"KeyN"`
`"o"`	`"O"`	`"KeyO"`
`"p"`	`"P"`	`"KeyP"`
`"q"`	`"Q"`	`"KeyQ"`
`"r"`	`"R"`	`"KeyR"`
`"s"`	`"S"`	`"KeyS"`
`"t"`	`"T"`	`"KeyT"`
`"u"`	`"U"`	`"KeyU"`
`"v"`	`"V"`	`"KeyV"`
`"w"`	`"W"`	`"KeyW"`
`"x"`	`"X"`	`"KeyX"`
`"y"`	`"Y"`	`"KeyY"`
`"z"`	`"Z"`	`"KeyZ"`
`"-"`	`"_"`	`"Minus"`
`"."`	`">"`	`"Period"`
`"'"`	`"""`	`"Quote"`
`";"`	`":"`	`"Semicolon"`
`"/"`	`"?"`	`"Slash"`
`"\uE00A"`		`"AltLeft"`
`"\uE052"`		`"AltRight"`
`"\uE009"`		`"ControlLeft"`
`"\uE051"`		`"ControlRight"`
`"\uE006"`		`"Enter"`
`"\uE03D"`		`"OSLeft"`
`"\uE053"`		`"OSRight"`
`"\uE008"`		`"ShiftLeft"`
`"\uE050"`		`"ShiftRight"`
`" "`	`"\uE00D"`	`"Space"`
`"\uE004"`		`"Tab"`
`"\uE017"`		`"Delete"`
`"\uE010"`		`"End"`
`"\uE002"`		`"Help"`
`"\uE011"`		`"Home"`
`"\uE016"`		`"Insert"`
`"\uE01E"`		`"PageDown"`
`"\uE01F"`		`"PageUp"`
`"\uE015"`		`"ArrowDown"`
`"\uE012"`		`"ArrowLeft"`
`"\uE014"`		`"ArrowRight"`
`"\uE013"`		`"ArrowUp"`
`"\uE00C"`		`"Escape"`
`"\uE031"`		`"F1"`
`"\uE032"`		`"F2"`
`"\uE033"`		`"F3"`
`"\uE034"`		`"F4"`
`"\uE035"`		`"F5"`
`"\uE036"`		`"F6"`
`"\uE037"`		`"F7"`
`"\uE038"`		`"F8"`
`"\uE039"`		`"F9"`
`"\uE03A"`		`"F10"`
`"\uE03B"`		`"F11"`
`"\uE03C"`		`"F12"`
`"\uE01A"`	`"\uE05C"`	`"Numpad0"`
`"\uE01B"`	`"\uE056"`	`"Numpad1"`
`"\uE01C"`	`"\uE05B"`	`"Numpad2"`
`"\uE01D"`	`"\uE055"`	`"Numpad3"`
`"\uE01E"`	`"\uE058"`	`"Numpad4"`
`"\uE01F"`		`"Numpad5"`
`"\uE020"`	`"\uE05A"`	`"Numpad6"`
`"\uE021"`	`"\uE057"`	`"Numpad7"`
`"\uE022"`	`"\uE059"`	`"Numpad8"`
`"\uE023"`	`"\uE054"`	`"Numpad9"`
`"\uE024"`		`"NumpadAdd"`
`"\uE026"`		`"NumpadComma"`
`"\uE028"`	`"\uE05D"`	`"NumpadDecimal"`
`"\uE029"`		`"NumpadDivide"`
`"\uE007"`		`"NumpadEnter"`
`"\uE024"`		`"NumpadMultiply"`
`"\uE026"`		`"NumpadSubtract"`

`key`'s codepoint	Description	Location
`\uE007`	Enter	`1`
`\uE008`	Left Shift	`1`
`\uE009`	Left Control	`1`
`\uE00A`	Left Alt	`1`
`\uE01A`	Numpad 0	`3`
`\uE01B`	Numpad 1	`3`
`\uE01C`	Numpad 2	`3`
`\uE01D`	Numpad 3	`3`
`\uE01E`	Numpad 4	`3`
`\uE01F`	Numpad 5	`3`
`\uE020`	Numpad 6	`3`
`\uE021`	Numpad 7	`3`
`\uE022`	Numpad 8	`3`
`\uE023`	Numpad 9	`3`
`\uE024`	Numpad *	`3`
`\uE025`	Numpad +	`3`
`\uE026`	Numpad ,	`3`
`\uE027`	Numpad -	`3`
`\uE028`	Numpad .	`3`
`\uE029`	Numpad /	`3`
`\uE03D`	Left Meta	`1`
`\uE050`	Right Shift	`2`
`\uE051`	Right Control	`2`
`\uE052`	Right Alt	`2`
`\uE053`	Right Meta	`2`
`\uE054`	Numpad PageUp	`3`
`\uE055`	Numpad PageDown	`3`
`\uE056`	Numpad End	`3`
`\uE057`	Numpad Home	`3`
`\uE058`	Numpad ArrowLeft	`3`
`\uE059`	Numpad ArrowUp	`3`
`\uE05A`	Numpad ArrowRight	`3`
`\uE05B`	Numpad ArrowDown	`3`
`\uE05C`	Numpad Insert	`3`
`\uE05D`	Numpad Delete	`3`

Attribute	Value
`key`	`key`
`code`	`code`
`location`	`location`
`altKey`	`device state`'s `alt` property
`shiftKey`	`device state`'s `shift` property
`ctrlKey`	`device state`'s `ctrl` property
`metaKey`	`device state`'s `meta` property
`repeat`	`repeat`
`isComposing`	`false`
`charCode`	`charCode`
`keyCode`	`keyCode`
`which`	`which`

Definition	Dialog	Interactions
Alert	window.`alert`	Accept Alert Dismiss Alert Get Alert Text
Confirm	window.`confirm`	Dismiss Alert Accept Alert Get Alert Text
Prompt	window.`prompt`	Dismiss Alert Accept Alert Get Alert Text Send Alert Text

Keyword	State	Description
"`dismiss`"	Dismiss state	All simple dialogs encountered should be dismissed.
"`accept`"	Accept state	All simple dialogs encountered should be accepted.
"`dismiss and notify`"	Dismiss and notify state	All simple dialogs encountered should be dismissed, and an error returned that the dialog was handled.
"`accept and notify`"	Accept and notify state	All simple dialogs encountered should be accepted, and an error returned that the dialog was handled.
"`ignore`"	Ignore state	All simple dialogs encountered should be left to the user to handle.

Conformance

Dependencies

Design Notes

Compatibility

Simplicity

Extensions

Terminology

Interface

Nodes

Protocol

Algorithms

Commands

Processing Model

Routing Requests

List of Endpoints

Handling Errors

Protocol Extensions

Capabilities

Proxy

Processing Capabilities

Sessions

New Session

Delete Session

Status

Get Timeouts

Set Timeouts

Navigation

Navigate To

Get Current URL

Back

Forward

Refresh

Get Title

Command Contexts

Get Window Handle

Close Window

Switch To Window

Get Window Handles

Switch To Frame

Switch To Parent Frame

Resizing and Positioning Windows

Get Window Rect

Set Window Rect

Maximize Window

Minimize Window

Fullscreen Window

Elements

Element Interactability

Element Retrieval

Locator Strategies

CSS Selectors

Link Text

Partial Link Text

Tag Name

XPath

Find Element

Find Elements

Find Element From Element

Find Elements From Element

Get Active Element

Element State

Is Element Selected

Get Element Attribute

Get Element Property

Get Element CSS Value

Get Element Text

Get Element Tag Name

Get Element Rect

Is Element Enabled

Element Interaction

Element Click

Element Clear

Element Send Keys

Document Handling

Get Page Source

Executing Script

Execute Script

Execute Async Script

Cookies

Get All Cookies