WebDriver

Abstract

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 behaviour of web browsers.

Provided is a set of interfaces to discover and manipulate DOM elements in web documents and to control the behaviour 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.

The standard forms part of the Web Testing Activity that authors a larger set of tools commonly used for testing.

1. 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.

The standard defines four broad conformance classes:

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.
Issue 1
Define the requirements on the local end somewhere.
Remote End: The remote end hosts the server side of the protocol. Defining the behaviour of a remote end in response to the WebDriver protocol forms the largest part of this specification.
Intermediary Node: Intermediary nodes are those that act as proxies, implementing both the client and server sides of the protocol. Intermediary nodes 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. However they are not expected to implement remote end steps directly.
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. An endpoint node must be, like intermediary nodes, indistinguishable from a remote end.

1.1 Dependencies

This specification relies on several other underlying specifications.

DOM

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

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]

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

Keyboard Event Code Tables

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

Keyboard Modifier Keys

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 and values that are used throughout this specification:

Fetch

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

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 behaviour for:

The following types are also defined in the HTML specification, and referenced here:

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

Content editable

The following events are also defined in the HTML specification:

beforeunload

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

data: URL

HTTP and related specifications

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]

Styling

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

CSS reference 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]:

Elements from point as elementsFromPoint()
getClientRects
innerHeight
innerWidth
offsetLeft
offsetParent
offsetTop
scrollIntoView()

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]

XPATH

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

4. Protocol

WebDriver remote ends must provide an HTTP-based 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.

4.1 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.

The result of getting a property with name from an Object is defined as the result of calling the [[GetOwnProperty]] internal method of with property name name.

4.2 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 remote 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.

4.3 Processing Model

The remote end acts as a HTTP server reading requests from the client and writing responses, typically over 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:

Issue 2

Should mention what happens if it can’t be decoded as HTTP. Note that Fetch isn’t quite right because it doesn’t specify how to construct a request from network data, or serialize a response.

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].
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 url variables be request match’s data.
Let session id be the corresponding variable from url variables.
If command is not New Session:
1. If session id is not equal to the ID of any session in the list of active sessions, send an error with error code invalid session id, then jump to step 1 in this overall algorithm.
  Otherwise, let the current session be the session with ID session id.
If request’s method is POST:
1. Let parse result be the result of parsing as JSON with request’s body as the argument.
2. If parse result is an error or if it is a success but its associated data 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’s data.
Otherwise, let parameters be null.
Let response result be the return value obtained by running the remote end steps for command with url variables as arguments.
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, 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.
Issue 3
Really need a better way to construct JSON literals.
Let data be a new JSON Object initialised with the following properties:

"error"
Value of name.
"message"
Value of message.
"stacktrace"
Value of stacktrace.
Send a response with status and data 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.
If data is not null, let response’s body be the result of serializing as JSON with data as the argument.
Let response bytes be the byte sequence resulting from serializing response according to the rules in [RFC7230].
Write response bytes to the connection.

4.4 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 an 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.

4.5 List of Endpoints

The following table of endpoints lists the method and URI template for each endpoint node command.

Method	URI Template	Command
POST	/session	New Session
DELETE	/session/{`session id`}	Delete Session
POST	/session/{`session id`}/url	Go
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`}/window/fullscreen	Fullscreen Window
POST	/session/{`session id`}/window/maximize	Maximize Window
POST	/session/{`session id`}/window/size	Set Window Size
GET	/session/{`session id`}/window/size	Get Window Size
POST	/session/{`session id`}/frame	Switch To Frame
POST	/session/{`session id`}/frame/parent	Switch To Parent Frame
POST	/session/{`session id`}/element	Find Element
POST	/session/{`session id`}/element/{element id}/element	Find Element From Element
POST	/session/{`session id`}/elements	Find Elements
POST	/session/{`session id`}/element/{element id}/elements	Find Elements From Element
GET	/session/{`session id`}/element/active	Get Active 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
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/{`name`}	Get 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`}/timeouts	Set Timeout
POST	/session/{`session id`}/actions	Perform Actions
DELETE	/session/{`session id`}/actions	Releasing Actions
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`}/sendKeys	Element Send Keys
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

4.6 Handling Errors

Errors are represented in the WebDriver protocol with a HTTP response with a HTTP status in the 4xx or 5xx range, and a JSON body containing details of the error. This JSON body has three fields: error, containing a string indicating the error type; message, containing an implementation-defined string with a human readable description of the kind of error that occurred; and stacktrace, containing an implementation-defined string with a stack trace report of the active stack frames at the time when the error occurred.

Example 2

A DELETE request to /session/1234, 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:

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

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 not selectable	400	`element not selectable`	An attempt was made to select an element that cannot be selected.
element not visible	400	`element not visible`	An element command could not be completed because the element is not visible on the page.
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 coordinates	400	`invalid element coordinates`	The coordinates provided to an interactions operation are invalid.
invalid element state	400	`invalid element state`	An element command could not be completed because the element is in an invalid state, e.g. attempting to click an element that is no longer attached to the document.
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	400	`no such alert`	An attempt was made to operate on a modal dialog when one was not open.
no such element	404	`no such element`	An element could not be located on the page using the given search parameters.
no such frame	400	`no such frame`	A request to switch to a frame could not be satisfied because the frame could not be found.
no such window	400	`no such window`	A request to switch to a window could not be satisfied because the window could not be found.
script timeout	408	`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	400	`stale element reference`	An element command failed because the referenced element is no longer attached to the DOM.
timeout	408	`timeout`	An operation did not complete before its timeout expired.
unable to set cookie	500	`unable to set cookie`	A request 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.

4.7 Protocol Extensions

The protocol is designed to allow extension to meet vendor-specific needs. Commands that are specific to a user agent 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 name that is a lowercased ASCII string, and which should bear some resemblance to what the command performs. The name is used to form an extension command’s URL.

The extension command’s extension command URL is a URL composed of the extension prefix, followed by "/", and the extension command’s name. The extension command URL, 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.

The remote end’s extension prefix is a lowercased ASCII string that forms a URL path element, separating extension commands from other commands to avoid potential resource conflicts with other implementations. 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.

5. Capabilities

WebDriver capabilities allow the local end to specify what features it desires or requires the remote end to fulfill to be able to create a new session.

The following table provides an overview of recognised capabilities, and their usage and effect:

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 system or operating system of the endpoint node.
Platform version	"`platformVersion`"	string	Identifies the system version of the endpoint node.
Accept SSL certificates	"`acceptSslCerts`"	boolean	Indicates that the endpoint node support invalid SSL certificates.

Implementations are free to use the capabilities dictionary passed in the request to create a new session to provide additional feature requests from any of the remote ends, including the endpoint node. Likewise the remote end may supply additional entries on the capabilities object returned from creating a new session.

Example 4

Capabilities may for example be used to provide a serialised profile for a remote end to use during startup of the user agent binary.

A fictive example of this:

capabilities := {}
profile := serialise_profile("/path/to/profile")
capabilities["profile"] = profile
session := new_session(capabilities)

When processing capabilities with argument parameters a remote end must run the following steps:

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

"browserName"
The lowercase name of the user agent.
"browserVersion"
The version of the user agent.
"platformName"
The lowercase name of the platform.
"platformVersion"
The version of the platform.
"acceptSslCerts"
Be true if the User Agent can handle invalid SSL certifications else let it be false.
Let required capabilities be the result of getting a property named requiredCapabilities from capabilities.
If required capabilities is not a JSON Object, set the value to an empty JSON Object.
Let desired capabilities be the result of getting a property named desiredCapabilities from capabilities.
If desired capabilities is not a JSON Object, set the value to an empty JSON Object.
Let length be the length of required capabilities.
Let k be 0.
While k < length:
1. Let capability be the entry in required capabilities at index k.
2. If the name of the capability is among the names of entries in desired capabilities, remove the corresponding entry from desired capabilities.
3. Increase k by 1.
Let unmet capabilities be an empty JSON List.
Let unprocessed capabilities be a JSON Object that contains all entries from required capabilities and all entries from desired capabilities.
Let j be 0.
Let capabilities length be the length of unprocessed capabilities.
While j < capabilities length:
1. Let unprocessed capability be the entry at index j in unprocessed capabilities.
2. If during the steps below the unprocessed capability equals an entry in required capabilities and name of unprocessed capability entry among the names of entries in server capabilities and the values do not match do the following:
  1. Append a string containing the property name and the differences between the values.
3. Let browser name be the result of getting a property named browserName from unprocessed capability. If browser name is undefined move to the next step.
4. Let browser version be the result of getting a property named browserVersion from unprocessed capability. If browser version is undefined move to the next step.
5. Let platform name be the result of getting a property named platformName from unprocessed capability. If platform name is undefined move to the next step.
6. Let platform version be the result of getting a property named platformVersion from unprocessed capability. If platform version is undefined move to the next step.
7. Let proxy be the result of getting a property named proxy from unprocessed capability. If proxy is undefined move to the next step. If proxy is defined and not a map, append a string saying that a JSON Object is required, else call set the proxy passing in proxy.
8. Let page load strategy be the result of getting a property named pageLoadStrategy from unprocessed capability. If page load strategy is undefined, then set the entry pageLoadStrategy in server capabilities to normal.
If the length of unmet capabilities is not equal to 0, return session not created with data unmet capabilities.
Return server capabilities.

To set the proxy from a JSON Object proxy:

Let proxy type be the result of getting a property named proxyType from proxy.
Switch on proxy type:
"pac"
If the implementation supports proxy autoconfiguration, set the implementation’s autoproxy configuration URL to proxy autoconfiguration url.
Otherwise return an error with error code invalid argument.
"noproxy"
Set the proxy to No Proxy using implementation defined steps. If this can not be set during this process return error.
"autodetect"
Set the proxy to Auto-Detect proxy setting from the network using implementation defined steps. If this can not be set during this process return error.
"system"
Set the proxy to use system proxy settings using implementation defined steps. If this can not be set during this process return error.
"manual"
1. Let ftp proxy be the result of getting a property named ftpProxy from proxy.
2. Let ftp proxy port be the result of getting a property named ftpProxyPort from proxy.
3. Let http proxy be the result of getting a property named httpProxy from proxy.
4. Let http proxy port be the result of getting a property named httpProxyPort from proxy.
5. Let ssl proxy be the result of getting a property named sslProxy from proxy.
6. Let ssl proxy port be the result of getting a property named sslProxyPort from proxy.
7. Let socks proxy be the result of getting a property named socksProxy from proxy.
8. Let socks proxy port be the result of getting a property named socksProxyPort from proxy.
9. If socks proxy and socks proxy port is defined:
  1. Let socks version be the result of getting a property named socksVersion from proxy.
  2. Let socks username be the result of getting a property named socksUsername from proxy.
  3. Let socks password be the result of getting a property named socksPassword from proxy.
10. Follow implementation defined steps to set the proxy using defined variables from previous steps. If there are items that can not be set during this process return error.
Otherwise
Return error with error code invalid argument.

6. 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 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 requests to the remote end requires passing a session ID.

A WebDriver session represents the connection between a local end and a specific remote end. A remote end that is not an intermediary node has at most one active session at a given time.

The session is set up at the invocation of a New Session, and 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.

A remote end has an associated list of active sessions, which is a list of all sessions that are currently started.

Requests, except New Session requests, have an associated current session, which is the session in which that request's command will run.

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 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, or the top-level browsing context for which the current browsing context is an ancestor browsing context.

A session has an associated session script timeout that specifies a time to wait for scripts to run. 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 for the implicit element location strategy when locating elements using Find Element and Find Elements. Unless stated otherwise it is zero milliseconds.

A session has an associated page loading strategy, which is one of none, normal, and eager. Unless stated otherwise, it is normal.

A session has an associated user prompt handler.

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

Set the webdriver-active flag to false.
Close any top-level browsing contexts associated with the session, without prompting to unload.
Remove the current session from active sessions.
Perform any implementation-specific cleanup steps.

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.

6.1 New Session

HTTP Method	Path Template
POST	/session

The New Session command creates a new WebDriver session with the endpoint node. If the maximum active sessions has been reached, that is if the endpoint node already has a current session, there is a problem processing the given capabilities, or the provisioning of a remote end is impossible, a session not created error is returned.

If the remote end is an intermediary node, they are allowed to freely use the capabilities data e.g. to select a specific browser to test based on a combination of the required and desired capabilities. Typically the New Session response from the endpoint node selected in this process will then be relayed directly to the local end, as outlined in step 1 of the remote end steps.

Type	Identifier
session script timeout	"`script`"
session page load timeout	"`page load`"
session implicit wait timeout	"`implicit`"

State	Keyword
CSS selector	"`css selector`"
Link text selector	"`link text`"
Partial link text selector	"`partial link text`"
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 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. Defaults to 20 years into the future if omitted when adding a cookie.

Actions	Input Type
keyDown	Keyboard
keyUp	Keyboard
pointerMove	Pointer
pointerDown	Pointer
pointerUp	Pointer
pointerCancel	Pointer
pause	General

Key	Code	Type
NULL	\uE000	NULL
CANCEL	\uE001	Special key
HELP	\uE002	Special key
BACK_SPACE	\uE003	Special key
TAB	\uE004	Special key
CLEAR	\uE005	Special key
RETURN	\uE006	Special key
ENTER	\uE007	Special key
SHIFT	\uE008	Modifier
CONTROL	\uE009	Modifier
ALT	\uE00A	Modifier
PAUSE	\uE00B	Special key
ESCAPE	\uE00C	Special key
SPACE	\uE00D	Special key
PAGE_UP	\uE00E	Special key
PAGE_DOWN	\uE00F	Special key
END	\uE010	Special key
HOME	\uE011	Special key
ARROW_LEFT	\uE012	Special key
ARROW_UP	\uE013	Special key
ARROW_RIGHT	\uE014	Special key
ARROW_DOWN	\uE015	Special key
INSERT	\uE016	Special key
DELETE	\uE017	Special key
SEMICOLON	\uE018	Special key
EQUALS	\uE019	Special key
NUMPAD0	\uE01A	Special key
NUMPAD1	\uE01B	Special key
NUMPAD2	\uE01C	Special key
NUMPAD3	\uE01D	Special key
NUMPAD4	\uE01E	Special key
NUMPAD5	\uE01F	Special key
NUMPAD6	\uE020	Special key
NUMPAD7	\uE021	Special key
NUMPAD8	\uE022	Special key
NUMPAD9	\uE023	Special key
MULTIPLY	\uE024	Special key
ADD	\uE025	Special key
SEPARATOR	\uE026	Special key
SUBTRACT	\uE027	Special key
DECIMAL	\uE028	Special key
DIVIDE	\uE029	Special key
F1	\uE031	Special key
F2	\uE032	Special key
F3	\uE033	Special key
F4	\uE034	Special key
F5	\uE035	Special key
F6	\uE036	Special key
F7	\uE037	Special key
F8	\uE038	Special key
F9	\uE039	Special key
F10	\uE03A	Special key
F11	\uE03B	Special key
F12	\uE03C	Special key
META	\uE03D	Special key
COMMAND	\uE03D	Special key
ZENKAKU_HANKAKU	\uE040	Special key

Definition	Dialogue	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 dialogues encountered should be dismissed.
"`accept`"	Accept state	All simple dialogues encountered should be accepted.

Abstract

Status of This Document

1. Conformance

1.1 Dependencies

2. Terminology

3. Interface

4. Protocol

4.1 Algorithms

4.2 Commands

4.3 Processing Model

4.4 Routing Requests

4.5 List of Endpoints

4.6 Handling Errors

4.7 Protocol Extensions

5. Capabilities

6. Sessions

6.1 New Session

6.2 Delete Session

6.3 Set Timeout

7. Navigation

7.1 Go

7.2 Get Current URL

7.3 Back

7.4 Forward

7.5 Refresh

7.6 Get Title

8. Invalid SSL Certificates

9. Command Contexts

9.1 Get Window Handle

9.2 Close Window

9.3 Switch To Window

9.4 Get Window Handles

9.5 Switch To Frame

9.6 Switch To Parent Frame

9.7 Resizing and Positioning Windows

9.7.1 Get Window Size

9.7.2 Set Window Size

9.7.3 Maximize Window

9.7.4 Fullscreen Window

10. Elements

10.1 Element Interactability

10.2 Get Active Element

11. Element Retrieval

11.1 Locator Strategies

CSS Selectors

Link Text

Partial Link Text

XPath

11.2 Finding Elements to interact

12. Element State

12.1 Is Element Selected

12.2 Get Element Attribute

12.3 Get Element Property

12.4 Get Element CSS Value

12.5 Get Element Text

12.6 Get Element Tag Name

12.7 Get Element Rect

12.8 Is Element Enabled

13. Element Interaction

13.1 Element Click

13.2 Element Clear

13.3 Element Send Keys

14. Document Handling

14.1 Getting Page Source

14.2 Executing Script

14.2.1 Execute Script

14.2.2 Execute Async Script

15. Cookies

15.1 Get Cookie

15.2 Add Cookie

15.3 Delete Cookie

15.4 Delete All Cookies

16. Interactions

16.1 Actions

16.1.1 Terminology

16.1.2 Creating Actions

16.1.3 Releasing Actions

16.1.4 Actions

16.1.4.1 General Actions

16.1.4.2 Keyboard Actions