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.

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

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 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]]

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

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 following types are also defined in the HTML specification, and referenced here:

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]]

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:

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

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

Infra
The following terms are defined in the Infra standard: [[!INFRA]]
Page Visibility
The following terms are defined in the Page Visibility Specification [[!PAGE-VISIBILITY]]
Styling
The following terms are defined in the CSS Values and Units Module Level 3 specification: [[!CSS3-VALUES]]
The following properties are defined in the CSS Basic Box Model Level 3 specification: [[!CSS3-BOX]]
The following terms are defined in the CSS Device Adaptation Module Level 1 specification: [[!CSS-DEVICE-ADAPT]]
The following properties are defined in the CSS Display Module Level 3 specification: [[!CSS3-DISPLAY]]
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]]
The following terms are defined in the CSS Object Model: [[!CSSOM]]:
The following functions are defined in the CSSOM View Module: [[!CSSOM-VIEW]]:
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]]
Unicode Standard Annex #44
The following terms are defined in the standard: [[!UAX44]]
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]]

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 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 aims to allow other standards to provide extensions to support new functionality, and to allow conformance tests that cannot be implemented entirely in ECMAScript to be written in a vendor-neutral way.

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 serializing it as appropriate for the callee.

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 describe the user interface of the user agent. Examples of browser chrome elements include but are not limited to: toolbars (such as a bookmark toolbar), menus (such as the file menu), buttons (such as the back button) and decorations (such as security and certificate indicators).

Interface

partial interface Navigator {
  readonly attribute boolean webdriver;
};

The webdriver IDL attribute of the Navigator interface must return the value of the webdriver-active flag, which is initially false.

This property allows websites to determine that the user agent is under control by WebDriver, and can be used to help mitigate denial-of-service attacks.

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 client and server sides of the 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.

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 for each node type said to be:

Intermediary node

False if it is known to be in a state in which attempting to create a new session would fail. Otherwise true.

Endpoint node

False if the maximum active sessions is equal to the length of the list of active sessions or there is a current user prompt present. 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

  1. Let temp be the result of calling algorithm.

  2. If temp is an error return temp, otherwise let result be temp’s data field.

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.

The result of setting a property with name and value to an Object is defined as calling the [[\Put]] internal method with name name and value value.

The result of JSON serialization with object of type JSON Object and calling the [[\Stringify]] function with argument object.

The result of JSON deserialization with text is defined as the result of calling the [[\Parse]] function with 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:

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.

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

  2. Let request match be the result of the algorithm to match a request with request’s method and URL as arguments.

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

  4. Let session id be the corresponding variable from url variables.

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

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

  7. Wait for navigation to complete. If this returns an error return its value and jump to step 1 in this overall algorithm, otherwise continue.

  8. Let response result be the return value obtained by running the remote end steps for command with url variables as arguments.

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

  10. Send a response with status 200 and response data.

  11. Jump to step 1.

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

  1. Let http status and name be the error response data for error code.

  2. Let message be an implementation-defined string containing a human-readable description of the reason for the error.

  3. 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 data be a new JSON Object initialised with the following properties:

    error
    name
    message
    message
    stacktrace
    stacktrace
  4. 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:

  1. Let response be a new response.

  2. Set response’s HTTP status to status, and status message to the string corresponding to the description of status in the status code registry.

  3. Set the response’s header with name and value with the following values:

    Content-Type
    "application/json; charset=utf-8"
    Cache-Control
    "no-cache"
  4. Let response’s body be a JSON Object with a key value set to the JSON serialization of data.

  5. Let response bytes be the byte sequence resulting from serializing response according to the rules in [[!RFC7230]].

  6. Write response bytes to the connection.

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:

  1. Let endpoints be a list containing each row in the table of endpoints.

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

  3. If there are no entries in endpoints, return error with error code unknown command.

  4. Remove each entry in endpoints for which the method column is not an exact case-sensitive match for method.

  5. If there are no entries in endpoints, return error with error code unknown method.

  6. There is now exactly one entry in endpoints; let entry be this entry.

  7. Let parameters be the result of extracting the variables from URL using entry’s URI template.

  8. Let command be entry’s command.

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

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 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}/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. 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.

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 selectable 400 element not selectable An attempt was made to select an element that cannot be selected.
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 coordinates 400 invalid coordinates The coordinates provided to an interactions operation are invalid.
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 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 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 400 no such frame A command to switch to a frame could not be satisfied because the frame could not be found.
no such window 400 no such window A command 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 A 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 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.

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 an ASCII lower alpha 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 command 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.

An extension command prefix is an ASCII lower alpha string that forms a URL path part, separating extension commands from other commands in order 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, 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 preceeds the first ":" character in the string.

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.

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.

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", "noproxy", "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. If a URL is passed through this property, set ftpProxy to the host and ftpProxyPort to the port when the proxyType is equal to "manual". A URL consisting of just the domain and optional port
ftpProxyPort number Defines the proxy port for FTP traffic when the proxyType is equal to "manual". If ftpProxyPort is defined in ftpProxy and from this property, return error with error code invalid argument. An integer
httpProxy string Defines the proxy host for HTTP traffic. If a URL is passed through this property, set httpProxy to the host and httpProxyPort to the port when the proxyType is equal to "manual". A URL consisting of just the domain and optional port
httpProxyPort number Defines the proxy port for HTTP traffic when the proxyType is "manual". If httpProxyPort is defined in httpProxy and from this property, return error with error code invalid argument. An integer
sslProxy string Defines the proxy host for encrypted TLS traffic when the proxyType is "manual". If a URL is passed through this property, set sslProxy to the host and sslProxyPort to the port. A URL consisting of just the domain and optional port
sslProxyPort number Defines the proxy port for SSL traffic when the proxyType is "manual". If sslProxyPort is defined in sslProxy and from this property, return error with error code invalid argument. An integer
socksProxy string Defines the proxy host for a SOCKS proxy when the proxyType is "manual". If a URL is passed through this property, set socksProxy to the host and socksProxyPort to the port. A URL consisting of just the domain and optional port
socksProxyPort number Defines the proxy port for a SOCKS proxy when the proxyType is "manual". If socksProxyPort is defined in socksProxy and from this property, return error with error code invalid argument. An integer
socksVersion number Defines the SOCKS proxy version when the proxyType is "manual". Any string
socksUsername string Defines the username used when authenticating with a SOCKS proxy when the proxyType is "manual". Any string
socksPassword string Defines the password used when authenticating with a SOCKS proxy, when the proxyType is "manual", and is not returned with capabilities to the local end. Any string

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

  1. If parameter is not a JSON Object return an error with error code invalid argument.

  2. Let proxy be a new, empty proxy configuration object.

  3. 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. Let key be the result of lowercasing key.

    4. If there is no matching key for key in the proxy configuration table return an error with error code invalid argument.

    5. If value is not one of the valid values for that key, return an error with error code invalid argument.

    6. Set a property key to value on 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:

  1. Let capabilities request be the result of getting a property named "capabilities" from parameters.

    1. If capabilities request is not a JSON object, return error with error code invalid argument.

  2. Let required capabilities be the result of getting a property named "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.

  3. Let all first match capabilities be the result of getting a property named "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, return error with error code invalid argument.

  4. Let validated first match capabilities be an empty JSON List.

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

  6. For each first match capbilities corresponding to an indexed property in validated first match capabilities:

    1. Let merged capabilities be the result of trying to merge capabilities with required capabilities and first match capabilities as arguments.

    2. Let matched capabilities be the result of trying to match capabilities with merged capabilities as an argument.

    3. If matched capabilities is not null return matched capabilities.

  7. Return success with data null.

When required to validate capabilities with argument capability:

  1. If capability is not a JSON Object return an error with error code invalid argument.

  2. Let result be an empty JSON Object.

  3. 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 witha 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.

  4. Return success with data result.

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

  1. Let result be a new JSON Object.

  2. For each enumerable own property in primary, run the following substeps:

    1. Let name be the the name of the property.

    2. Let value be the the result of getting a property named name from primary.

    3. Set a property on result with name name and value value.
  3. If secondary is undefined, return result.

  4. For each enumerable own property in secondary, run the following substeps:

    1. Let name be the the name of the property.

    2. Let value be the the result of getting a property named name from secondary.

    3. Let primary value be the result of getting a property named 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.
  5. Return result.

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

  1. 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.
  2. Optionally add extension capabilities as entries to matched capabilities. The values of these may be ellided, and there is no requirement that all extension capabilities be added.

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

    1. 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 are to be treated as valid platformNames for the following Operating Systems:

      Platform Operating System
      linuxAny OS based upon the Linux kernel and X Windows.
      macAny version of Apple's OS X.
      windowsAny version of Microsoft's Windows, including desktop and mobile versions.

      This list is not exhaustive.

      "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 not the key of an extension capability and the remote end is an endpoint node return success with data null.

      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.

    2. Set a property on matched capability with name name and value value.

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

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 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 retreiving 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 none, normal, and eager. 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 null.

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.

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

  1. Set the webdriver-active flag to false.

  2. Close any top-level browsing contexts associated with the session, without prompting to unload.

  3. Remove the current session from active sessions.

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

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, 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, 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 custom capabilities to assist in this process, however, these 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 MAY forward custom, top-level parameters (i.e. non-capabilities) to subsequent remote end nodes.

The remote end steps are:

  1. If the remote end is an intermediary node, take implementation-defined steps that either result in returning an error with error code session not created, or in returning a success with data that is isomorphic to that returned by remote ends according to the rest of this algorithm.

  2. If the maximum active sessions is equal to the length of the list of active sessions, return error with error code session not created.

  3. If there is a current user prompt, return error with error code session not created.

  4. Let capabilities be the result of trying to process capabilities with parameters as an argument.

  5. If capabilities result is an error, return error with error code session not created and the error data from capabilities result.

  6. If capabilities result's data is null, return error with error code session not created.

  7. Let capabilities be capabilities result’s data.

  8. Let session id be a UUID.

  9. Let session be a new session with the session ID of session id.

  10. Set the current session to session.

  11. Append session to active sessions.

  12. Let body be a JSON Object initialised with:

    sessionId
    session id
    capabilities
    capabilities result
  13. Initialize the following from capabilities:

    1. Let strategy be the result of getting property "pageLoadStrategy" from capabilities.

    2. If strategy is a string, set the current session’s page loading strategy to strategy. Otherwise, set the page loading strategy to normal.

    3. Let proxy be the result of getting property "proxy" from capabilities.

    4. If proxy is a proxy configuration object, take implementation-defined steps to set the user agent proxy using the extracted proxy configuration. If the defined proxy cannot be configured or is not a proxy configuration object, return error with error code session not created.

    5. Let timeouts be the result of getting property "timeouts" from capabilities.

    6. If timeouts is a session timeouts configuration object:

      1. If timeouts has a numeric property with key "implicit", set the current session’s session implicit wait timeout to the value of property "implicit". Otherwise, set the session implicit wait timeout to 0 (zero) milliseconds.

      2. If timeouts has a numeric property with key "pageLoad", set the current session’s session page load timeout to the value of property "pageLoad". Otherwise, set the session page load timeout to 300,000 milliseconds.

      3. If timeouts has a numeric property with key "script", set the current session’s session script timeout to the value of property "script". Otherwise, set the session script timeout to 30,000 milliseconds.

    7. Apply changes to the user agent for any implementation-defined capabilities selected during the capabilities processing step.

  14. Set the webdriver-active flag to true.

  15. Return success with data body.

Delete Session

HTTP Method Path Template
DELETE /session/{session id}

The Delete Session command closes any top-level browsing contexts associated with the current session, terminates the connection, and finally closes the current session.

The remote end steps are:

  1. Close the session.

  2. Return success with data null.

Status

HTTP Method Path Template
GET /status

The Status command returns information about whether a remote end is in a state in which it can create new sessions and can additionally include arbitrary meta information that is specific to the implementation.

The readiness state is represented by the ready property of the body, which is false if an attempt to create a session at the current time would fail. However, the value true does not guarantee that a New Session command will succeed.

Implementations may optionally include additional meta information as part of the body, but the top-level properties ready and message are reserved and must not be overwritten.

The remote end steps are:

  1. Let body be a new JSON Object with the following properties:

    "ready"

    The remote end’s readiness state.

    "message"

    An implementation-defined string explaining the remote end’s readiness state.

  2. Return success with data body.

Get Timeouts

HTTP Method Path Template
GET /session/{session id}/timeouts

The Get Timeouts command gets timeout durations associated with the current session.

The remote end steps are:

  1. Let body be a new JSON Object with the following properties:

    "script"
    session script timeout
    "pageLoad"
    session page load timeout
    "implicit"
    session implicit wait timeout
  2. Return success with data body.

Set Timeouts

HTTP Method Path Template
POST /session/{session id}/timeouts

The Set Timeouts command sets timeout durations associated with the current session. The timeouts that can be controlled are listed in the table of session timeouts below.

The following table of session timeouts enumerates the different timeout types that may be set. The keywords given in the first column maps to the timeout type given in the second.

Keyword Type Brief 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.

A session timeouts configuration is a JSON Object. It consists of the properties named after the keys in the table of session timeouts and may include implementation-specific timeouts.

The steps to deserialize as a timeout with argument parameters are:

  1. If parameters is not a JSON Object, return error with error code invalid argument.

  2. For each enumerable own property in parameters, 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 parameters.

    3. Find the timeout type from the table of session timeouts by looking it up by its keyword key.

      If no keyword matches key, return error with error code invalid argument.

    4. If value is not an integer, or it is less than 0 or greater than 264 – 1, return error with error code invalid argument.

  3. Return success with data parameters.

The remote end steps are:

  1. Let parameters be the result of trying to deserialize as a timeout parameters.
  2. For each enumerable own property in parameters:

    1. Let key be the name of the property.

    2. Let value be the result of getting a property named name from parameters.

    3. Find the timeout type from the table of session timeouts by looking it up by its keyword key.

    4. Set timeout type’s value.

  3. Return success with data null.

Navigation

The commands in this section allow navigation of the current top-level browsing context to new URLs and introspection of the document currently loaded in this browsing context.

For commands that cause a new document to load, the point at which the command returns is determined by the session’s page loading strategy. The normal state causes it to return after the load event fires on the new page, eager causes it to return after the DOMContentLoaded event fires, and none causes it to return immediately.

Navigation actions are also affected by the value of the session page load timeout, which determines the maximum time that commands will block before returning with a timeout error.

The following is the table of page load strategies that links the pageLoadingStrategy capability keyword to a page loading strategy state, and shows which document readiness state that corresponds to it:

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

When asked to deserialize as a page load strategy with argument value:

  1. If value is null, let value be set to "normal".

  2. If value is not a string return an error with error code invalid argument.

  3. If there is no entry in the table of page load strategies with keyword value return an error with error code invalid argument.

  4. Return success with data value.

When asked to wait for navigation to complete, run the following steps:

  1. If the current session's page loading strategy is not "none" and if there is an ongoing attempt to navigate the current browsing context that has not yet matured, wait for navigation to complete.

  2. If the current session has a page loading strategy:

    1. Let readiness target be the document readiness state tied to the current session’s page loading strategy, which can be found in the table of page load strategies.

    2. Wait for the the current browsing context’s document readiness state to reach readiness target, or for the session page load timeout to pass, whichever occurs sooner.

    3. If the previous step completed by the session page load timeout being reached and the browser does not have an active user prompt, return error with error code timeout.

When asked to run the post-navigation checks, run the substeps of the first matching statement:

response is a network error

Return error with error code unknown error.

response be blocked by content security policy

If the current session’s secure TLS state is disabled, take implementation specific steps to ensure the navigation is not aborted and that the untrusted- or invalid TLS certificate error that would normally occur under these circumstances, are suppressed.

Otherwise return error with error code insecure certificate.

response’s HTTP status is 401
Otherwise

Irrespective of how a possible authentication challenge is handled, return success with data null.

Go

HTTP Method Path Template
POST /session/{session id}/url

The Go command is used to cause the user agent to navigate the current top-level browsing context a new location.

If the session is not in a secure TLS state, no certificate errors that would normally cause the user agent to abort and show a security warning are to be hinder navigation to the requested address.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the url property is missing from the parameters argument or it is not a string, return error with error code invalid argument.

  4. Let url be the result of getting a property named url from the parameters argument.

  5. If url is not an absolute URL or is not an absolute URL with fragment or not a local scheme, return error with error code invalid argument.

  6. Let current URL be the current top-level browsing context’s active document’s document URL.

  7. If current URL and url do not have the same absolute URL:

    1. If timer has not been started, start a timer. If this algorithm has not completed before timer reaches the session's session page load timeout in milliseconds, return an error with error code timeout.
  8. Navigate the current top-level browsing context to url.

  9. If url is special except for file and current URL and URL do not have the same absolute URL :

    1. Run the post-navigation checks and return its value if it is an error.

    2. Wait for navigation to complete and return its value if it is an error.

  10. Set the current browsing context to the current top-level browsing context.

  11. If the current top-level browsing context contains a refresh state pragma directive of time 1 second or less, wait until the refresh timeout has elasped, a new navigate has begun, and return to the first step of this algorithm.

  12. Return success with data null.

Figure out if next paragraph is actually required:

When a page contains a META tag with the "http-equiv" attribute set to "refresh", a response MUST be returned if the timeout is greater than 1 second and the other criteria for determining whether a page is loaded are met. When the refresh period is 1 second or less and the page loading strategy is "normal" or "conservative" implementations MUST wait for the refresh to complete before responding.

Get Current URL

HTTP Method Path Template
GET /session/{session id}/url

The Get Current URL command returns the URL of the current top-level browsing context.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let url be the serialization of the current top-level browsing context’s active document’s document URL.

  4. Return success with data url.

Back

HTTP Method Path Template
POST /session/{session id}/back

The Back command causes the browser to traverse one step backward in the joint session history of the current top-level browsing context. This is equivalent to pressing the back button in the browser chrome or calling window.history.back.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Traverse the history by a delta –1 for the current browsing context.

  4. If the previous step completed results in a pageHide event firing, wait until pageShow event fires or for the session page load timeout milliseconds to pass, whichever occurs sooner.

  5. If the previous step completed by the session page load timeout being reached, and user prompts have been handled, return error with error code timeout.

  6. Return success with data null.

Forward

HTTP Method Path Template
POST /session/{session id}/forward

The Forward command causes the browser to traverse one step forwards in the joint session history of the current top-level browsing context.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Traverse the history by a delta 1 for the current browsing context.

  4. If the previous step completed results in a pageHide event firing, wait until pageShow event fires or for the session page load timeout milliseconds to pass, whichever occurs sooner.

  5. If the previous step completed by the session page load timeout being reached, and user prompts have been handled, return error with error code timeout.

  6. Return success with data null.

Refresh

HTTP Method Path Template
POST /session/{session id}/refresh

The Refresh command causes the browser to reload the page in in current top-level browsing context.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Navigate the current top-level browsing context to the same resource as its active document, with replacement enabled.

  4. Run the post-navigation checks and return its value if it is an error.

  5. Wait for navigation to complete and return its value if it is an error.

  6. Set the current browsing context to the current top-level browsing context.

  7. Return success with data null.

Get Title

HTTP Method Path Template
GET /session/{session id}/title

The Get Title command returns the document title of the current top-level browsing context, equivalent to calling document.title.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let title be the initial value of the title IDL attribute of the current top-level browsing context's active document.

  4. Return success with data title.

Command Contexts

Many WebDriver commands happen in the context of either the current browsing context or current top-level browsing context. The current top-level browsing context is represented in the protocol by its associated window handle. A top-level browsing context is selected using the Switch To Window command. Once this is done, a specific browsing context can be selected using the Switch to Frame command.

The use of the term “window” to refer to a top-level browsing context is legacy and doesn’t correspond with either the operating system notion of a “window” or the DOM Window object.

A browsing context is said to be no longer open if it has been discarded.

Each browsing context has an associated window handle (string) uniquely identifying it. It must not be "current".

The web window identifier is the string constant "window-fcc6-11e5-b4f8-330a88ab9d7f".

The web frame identifier is the string constant "frame-075b-4da1-b6ba-e579c2d3230a".

The JSON Serialization of the WindowProxy object is the JSON Object obtained by applying the following algorithm to the given WindowProxy object window:

  1. Let identifier be the web window identifier if the associated browsing context of window is a top-level browsing context.

    Otherwise let it be the web frame identifier.

  2. Return a JSON Object initialised with the following properties:

    identifier

    Associated window handle of the window’s browsing context.

In accordance with the focus section of the [[!HTML]] specification, commands are unaffected by whether the operating system window has focus or not.

Get Window Handle

HTTP Method Path Template
GET /session/{session id}/window

The Get Window Handle command returns the window handle for the current top-level browsing context. It can be used as an argument to Switch To Window.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Return success with data being the window handle associated with the current top-level browsing context.

Close Window

HTTP Method Path Template
DELETE /session/{session id}/window

The remote end steps for the Close Window command are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Close the current top-level browsing context.

  4. If there are no more open top-level browsing contexts, then close the session.

  5. Return the result of running the remote end steps for the Get Window Handles command.

Switch To Window

HTTP Method Path Template
POST /session/{session id}/window

The Switch To Window command is used to select the current top-level browsing context for the current session, i.e. the one that will be used for processing commands.

The remote end steps are:

  1. If there is an active user prompt, that due to the uniqueness of the user agent prevents the focussing of another top-level browsing context, return error with error code unsupported operation.

  2. Let handle be the result of getting a property named "handle" from the parameters argument.

  3. If handle is equal to the associated window handle for some top-level browsing context in the current session, set the session’s current browsing context to that browsing context, and return success with data null.

    Otherwise, return error with error code no such window.

Get Window Handles

HTTP Method Path Template
GET /session/{session id}/window/handles

The Get Window Handles command returns a list of window handles for every open top-level browsing context. The order in which the window handles are returned is arbitrary.

The remote end steps are:

  1. Let handles be a JSON List.

  2. For each top-level browsing context in the remote end, push the associated window handle onto handles.

  3. Return success with data handles.

Switch To Frame

HTTP Method Path Template
POST /session/{session id}/frame

The Switch To Frame command is used to select the current top-level browsing context or a child browsing context of the current browsing context to use as the current browsing context for subsequent commands.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let id be the result of getting a property named "id" from the parameters argument.

  4. Run the substeps of the first matching condition:

    id is null
    1. Set the current browsing context to the current top-level browsing context.

    id is a Number object
    1. If id is less than 0 or greater than 216 – 1, return error with error code no such frame.

    2. Let window be the associated window of the current browsing context’s active document.

    3. If id is not a supported property index of window, return error with error code no such frame.

    4. Let child window be the WindowProxy object obtained by calling [[\GetOwnProperty]] of a Window object window with argument id.

    5. Set the current browsing context to new window’s browsing context.

    id represents a web element
    1. Let element be the result of trying to get a known element by web element reference id.

    2. If element is stale, return error with error code stale element reference.

    3. If element is not a frame or iframe element, return error with error code no such frame.

    4. Set the current browsing context to element’s nested browsing context.

    Otherwise
    1. Return error with error code no such frame.

  5. Return success with data null.

WebDriver is not bound by the same origin policy, so it is always possible to switch into child browsing contexts, even if they are different origin to the current browsing context.

Switch To Parent Frame

HTTP Method Path Template
POST /session/{session id}/frame/parent

The Switch to Parent Frame command sets the current browsing context for future commands to the parent of the current browsing context.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the current browsing context is not equal to the current top-level browsing context, set the current browsing context to the parent browsing context of the current browsing context.

  4. Return success with data null.

Resizing and Positioning Windows

WebDriver provides commands for interacting with the operating system window containing the current top-level browsing context. Because different operating system’s window managers provide different abilities, not all of the commands in this section can be supported by all remote ends. Support for these commands is determined by the window dimensioning/positioning capability. Where a command is not supported, an unsupported operation error is returned.

A top-level browsing context’s window rect is defined as a dictionary of the screenX, screenY, width and height attributes of the WindowProxy. Its JSON representation is the following:

x

WindowProxy’s screenX attribute.

y

WindowProxy’s screenY attribute.

width

Width of the top-level browsing context’s outer dimensions, including any browser chrome and externally drawn window decorations in CSS reference pixels.

height

Height of the top-level browsing context’s outer dimensions, including any browser chrome and externally drawn window decorations in CSS reference pixels.

In some user agents the operating system’s window dimensions including decorations, are provided by the proprietary window.outerWidth and window.outerHeight [[!DOM]] properties.

Get Window Rect

HTTP Method Path Template
GET /session/{session id}/window/rect

The Get Window Rect command returns the size and position on the screen of the operating system window corresponding to the current top-level browsing context.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Return success with the JSON serialization of the current top-level browsing context’s window rect.

Set Window Rect

HTTP Method Path Template
POST /session/{session id}/window/rect

The Set Window Rect command alters the size and the position of the operating system window corresponding to the current top-level browsing context.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the remote end does not support the Set Window Rect command for the current top-level browsing context for any reason, return error with error code unsupported operation.

  4. Let width be the result of getting a property named width from the parameters argument, else let it be null.

  5. Let height be the result of getting a property named height from the parameters argument, else let it be null.

  6. Let x be the result of getting a property named x from the parameters argument, else let it be null.

  7. Let y be the result of getting a property named y from the parameters argument, else let it be null.

  8. If width or height is neither null nor an integer from 0 to 264 − 1, return error with error code invalid argument.

  9. If x or y is neither null nor an integer from −(263) to 263 − 1, return error with error code invalid argument.

  10. Fully exit fullscreen.

  11. If the top-level browsing context’s document hidden attribute is true, run the implementation specific steps that will set the top-level browsing context document hidden attribute to false.

  12. If width and height are not null:

    1. Set the width, in CSS reference pixels, of the operating system window containing the current top-level browsing context, including any browser chrome and externally drawn window decorations to a value that is as close as possible to width.

    2. Set the height, in CSS reference pixels, of the operating system window containing the current top-level browsing context, including any browser chrome and externally drawn window decorations to a value that is as close as possible to height.

  13. If x and y are not null:

    1. Run the implementation-specific steps to set the position of the operating system level window containing the current top-level browsing context to the position given by the x and y coordinates.

  14. Return success with the JSON serialization of the current top-level browsing context’s window rect.

Maximize Window

HTTP Method Path Template
POST /session/{session id}/window/maximize

The Maximize Window command invokes the window manager-specific “maximize” operation, if any, on the window containing the current top-level browsing context. This typically increases the window to the maximum available size without going full-screen.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the remote end does not support the Maximize Window command for the current top-level browsing context for any reason, return error with error code unsupported operation.

  4. Run the implementation-specific steps to increase the dimensions of the operating system level window containing the current top-level browsing context to the maximum available size allowed by the window manager.

  5. Return success with the JSON serialization of the current top-level browsing context’s window rect.

Minimize Window

HTTP Method Path Template
POST /session/{session id}/window/minimize

The Minimize Window command invokes the window manager-specific “minimize” operation, if any, on the window containing the current top-level browsing context. This typically hides the window in the system tray.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the remote end does not support the Minimize Window command for the current top-level browsing context for any reason, return error with error code unsupported operation.

  4. Run the implementation-specific steps to hide the current top-level browsing context from the visible screen.

  5. Return success with the JSON serialization of the current top-level browsing context’s window rect.

Fullscreen Window

HTTP Method Path Template
POST /session/{session id}/window/fullscreen

The Fullscreen Window command invokes the window manager-specific “full screen” operation, if any, on the window containing the current top-level browsing context. This typically increases the window to the size of the physical display and can hide browser chrome elements such as toolbars.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. If the remote end does not support fullscreen return error with error code unsupported operation.

  4. Call fullscreen an element with the current top-level browsing context’s active document’s document element.

  5. Return success with the JSON serialization of the current top-level browsing context’s window rect.

Elements

A web element is an abstraction used to identify an element when it is transported across the protocol, between remote- and local ends.

The web element identifier is a constant with the string "element-6066-11e4-a52e-4f735466cecf".

Each element has an associated web element reference that uniquely identifies the element across all browsing contexts. The web element reference for every element representing the same element is the same. It should be a UUID.

An ECMAScript Object represents a web element if it has a web element identifier own property.

Each browsing context has an associated list of known elements. When the browsing context is discarded, the list of known elements is discarded along with it.

To get a known element with argument reference, let element be the known element which web element reference matches reference. If there are none, return error with error code no such element. If element is stale, return error with error code stale element reference. Otherwise return success with element.

To create a web element reference for an element:

  1. For each known element of the current browsing context’s known elements:

    1. If known element equals element, return success with known element’s web element reference.

  2. Add element to the known elements of the current browsing context.

  3. Return success with the element’s web element reference.

The JSON serialization of an element is a JSON Object where the web element identifier key is mapped to the element’s web element reference.

When required to deserialize a web element by a JSON Object object that represents a web element:

  1. If object has no own property web element identifier, return error with error code invalid argument.

  2. Let reference be the result of getting the web element identifier property from object.

  3. Let element be the result of trying to get a known element with argument reference.

  4. Return success with data element.

A stale element is a reference to a node that has been disconnected from the current browsing context’s DOM. To determine if an element is stale, run the following substeps:

  1. Let document be the current browsing context’s document element.

  2. If element is not in the same tree as document, return true.

  3. Otherwise return false.

An element is scrolled into view by following these steps:

  1. If element is in view, do nothing.

  2. Otherwise, [[\CALL]] scrollIntoView on element with arguments ScrollIntoViewOptions {behavior: "instant", block: "end", inline: "nearest"}.

An element is considered editable if one or more of the following conditions are met:

An element is said to have pointer events disabled if the resolved value of its "pointer-events" style property is "none".

An element is to be considered read only if it is an input element whose readOnly attribute is set.

Element Interactability

In order to determine if an element can be interacted with using pointer actions, WebDriver performs hit-testing to find if the interaction will be able to reach the requested element.

An interactable element is an element which is either pointer-interactable or keyboard-interactable.

A pointer-interactable element is defined to be the first element, defined by the paint order found at the center point of its rectangle that is inside the viewport, excluding the size of any rendered scrollbars.

A keyboard-interactable element is defined to be any element that has a focusable area, or is the body element. In the case of the body element all keyboard interactions must be targeted to its ownerDocument.

An element’s in-view center point is the origin position of the rectangle that is the intersection between the element’s first DOM client rectangle and the initial viewport. Given an element that is known to be in view, it can be calculated this way:

  1. Let rectangle be the first element of the DOMRect sequence returned by calling getClientRects on element.

  2. Let left be (max(0, min(x coordinate, x coordinate + width dimension))).

  3. Let right be (min(innerWidth, max(x coordinate, x coordinate + width dimension))).

  4. Let top be (max(0, min(y coordinate, y coordinate + width dimension))).

  5. Let bottom be (min(innerHeight, max(y coordinate, y coordinate + height dimension))).

  6. Let x be (0.5 × (left + right).

  7. Let y be (0.5 × (top + bottom).

  8. Return x and y as a pair.

An element is in view if it is a member of its own pointer-interactable paint tree.

An element is obscured if it is not pointer-interactable and the first pointer-interactable element at its center point is not itself.

In order to produce a pointer-interactable paint tree from an element:

  1. If element is not in the same tree as the current browsing context’s active document, return an empty sequence.

  2. Let rectangles be the DOMRect sequence returned by calling element’s getClientRects.

  3. If rectangles has the length of 0, return an empty sequence.

  4. Let center point be the in-view center point of element given the first indexed element of rectangles.

  5. Return the elements from point given the coordinates center point.

To get the first pointer-interactable element given a pointer-interactable paint tree, return with success the first element. Otherwise, if there are no such elements, return an error.

Get Active Element

HTTP Method Path Template
GET /session/{session id}/element/active

Get Active Element returns the active element of the current browsing context’s document element.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let active element be the active element of the current browsing context’s document element.

  4. Let active web element be the JSON Serialization of active element.

  5. Return success with data active web element.

Element Retrieval

The Find Element, Find Elements, Find Element From Element, and Find Elements From Element commands allow lookup of individual elements and collections of elements. Element retrieval searches are performed using pre-order traversal of the document’s nodes that match the provided selector’s expression. Elements are serialised and returned as web elements.

When required to find with arguments start node, using and value, a remote end must run the following steps:

  1. Let end time be the current time plus the session implicit wait timeout.

  2. Let location strategy be equal to using.

  3. Let selector be equal to value.

  4. Let result be an empty JSON List.

  5. Let elements returned be the result of the relevant element location strategy call with arguments start node, and selector.

  6. If a DOMException, SyntaxError, XPathException, or other error occurs during the execution of the element location strategy, return error invalid selector.
  7. If elements returned is empty and the current time is less than end time return to step 5. Otherwise, continue to the next step.

  8. Let result be an empty JSON List.

  9. For each element in elements returned, append the serialization of element to result.

  10. Return result.

Locator Strategies

An element location strategy is an enumerated attribute deciding what technique should be used to search for elements in the current browsing context. The following table of location strategies lists the keywords and states defined for this attribute:

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"

CSS Selectors

To find a web element with the CSS Selector strategy the following steps need to be completed:

  1. Let elements be the result of calling querySelectorAll with selector with the context object equal to the start node.
  2. Return elements.

Link Text

To find a web element with the Link Text strategy the following steps need to be completed:

  1. Let elements be the result of calling querySelectorAll, with argument a elements, with the context object equal to the start node.

  2. Let result be an empty NodeList.

  3. For each element in elements:

    1. Let rendered text be the value that would be returned via a call to Get Element Text for element.

    2. Let trimmed text be the result of removing all whitespace from the start and end of the string rendered text.

    3. If trimmed text equals selector, append element to result.

  4. Return result.

Partial Link Text

The Partial link text strategy is very similar to the Link Text strategy, but rather than matching the entire string, only a substring needs to match. That is, return all a elements with rendered text that contains the selector expression.

To find a web element with the Partial Link Text strategy the following steps need to be completed:

  1. Let elements be the result of calling querySelectorAll, with argument a elements, with the context object equal to the start node.

  2. Let result be an empty NodeList.

  3. For each element in elements:

    1. Let rendered text be the value that would be returned via a call to Get Element Text for element.

    2. If rendered text contains selector, append element to result.

  4. Return result.

Tag Name

To find a web element with the Tag Name strategy return the result of calling start node's getElementsByTagName with the argument selector.

XPath

To find a web element with the XPath Selector strategy the following steps need to be completed:

  1. Let result be Return the result of calling evaluate, with arguments selector, context object equal to the start node.

  2. If any item in result is not an element return an error with error code invalid selector.

  3. Return result.

Find Element

HTTP Method Path Template
POST /session/{session id}/element

The Find Element command is used to find an element in the current browsing context that can be used for future commands.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let start node be the current browsing context’s document element.

  3. Let location strategy be the result of getting a property called "using".

  4. If location strategy is not present as a keyword in the table of location strategies, return error with error code invalid argument.

  5. Let selector be the result of getting a property called "value".

  6. If selector is undefined, return error with error code invalid argument.

  7. Let result be the result of Find with start node, location strategy, and selector.

  8. If result is empty, return error with error code no such element. Otherwise, return the first element of result.

Find Elements

HTTP Method Path Template
POST /session/{session id}/elements

The Find Elements command is used to find elements in the current browsing context that can be used for future commands.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let start node be the current browsing context’s document element.

  3. Let location strategy be the result of getting a property called "using".

  4. If location strategy is not present as a keyword in the table of location strategies, return error with error code invalid argument.

  5. Let selector be the result of getting a property called "value".

  6. If selector is undefined, return error with error code invalid argument.

  7. Return the result of Find with start node, location strategy, and selector.

Find Element From Element

HTTP Method Path Template
POST /session/{session id}/element/{element id}/element

The Find Element From Element command is used to find an element from a web element in the current browsing context that can be used for future commands.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let start node be the result of trying to get a known element with argument element id.

  3. Let location strategy be the result of getting a property called "using".

  4. If location strategy is not present as a keyword in the table of location strategies, return error with error code invalid argument.

  5. Let selector be the result of getting a property called "value".

  6. If selector is undefined, return error with error code invalid argument.

  7. Let result be the value of calling Find with start node, location strategy, and selector.
  8. If result is empty, return error with error code no such element. Otherwise, return the first element of result.

Find Elements From Element

HTTP Method Path Template
POST /session/{session id}/element/{element id}/elements

The Find Elements From Element command is used to find elements from a web element in the current browsing context that can be used for future commands.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let start node be the result of trying to get a known element with argument element id.

  3. Let location strategy be the result of getting a property called "using".

  4. If location strategy is not present as a keyword in the table of location strategies, return error with error code invalid argument.

  5. Let selector be the result of getting a property called "value".

  6. If selector is undefined, return error with error code invalid argument.

  7. Return the result of Find with start node, location strategy, and selector.

Element State

To calculate the absolute position of element:

  1. Let x and y both be 0.

  2. Let rect be the value returned by calling getBoundingClientRect.

  3. Let rect x be the result of getting a property named "x" from rect.

  4. Let rect y be the result of getting a property named "y" from rect.

  5. Let scroll x be the value returned by calling scrollX.

  6. Let scroll y be the value returned by calling scrollY.

  7. Set x to (scroll x + rect x)

  8. Set y to (scroll y + rect y)

  9. Return a pair of (x, y).

When a node is said to be not in the same tree as another node, other, the following steps must be taken:

  1. If the node’s ownerDocument attribute is not other, return true.

  2. If the result of calling the node’s compareDocumentPosition with other as argument is DOCUMENT_POSITION_DISCONNECTED (1), return true.

  3. Return false.

An element’s container is:

option element in a valid element context
optgroup element in a valid element context

The element’s element context, meaning its immediate parent node in reverse tree-order originating from element that is either a datalist element or a select element.

option element in an invalid element context

The element does not have a container.

Otherwise

The container is the element itself.

Is Element Selected

HTTP Method Path Template
GET /session/{session id}/element/{element id}/selected

Is Element Selected determines if the referenced element is selected or not. This operation only makes sense on input elements of the Checkbox- and Radio Button states, or option elements.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let selected be the value corresponding to the first matching statement:

    element is an input element with a type attribute in the Checkbox- or Radio Button state

    The result of element’s checkedness.

    element is an option element

    The result of element’s selectedness.

    Otherwise
    False.
  6. Return success with data selected.

Get Element Attribute

HTTP Method Path Template
GET /session/{session id}/element/{element id}/attribute/{name}

The Get Element Attribute command will return the attribute of a web element.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. If name is undefined, return error with error code invalid argument.

  6. Let result be the result of the first matching condition:
    If name is a boolean attribute

    "true" (string) if the element has the attribute, otherwise null.

    Otherwise

    The result of getting an attribute by name name.

  7. Return success with data result.

Please note that the behavior of this command deviates from the behavior of getAttribute in [[DOM]], which in the case of a set boolean attribute would return an empty string. The reason this command returns true as a string is because this evaluates to true in most dynamically typed programming languages, but still preserves the expected type information.

Get Element Property

HTTP Method Path Template
GET /session/{session id}/element/{element id}/property/{name}

The Get Element Property command will return the result of getting a property of an element.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let property be the result of calling the [[\GetProperty]] internal method of element with property name name.

  6. Let result be the value of property if not undefined, or null.

  7. Return success with data result.

Get Element CSS Value

HTTP Method Path Template
GET /session/{session id}/element/{element id}/css/{property name}

The Get Element CSS Value command retrieves the computed value of the given CSS property of the given web element.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let computed value be the computed value of parameter property name from element’s style declarations if the current browsing context’s document type is not "xml", else let it be "".

  6. Return success with data computed value.

Get Element Text

HTTP Method Path Template
GET /session/{session id}/element/{element id}/text

The Get Element Text command intends to return an element’s text “as rendered”. This is approximately equivalent to calling element.innerText. An element’s rendered text is also used for locating a elements by their link text and partial link text.

When processing text, whitespace is defined as characters from the Unicode Character Database ([[UAX44]]) with the Unicode character property "WSpace=Y".

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let rendered text be the result of getting innerText of element.

  6. Return success with data rendered text.

Get Element Tag Name

HTTP Method Path Template
GET /session/{session id}/element/{element id}/name

The Get Element Tag Name command returns the qualified element name of the given web element.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let qualified name be the result of getting element’s tagName content attribute.

  6. Return success with data qualified name.

Get Element Rect

HTTP Method Path Template
GET /session/{session id}/element/{element id}/rect

The Get Element Rect command returns the dimensions and coordinates of the given web element. The returned value is a dictionary with the following members:

x
X axis position of the top-left corner of the web element relative to the current browsing context’s document element in CSS reference pixels.
y
Y axis position of the top-left corner of the web element relative to the current browsing context’s document element in CSS reference pixels.
height
Height of the web element’s bounding rectangle in CSS reference pixels.
width
Width of the web element’s bounding rectangle in CSS reference pixels.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If the element is stale, return error with error code stale element reference.

  5. Calculate the absolute position of element and let it be coordinates.

  6. Let rect be element’s bounding rectangle.

  7. Let body be a new JSON Object initialised with:

    x
    The first value of coordinates.
    y
    The second value of coordinates.
    width
    Value of rect’s width dimension.
    height
    Value of rect’s height dimension.
  8. Return success with data body.

Is Element Enabled

HTTP Method Path Template
GET /session/{session id}/element/{element id}/enabled

Is Element Enabled determines if the referenced element is enabled or not. This operation only makes sense on form controls.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. If element is stale, return error with error code stale element reference.

  5. Let enabled be a boolean initially set to true if the current browsing context’s document type is not "xml".

    Otherwise, let enabled to false and jump to the last step of this algorithm.

  6. Set enabled to false if a form control is disabled.

  7. Return success with data enabled.

Element Interaction

The element interaction commands provide a high-level instruction set for manipulating form controls. Unlike Actions, they will implicitly scroll elements into view and check that it is an interactable element.

Element Click

HTTP Method Path Template
POST /session/{session id}/element/{element id}/click

The Element Click command scrolls into view the element if it is not already pointer-interactable, and clicks its in-view center point. If the element’s center point is obscured by another element, an element click intercepted error is returned. If the element is outside the viewport, an element not interactable error is returned.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let element be the result of trying to get a known element by reference element id.

  3. If the element is an input element in the file upload state return error with error code invalid argument.

  4. Scroll into view the element’s container.

  5. Wait in an implementation-specific way up to the session implicit wait timeout for the container to become in view.

  6. If element’s container is still not in view, return error with error code element not interactable.

  7. If element’s container is obscured by another element, return error with error code element click intercepted.

  8. Matching on element:

    option element
    1. Let parent node be the element's container.

    2. Fire a mouseOver event at parent node.

    3. Fire a mouseMove event at parent node.

    4. Fire a mouseDown event at parent node.

    5. Run the focusing steps on parent node.

    6. Fire an input event at parent node.

    7. Let previous selectedness be equal to element selectedness.

    8. Set element’s selectedness state to true.

    9. If previous selectedness is false:

      1. Fire a change event at parent node.

    10. Fire a mouseUp event at parent node.

    11. Fire a click event at parent node.

    Otherwise

    Run interaction steps on coordinate.

  9. Wait until the user agent event loop has spun enough times to process the DOM events generated by the previous step.

  10. If the click causes navigation:

    1. Run the post-navigation checks and return its value if it is an error.

    2. Wait for navigation to complete and return its value if it is an error.

    Note that one may not know if a click causes navigation. It is safe to run the post-navigation checks and waiting for the navigation to complete even though navigation did not occur.

  11. Return success with data null.

Element Clear

HTTP Method Path Template
POST /session/{session id}/element/{element id}/clear

The Element Clear command scrolls into view an editable or resettable element and then attempts to clear its selected files or text content.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let element be the result of trying to get a known element with argument element id.

  3. If element is not editable and is not resettable return an error with error code invalid element state.

  4. Scroll into view the element.

  5. Wait in an implementation-specific way up to the session implicit wait timeout for element to become interactable.

  6. If element is not interactable, return error with error code element not interactable.

  7. If element is disabled, read only, or has pointer events disabled, return error with error code invalid element state.

  8. If element is content editable follow the steps required to clear a content editable element. Otherwise, follow the steps required to clear a resettable element.
  9. Return success with data null.

When required to clear a content editable element a remote end must run the following steps:

  1. If element's innerHTML IDL attribute is an empty string do nothing and return.

  2. Run the focusing steps for element.

  3. Set element's innerHTML IDL attribute to an empty string.

  4. Run the unfocusing steps for the element.

When required to clear a resettable element a remote end must run the following steps:

  1. If element's value is an empty string do nothing and return.

  2. Run the focusing steps for element.

  3. Run element's reset algorithm.

  4. Run the unfocusing steps for the element.

Element Send Keys

HTTP Method Path Template
POST /session/{session id}/element/{element id}/value

The Element Send Keys command scrolls into view the form control element and then sends the provided keys to the element. In case the element is not keyboard-interactable, an element not interactable error is returned.

The key input state used for input may be cleared mid-way through “typing” by sending the null key, which is U+E000 (NULL).

When required to clear the modifier key state with an argument of undo actions and keyboard a remote end must run the following steps:

  1. If keyboard is not a key input source return error with error code invalid argument.

  2. For each entry key in the lexically sorted keys of undo actions:

    1. Let action be the value of undo actions matching key entry key.

    2. If action is not an action object of type "key" and subtype "keyUp", return error with error code invalid argument.

    3. Dispatch a keyUp action with arguments action and keyboard’s key input state.

An extended grapheme cluster is typeable if it consists of a single unicode code point and the code is not undefined.

The shifted state for keyboard is the value of keyboard’s key input state’s shift property.

In order to dispatch the events for a typeable string with arguments text and keyboard, a remote end must for each char corresponding to an indexed property in text:

  1. If char is a shifted character and the shifted state of keyboard is false, create a new action object with keyboard's id, "key", and "keyDown", and set its value property to U+E008 ("left shift"). Dispatch a keyDown action with this action object and keyboard's key input state.

  2. If char is not a shifted character and the shifted state of keyboard is true, create a new action object with keyboard's id, "key", and "keyUp", and set its value property to U+E008 ("left shift"). Dispatch a keyUp action with this action object and keyboard's key input state.

  3. Let keydown action be a new action object constructed with arguments keyboard's id, "key", and "keyDown".

  4. Set the value property of keydown action to char

  5. Dispatch a keyDown action with arguments keydown action and keyboard's key input state.

  6. Let keyup action be a copy of keydown action with the subtype property changed to "keyUp".

  7. Dispatch a keyUp action with arguments keyup action and keyboard's key input state.

When required to dispatch a composition event with arguments type and cluster the remote end must perform implementation-specific action dispatch steps equivalent to sending composition events in accordance with the requirements of [[!UI-EVENTS]], and producing the following event with the specified properties.

When required to dispatch actions for a string with arguments text and keyboard, a remote end must run the following steps:

  1. Let clusters be an array created by breaking text into extended grapheme clusters.

  2. Let undo actions be an empty dictionary.

  3. Let current typeable text be an empty string.

  4. For each cluster corresponding to an indexed property in clusters run the substeps of the first matching statement:

    cluster is the null key
    1. Dispatch the events for a typeable string with arguments current typeable text and keyboard. Reset current typeable text to an empty string.

    2. Clear the modifier key state with arguments being undo actions and keyboard.
    3. If the previous step results in an error, return that error.

    4. Reset undo actions to be an empty dictionary.
    cluster is a modifier key
    1. Dispatch the events for a typeable string with arguments current typeable text and keyboard. Reset current typeable text to an empty string.

    2. Let keydown action be an action object constructed with arguments keyboard's id, "key", and "keyDown".

    3. Set the value property of keydown action to cluster.

    4. Dispatch a keyDown action with arguments keydown action and keyboard's key input state.

    5. Add an entry to undo actions with key cluster and value being a copy of keydown action with the subtype modified to "keyUp".

    cluster is typeable
    Append cluster to current typeable text.
    Otherwise
    1. Dispatch the events for a typeable string with arguments current typeable text and keyboard. Reset current typeable text to an empty string.

    2. Dispatch a composition event with arguments "compositionstart" and undefined.

    3. Dispatch a composition event with arguments "compositionupdate" and cluster.

    4. Dispatch a composition event with arguments "compositionend" and cluster.

  5. Dispatch the events for a typeable string with arguments current typeable text and keyboard.

  6. Clear the modifier key state with arguments undo actions and keyboard. If an error is returned, return that error

The remote end steps for Element Send Keys are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Let element be the result of trying to get a known element with argument element id.

  4. Scroll into view the element.

  5. Wait in an implementation-specific way up to the session implicit wait timeout for element to become keyboard-interactable.

  6. If element is not keyboard-interactable, return error with error code element not interactable.

  7. Let text be the result of getting a property text from the parameters argument.

  8. If text is not a string, return an error with error code invalid argument.

  9. If element is not the active element, run the focusing steps for the element.

  10. If element is an input element whose type attribute is File:

    1. Let files be the result of splitting text on the newline ('\n') character.

    2. If files is of 0 length, return an error with error code invalid argument.

    3. Let multiple equal the result of calling hasAttribute("multiple") on element.

    4. if multiple is false and the length of files is not equal to 1 return an error with error code invalid argument.

    5. Verify that each file given by the user exists. If any do not, return error with error code invalid argument.

    6. Complete implementation specific steps equivalent to setting the selected files on the input. If multiple is true files are be appended to element's selected files.

    7. Fire an input event.

    8. Jump to the last step in this overall set of steps.

  11. Let current text length be the element’s length.

  12. Set the text insertion caret using set selection range with using current text length as the 2 parameters passed in.

  13. Let keyboard be a new key input source.

  14. Dispatch actions for a string with arguments text and keyboard.

  15. Remove keyboard from the current session's input state table

  16. Remove keyboard from the list of active input sources.

  17. Return success with data null.

Document Handling

Getting Page Source

HTTP Method Path Template
GET /session/{session id}/source

The Get Page Source command returns a string serialization of the DOM of the current browsing context active document.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts and return its value if it is an error.

  3. Let source be the result returned from the outerHTML IDL Attribute of the document element of the current browsing context active document.

  4. Let source be the result of serializing to string the current browsing context active document, if source is null.

  5. Return success with data source.

Executing Script

When required to JSON deserialize with argument value, and optional argument seen, a remote end must run the following steps:

  1. If seen was not provided, let seen be an empty set.

  2. Jump to the first appropriate step below:

    If value is null, or has type Boolean, Number or String:

    Return success with data value.

    If value is an Object that represents a web element:

    Return the deserialized web element from value.

    If value if value is an Array object or an Object object:

    Return the result of running the clone an object algorithm with arguments value and seen, and the JSON deserialize algorithm as the clone algorithm.

    Otherwise:

    Return error with error code javascript error.

When required to make a JSON clone with argument value, a remote end must run the following steps:

  1. Let seen be an empty set.

  2. Return the result of calling the internal JSON clone algorithm with arguments value and seen.

When required to run the internal JSON clone algorithm with arguments value and seen, a remote end must return the value of the first matching statement, matching on value:

undefined
null

Success with data null.

type Boolean
type Number
type String

Success with data value.

instance of element

If the element is stale, return error with error code stale element reference.

Otherwise, return success with the JSON Serialization of the web element value.

a WindowProxy object

If the associated browsing context of the WindowProxy object in value has been discarded, return error with error code stale element reference.

Otherwise return success with the JSON Serialization of value.

instance of NodeList
instance of HTMLCollection
instance of Array
instance of Object
  1. If value is in seen, return error with error code javascript error.

  2. Add value to seen.

  3. Produce the value of running the clone an object algorithm with arguments value and seen, and the internal JSON clone algorithm as the clone algorithm.

Otherwise

Error with error code javascript error.

When required to clone an object with arguments value and seen and clone algorithm, run the following steps:

  1. Let result be the value of the first matching statement, matching on value:

    instance of NodeList
    instance of HTMLCollection
    instance of Array

    A new Array object, which length property has the result of getting a property named "length" from value.

    Otherwise

    A new Object object.

  2. For each enumerable own property in value, run the following substeps:

    1. Let name be the name of the property.

    2. Let source property value be the result of getting a property named name from value. If doing so causes script to be run, and that script throws an exception, return error with error code javascript error.

    3. Let cloned property result be the result of calling the clone algorithm with arguments source property value and seen.

    4. If cloned property result is a success, set a property of result with name name and value equal to cloned property result’s data.

    5. Otherwise, return cloned property result.

The steps for extracting the script arguments from a request are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let script be the result of getting a property named script from the parameters argument.

  3. If script is not a String, return error with error code invalid argument.

  4. Let args be the result of getting a property named args from the parameters argument.

  5. If args is not an Object or its [[\Class]] internal property is not Array or Object, return error with error code invalid argument.

  6. Let arguments be a List consisting of a json deserialization of each item in args with the order preserved.

  7. Return success with data script and arguments.

The rules to execute a function body are as follows. The algorithm will return success with the JSON representation of the function’s return value, or an error if the evaluation of the function results in a JavaScript exception being thrown or at any point during its execution an unhandled user prompt appears.

If at any point during the algorithm a user prompt appears, the user prompt handler must be invoked. If its return value is an error, it must immediately return with that error and abort all subsequent substeps of this algorithm.

  1. Let window be the associated window of the current browsing context’s active document.

  2. Let environment settings be the environment settings object for window.

  3. Let script environment be the script execution environment for JavaScript obtained from environment settings.

  4. If body is not parsable as a FunctionBody or if parsing detects an early error, return error with error code javascript error.

  5. If body begins with a directive prologue that contains a use strict directive then let strict be true, otherwise let strict be false.

  6. Using the script execution environment script environment, let function be the result of calling create a function object with parameter list of an empty List, body body, scope of the global environment, and strict flag strict.

  7. Let script be a new script.

  8. Let script’s code entry-point be function.

  9. Let script’s settings object object be script settings.

  10. Invoke the [[\Call]] internal method of function, providing window as the this value and parameters as the argument values. If doing so does not produce an exception, let result be success with data set to the return value from this function call. Otherwise let result be error with error code javascript error.

  11. If result is an error, return result.

  12. Otherwise let json data be a JSON clone of result’s data.

  13. Return success with data json data.

Execute Script

HTTP Method Path Template
POST /session/{session id}/execute/sync

The Execute Script command executes a JavaScript function in the context of the current browsing context and returns the return value of the function.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Let script arguments be the result of extracting the script arguments from a request with argument parameters.

  4. If script arguments is an error, return script arguments.

  5. Let body and arguments be script arguments’ data.

  6. Let promise be a new Promise.

  7. Run the following substeps in parallel:

    1. Let result be the result of promise-calling execute a function body, with arguments body and arguments.

    2. If result is an error, reject promise with result.

  8. If promise is still pending and session script timeout milliseconds is reached, reject promise with error with error code script timeout.

  9. Upon fulfillment of promise with value v, return success with data v.

  10. Upon rejection of promise with reason r, if r is an error, return r. Otherwise, return error with error code javascript error and data r.

Execute Async Script

HTTP Method Path Template
POST /session/{session id}/execute/async

The Execute Async Script command causes JavaScript to execute as an anonymous function. Unlike the Execute Script command, the result of the function is ignored. Instead an additional argument is provided as the final argument to the function. This is a function that, when called, returns its first argument as the response.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Let script arguments be the result of extracting the script arguments from a request with argument parameters.

  4. If script arguments is an error, return script arguments.

  5. Let body and arguments be script arguments’ data.

  6. Let promise be a new Promise.

  7. Run the following substeps in parallel:

    1. Append resolve to script arguments.

    2. Let result be the result of promise-calling execute a function body, with arguments body and arguments.

    3. If result is an error, reject promise with result.

  8. If promise is still pending and session script timeout milliseconds is reached, reject promise with error with error code script timeout.

  9. Upon fulfillment of promise with value v, return success with data v.

  10. Upon rejection of promise with reason r, if r is an error, return r. Otherwise, return error with error code javascript error and data r.

The execute async script callback algorithm is initialized with a single argument webdriver callback state. It defines a function with a single optional argument result. When this function is called, the following steps are run:

  1. If webdriver callback state is not in the unset state, return undefined.

  2. If result is not present, let result be null.

  3. Let json result be a JSON clone of result.

  4. Set the webdriver callback state to set with data json result.

  5. Return undefined.

Cookies

This section describes the interaction with cookies as described in [[!RFC6265]].

A cookie is described in [[!RFC6265]] by a name-value pair holding the cookie’s data, followed by zero or more attribute-value pairs describing its characteristics.

The following table for cookie conversion defines the cookie concepts relevant to WebDriver, how these are referred to in [[!RFC6265]], what keys they map to in a serialised cookie, as well as the attribute-value keys needed when constructing a list of arguments for creating a cookie.

For informational purposes, the table includes a legend of whether the field is optional in the serialised cookie provided to Add Cookie, and a brief non-normative description of the field and the expected input type of its associated value.

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.

A serialised cookie is a JSON Object where a cookie’s [[!RFC6265]] fields listed in the table for cookie conversion are mapped using the JSON Key and the associated field’s value from the cookie store. The optional fields may be omitted.

To get all associated cookies to a document, the user agent must return the enumerated set of cookies that meet the requirements set out in the first step of the algorithm in [[RFC6265]] to compute cookie-string for an ‘HTTP API’, from the cookie store of the given document’s address.

When the remote end is instructed to create a cookie, this is synonymous to carrying out the steps described in [[!RFC6265]] section 5.3, under receiving a cookie, except the user agent may not ignore the received cookie in its entirety (disregard step 1).

To delete cookies given an optional filter argument name that is a string:

  1. For each cookie among all associated cookies of the current browsing context’s active document, run the substeps of the first matching condition:

    name is undefined
    name is equal to cookie name

    Set the cookie expiry time to a Unix timestamp in the past.

    Otherwise
    Do nothing.

Get All Cookies

HTTP Method Path Template
GET /session/{session id}/cookie

The Get All Cookies command returns all cookies associated with the address of the current browsing context’s active document.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Let cookies be a JSON List containing all associated cookies of the current browsing context’s active document.

  4. Return success with data cookies.

Get Named Cookie

HTTP Method Path Template
GET /session/{session id}/cookie/{name}

The Get Named Cookie command returns the cookie with the requested name from the associated cookies in the cookie store of the current browsing context’s active document. If no cookie is found, a no such cookie error is returned.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. If the name matches a cookie’s cookie name amongst all associated cookies of the current browsing context’s active document, return success with the serialised cookie as data.

    Otherwise, return error with error code no such cookie.

Add Cookie

HTTP Method Path Template
POST /session/{session id}/cookie

The Add Cookie command adds a single cookie to the cookie store associated with the active document’s address.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. If the current browsing context’s document element is a cookie-averse Document object, return error with error code invalid cookie domain.

  4. Let data be the result of getting a property named cookie from the parameters argument.

  5. If data is not a JSON Object with all the required (non-optional) JSON keys listed in the table for cookie conversion, return error with error code invalid argument.

  6. If cookie name or cookie value is null, cookie domain is not equal to the current browsing context’s active document’s domain, cookie secure only or cookie HTTP only are not boolean types, or cookie expiry time is not an integer type, or it less than 0 or greater than 264 – 1, return error with error code invalid argument.

  7. Create a cookie in the cookie store associated with the active document’s address using cookie name name, cookie value value, and an attribute-value list of the following cookie concepts listed in the table for cookie conversion from data:

    Cookie path

    The value if the entry exists, otherwise "/".

    Cookie domain

    The value if the entry exists, otherwise the current browsing context’s active document’s domain.

    Cookie secure only

    The value if the entry exists, otherwise false.

    Cookie HTTP only

    The value if the entry exists, otherwise false.

    Cookie expiry time

    The value if the entry exists, otherwise a Unix timestamp 20 years into the future from now.

    If there is an error during this step, return error with error code unable to set cookie.

  8. Return success with data null.

Delete Cookie

HTTP Method Path Template
DELETE /session/{session id}/cookie/{name}

The Delete Cookie command allows you to delete either a single cookie by parameter name, or all the cookies associated with the active document’s address if name is undefined.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Delete cookies using the name parameter as the filter argument.

  4. Return success with data null.

Delete All Cookies

HTTP Method Path Template
DELETE /session/{session id}/cookie

The Delete All Cookies command allows deletion of all cookies associated with the active document’s address.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts, and return its value if it is an error.

  3. Delete cookies, giving no filtering argument.

  4. Return success with data null.

Actions

Expand these examples

The Actions API provides a low-level interface for providing virtualised device input to the web browser. Conceptually, the Actions commands divide time into a series of ticks. The local end sends a series of actions which correspond to the change in state, if any, of each input device during each tick. For example, pressing a key is represented by an action sequence consisting of a single key input device and two ticks, the first containing a keyDown action, and the second a keyUp action, whereas a pinch-zoom input is represented by an action sequence consisting of a three ticks and two pointer input devices of type touch, each performing a sequence of actions pointerDown, followed by pointerMove, and then pointerUp.

Terminology

An input source is a virtual device providing input events. Each input source has an associated input id, which is a string that identifies the particular device, and a source type which determines the kind of input the device can provide. As with real devices, virtual devices are stateful; this state is recorded in an input source state object associated with each input source.

A null input source is an input source that is not associated with a specific physical device. Null input sources support the following actions:

Action Non-normative Description
pause Used with an integer argument to specify the duration of a tick, or as a placeholder to indicate that an input source does nothing during a particular tick.

A key input source is an input source that is associated with a keyboard-type device. A key input source supports the same pause action as a null input source plus the following actions:

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.

A pointer input source is an input source that is associated with a pointer-type input device. Such an input source has an associated pointer type specifying exactly which kind of pointing device it is associated with. A pointer input source supports the same pause action as a null input source plus the following actions:

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.

Each session maintains a list of active input sources. This list is initially empty. When an input source is added to the list of active input sources, a corresponding entry is made in the input state table where the key is the input source's input id and the value is the input source's input source state. When an input source is removed from the list of active input sources, the corresponding entry in the input state table is also removed.

A tick is the basic unit of time over which actions can be performed. During a tick, each input source has an assigned action — possibly a noop pause action — which may result in changes to the user agent internal state and eventually cause DOM events to be fired at the page. The next tick begins after the user agent has had a chance to process all DOM events generated in the current tick.

Waiting asynchronously means waiting for something to occur whilst allowing the browser to continue processing the event loop.

At the lowest level, the behavior of actions is intended to mimic the remote end's behavior with an actual input device as closely as possible, and the implementation strategy may involve e.g. injecting synthesized events into a browser event loop. Therefore the steps to dispatch an action will inevitably end up in implementation-specific territory. However there are certain content observable effects that must be consistent across implementations. To accomodate this, the specification requires that remote ends perform implementation-specific action dispatch steps, along with a list of events and their properties. This list is not comprehensive; in particular the default action of the input source may cause additional events to be generated depending on the implementation and the state of the browser (e.g. input events relating to key actions when the focus is on an editable element, scroll events, etc.).

Input Source State

The objects and properties defined in this section are spec-internal constructs and do not correspond to ECMAScript objects. For convenience the same terminology is used for their manipulation.

"Input source state" is used as a generic term to describe the state associated with each input source.

The corresponding input source state type for a label action type is given by the following table:

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

A null input source's input source state is a null input state. This is always an empty object.

A key input source's input source state is a key input state object. This is an object with a property, pressed, which is a set of strings representing currently pressed keys and properties alt, shift, ctrl, and meta, which are Booleans.

When required to create a new key input state object, an implementation must return a key input state object with the pressed property set to the empty set and alt, shift, ctrl, and meta all set to false.

A pointer input source's input source state is a pointer input state object. This consists of a subtype property, which has the possible values "mouse", "pen", and "touch", a pressed property which is a set of unsigned integers, an x property which is an unsigned integer, and a y property which is an unsigned integer.

When required to create a new pointer input state object with arguments subtype an implementation must return a pointer input state object with subtype set to subtype, pressed set to an empty set and both x and y set to 0.

Each session has an associated input state table. This is a map between input id and the input source state for that input source, with one entry for each item in the list of active input sources.

Each session also has an associated input cancel list, which is a list of actions. This list is used to manage dispatching events when resetting the state of the input sources. For simplicity the algorithms described here only append actions to the list and rely on the fact that the reset operations are idempotent.

Processing Actions Requests

The algorithm for extracting an action sequence from a request takes the JSON Object representing an action sequence, validates the input, and returns a data structure that is the transpose of the input JSON, such that the actions to be performed in a single tick are grouped together.

When required to extract an action sequence with argument parameters, a remote end must run the following steps:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let actions be the result of getting a property from parameters named actions.

  3. If actions is undefined or is not an Array, return error with error code invalid argument.

  4. Let actions by tick be an empty List.

  5. For each value action sequence corresponding to an indexed property in actions:

    1. Let input source actions be the result of trying to process an input source action sequence with argument action sequence.

    2. For each action in input source actions:

      1. Let i be the zero-based index of action in input source actions.

      2. If the length of actions by tick is less than i + 1, append a new List to actions by tick.

      3. Append action to the List at index i in actions by tick.

  6. Return success with data actions by tick.

When required to process an input source action sequence, with argument action sequence, a remote end must run the following steps:

  1. Let type be the result of getting a property named type from actions sequence.

  2. If type is not "key", "pointer", or "none", return an error with error code invalid argument.

  3. Let id be the result of getting a property named id from action sequence.

  4. If id is undefined or is not a String return error with error code invalid argument.

  5. If type is equal to "pointer", let parameters data be the result of getting a property named parameters from action sequence. Then let parameters be the result of trying to process pointer parameters with argument parameters data.

  6. Let source be the input source in the list of active input sources where that input source's input id matches id, or undefined is there is no matching input source.

  7. If source is undefined:

    1. Let source be a new input source created from the first match against type:
      "none"
      Create a new null input source.
      "key"
      Create a new key input source.
      "pointer"
      Create a new pointer input source. Let the new input source's pointer type be set to the value of parameters's pointerType property.
    2. Add source to the current session's list of active input sources.

    3. Add source's input source state to the current session's input state table, keyed on source's input id.

  8. If source's source type does not match type return an error with error code invalid argument.

  9. If parameters is not undefined, then if its pointerType property does not match source's pointer type return an error with error code invalid argument.

  10. Let action items be the result of getting a property named actions from action sequence.

  11. If action items is not an Array, return error with error code invalid argument.

  12. Let actions be a new list.

  13. For each action item in action items:

    1. If action item is not an Object return error with error code invalid argument.

    2. If type is "none" let action be the result of trying to process a null action with parameters id, and action item.

    3. Otherwise, if type is "key" let action be the result of trying to process a key action with parameters id, and action item.

    4. Otherwise, if type is "pointer" let action be the result of trying to process a pointer action with parameters id, parameters, and action item.

    5. Append action to actions.

  14. Return success with data actions.

The default pointer parameters consist of an object with property pointerType set to mouse.

When required to process pointer parameters with argument parameters data, a remote end must perform the following steps:

  1. Let parameters be the default pointer parameters.

  2. If parameters data is undefined, return success with data parameters.

  3. If parameters data is not an Object return error with error code invalid argument.

  4. Let pointer type be the result of getting a property named pointerType from parameters data.

  5. If pointer type is not undefined:

    1. If pointer type does not have one of the values "mouse", "pen", or "touch" return error with error code invalid argument.

    2. Set the pointerType property of parameters to pointer type.

  6. Return success with data parameters.

An action object constructed with arguments id, type, and subtype is an object with property id set to id, type set to type and subtype set to subtype. Specific action objects have further properties added by other algorithms in this specification.

When required to process a null action with arguments id and action item, a remote end must perform the following steps:

  1. Let subtype be the result of getting a property named type from action item.

  2. If subtype is not "pause" return error with error code invalid argument.

  3. Let action be an action object constructed with arguments id, "none", and subtype.

  4. Let result be the result of trying to process a pause action with arguments action item, and action.

  5. Return result.

When required to process a key action with arguments id and action item, a remote end must perform the following steps:

  1. Let subtype be the result of getting a property named type from action item.

  2. If subtype is not one of the values "keyUp", "keyDown", or "pause", return an error with error code invalid argument.

  3. Let action be an action object constructed with arguments id, "key", and subtype.

  4. If subtype is "pause"; let result be the result of trying to process a pause action with arguments action item, and action, and return result.

  5. Let key be the result of getting a property named value from action item.

  6. If key is not a String containing a single unicode code point or grapheme cluster? return error with error code invalid argument.

  7. Set the value property on action to key.

  8. Return success with data action.

When required to process a pointer action with arguments id, parameters, and action item, a remote end must perform the following steps:

  1. Let subtype be the result of getting a property named type from action item.

  2. If subtype is not one of the values pause, "pointerUp", "pointerDown", "pointerMove", or "pointerCancel" return an error with error code invalid argument.

  3. Let action be an action object constructed with arguments id, "pointer", and subtype.

  4. If subtype is "pause"; let result be the result of trying to process a pause action with arguments action item, and action, and return result.

  5. Set the pointerType property of action equal to the pointerType property of parameters.

  6. If subtype is "pointerUp" or "pointerDown", process a pointer up or pointer down action with arguments action item, and action. If doing so results in an error, return that error.

  7. If subtype is "pointerMove" process a pointer move action with arguments action item, and action. If doing so results in an error, return that error.

  8. If subtype is "pointerCancel" process a pointer cancel action. If doing so results in an error, return that error.

  9. Return success with data action.

When required to process a pause action with arguments action item, and action, a remote end must run the following steps:

  1. Let duration be the result of getting a property named duration from action item.

  2. If duration is not undefined and duration is not an Integer greater than or equal to 0, return error with error code invalid argument.

  3. Set the duration property of action to duration.

  4. Return success with data action.

When required to process a pointer up or pointer down action with arguments action item, and action, a remote end must run the following steps:

  1. Let button be the result of getting a property named button from action item.

  2. If button is not an Integer greater than or equal to 0 return error with error code invalid argument.

  3. Set the button property of action to button.

  4. Return success with data null.

When required to process a pointer move action with arguments action item, and action, a remote end must run the following steps:

  1. Let duration be the result of getting a property named duration from action item.

  2. If duration is not undefined and duration is not an Integer greater than or equal to 0, return error with error code invalid argument.

  3. Set the duration property of action to duration.

  4. Let origin be the result of getting a property named origin from action item.

  5. If origin is undefined let origin equal "viewport".

  6. If origin is not equal to "viewport" or "pointer" and origin is not an Object that represents a web element, return error with error code invalid argument.

  7. Set the origin property of action to origin.

  8. Let x be the result of getting a property named x from action item.

  9. If x is not undefined or is not an Integer return error with error code invalid argument.

  10. Set the x property of action to x.

  11. Let y be the result of getting a property named y from action item.

  12. If y is not undefined or is not an Integer return error with error code invalid argument.

  13. Set the y property of action to y.

  14. Return success with data null.

Dispatching Actions

The algorithm to dispatch actions takes a list of actions grouped by tick, and then causes each action to be run at the appropriate point in the sequence.

When asked to dispatch actions with argument actions by tick, a remote end must run the following steps:

  1. For each item tick actions in actions by tick:

    1. Let tick duration be the result of computing the tick duration with argument tick actions.

    2. Dispatch tick actions with arguments tick actions and tick duration. If this results in an error return that error.

    3. Wait until the following conditions are all met:

      • There are no pending asynchronous waits arising from the last invocation of the dispatch tick actions steps.

      • The user agent event loop has spun enough times to process the DOM events generated by the last invocation of the dispatch tick actions steps.

      • At least tick duration milliseconds have passed.

  2. Return success with data null.

When required to compute the tick duration with argument tick actions, a remote end must take the following steps:

  1. Let max duration be 0.

  2. For each action object in tick actions:

    1. let duration be undefined.

    2. If action object has subtype property set to "pause" or action object has type property set to "pointer" and subtype property set to "pointerMove", let duration be equal to the duration property of action object.

    3. If duration is not undefined, and duration is greater than max duration let max duration be equal to duration.

  3. Return max duration.

When required to dispatch tick actions with arguments tick actions and tick duration, a remote end must run the following steps:

  1. For each action object in tick actions:

    1. Let source id be equal to the value of action object's id property.

    2. Let source type be equal to the value of action object's type property.

    3. If the current session's input state table doesn't have a property corresponding to source id, then let the property corresponding to source id be a new object of the corresponding input source state type for source type.

    4. Let device state be the input source state corresponding to source id in the current session’s input state table.

    5. Let algorithm be the value of the column dispatch action algorithm from the following table of dispatch action algorithms that matches the source type and the action object's subtype property, to a dispatch action algorithm.

      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
  2. Return the result of running algorithm with arguments source id, action object, device state and tick duration.

General Actions

When required to dispatch a pause action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Return success with data null.

Keyboard Actions

The normalised key value for a raw key key is, if key appears in the table below, the string value in the second column on the row containing key's unicode code point in the first column, otherwise it is key.

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"

The code for key is the value in the last column of the following table on the row with key in either the first or second column, if any such row exists, otherwise it is undefined.

A shifted character is one that appears in the second column of the following table.

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"

The key location for key is the value in the last column in the table below on the row with key appears in the first column, if such a row exists, otherwise it is 0.

key's codepoint Description Location
\uE007Enter1
\uE008Left Shift1
\uE009Left Control1
\uE00ALeft Alt1
\uE01ANumpad 03
\uE01BNumpad 13
\uE01CNumpad 23
\uE01DNumpad 33
\uE01ENumpad 43
\uE01FNumpad 53
\uE020Numpad 63
\uE021Numpad 73
\uE022Numpad 83
\uE023Numpad 93
\uE024Numpad *3
\uE025Numpad +3
\uE026Numpad ,3
\uE027Numpad -3
\uE028Numpad .3
\uE029Numpad /3
\uE03DLeft Meta1
\uE050Right Shift2
\uE051Right Control2
\uE052Right Alt2
\uE053Right Meta2
\uE054Numpad PageUp3
\uE055Numpad PageDown3
\uE056Numpad End3
\uE057Numpad Home3
\uE058Numpad ArrowLeft3
\uE059Numpad ArrowUp3
\uE05ANumpad ArrowRight3
\uE05BNumpad ArrowDown3
\uE05CNumpad Insert3
\uE05DNumpad Delete3

When required to dispatch a keyDown action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Let raw key be equal to\ action object's value property.

  2. Let key be equal to the normalised key value for raw key.

  3. If the input state's pressed property contains key, let repeat be true, otherwise let repeat be false.

  4. Let code be the code for raw key.

  5. Let location be the key location for raw key.

  6. Let charCode, keyCode and which be the implementation-specific values of the charCode, keyCode and which properties appropriate for a key with key key and location location on a 102 key US keyboard, following the guidelines in [[!UI-EVENTS]].

  7. If key is "Alt", let device state's alt property be true.

  8. If key is "Shift", let device state's shift property be true.

  9. If key is "Control", let device state's ctrl property be true.

  10. If key is "Meta", let device state's meta property be true.

  11. Add key to the set corresponding to input state's pressed property.

  12. Append a copy of action object with the subtype property changed to keyUp to current session's input cancel list.

  13. Perform implementation-specific action dispatch steps equivalent to pressing a key on the keyboard in accordance with the requirements of [[!UI-EVENTS]], and producing the following events, as appropriate, with the specified properties. This will always produce events including at least a keyDown event.

    • keyDown with properties:
      Attribute Value
      keykey
      codecode
      locationlocation
      altKeydevice state's alt property
      shiftKeydevice state's shift property
      ctrlKeydevice state's ctrl property
      metaKeydevice state's meta property
      repeatrepeat
      isComposingfalse
      charCodecharCode
      keyCodekeyCode
      whichwhich
    • keyPress with properties:
      Attribute Value
      keykey
      codecode
      locationlocation
      altKeydevice state's alt property
      shiftKeydevice state's shift property
      ctrlKeydevice state's ctrl property
      metaKeydevice state's meta property
      repeatrepeat
      isComposingfalse
      charCodecharCode
      keyCodekeyCode
      whichwhich
  14. Return success with data null.

When required to dispatch a keyUp action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Let raw key be equal to action object's value property.

  2. Let key be equal to the normalised key value for raw key.

  3. If the input state's pressed property does not contain key, return.

  4. Let code be the code for raw key.

  5. Let location be the key location for raw key.

  6. Let charCode, keyCode and which be the implementation-specific values of the charCode, keyCode and which properties appropriate for a key with key key and location location on a 102 key US keyboard, following the guidelines in [[!UI-EVENTS]].

  7. If key is "Alt", let device state's alt property be false.

  8. If key is "Shift", let device state's shift property be false.

  9. If key is "Control", let device state's ctrl property be false.

  10. If key is "Meta", let device state's meta property be false.

  11. Remove key from the set corresponding to input state's pressed property.

  12. Perform implementation-specific action dispatch steps equivalent to releasing a key on the keyboard in accordance with the requirements of [[!UI-EVENTS]], and producing at least the following events with the specified properties:

    • keyup, with properties:
      Attribute Value
      keykey
      codecode
      locationlocation
      altKeydevice state's alt property
      shiftKeydevice state's shift property
      ctrlKeydevice state's ctrl property
      metaKeydevice state's meta property
      repeatfalse
      isComposingfalse
      charCodecharCode
      keyCodekeyCode
      whichwhich
  13. Return success with data null.

Pointer Actions

When required to dispatch a pointerDown action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Let pointerType be equal to action object's pointerType property.

  2. Let button be equal to action object's button property.

  3. If the input state's pressed property contains button return success with data null.

  4. Let x be equal to input state's x property.

  5. Let y be equal to input state's y property.

  6. Add button to the set corresponding to input state's pressed property, and let buttons be the resulting value of that property.

  7. Append a copy of action object with the subtype property changed to pointerUp to the current session's input cancel list.

  8. Perform implementation-specific action dispatch steps equivalent to pressing the button numbered button on the pointer with ID source id, having type type pointerType at viewport x coordinate x, viewport y coordinate y, with buttons buttons depressed in accordance with the requirements of [[!UI-EVENTS]] and [[!POINTER-EVENTS]]. Type specific properties for the pointer that are not exposed through the webdriver API must be set to the default value specified for hardware that doesn't support that property.

  9. Return success with data null.

When required to dispatch a pointerUp action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Let pointerType be equal to action object's pointerType property.

  2. Let button be equal to action object's button property.

  3. If the input state's pressed property does not contain button return success with data null.

  4. Let x be equal to action object's x property.

  5. Let y be equal to action object's y property.

  6. Remove button from the set corresponding to input state's pressed property, and let buttons be the resulting value of that property.

  7. Perform implementation-specific action dispatch steps equivalent to releasing the button numbered button on the pointer of ID source id having type type pointerType at viewport x coordinate x, viewport y coordinate y, with buttons buttons depressed, in accordance with the requirements of [[!UI-EVENTS]] and [[!POINTER-EVENTS]]. Type specific properties for the pointer that are not exposed through the webdriver API must be set to the default value specified for hardware that doesn't support that property.

  8. Return success with data null.

When required to dispatch a pointerMove action with arguments source id, action object, input state and tick duration a remote end must runthe following steps:

  1. Let x offset be equal to the x property of action object.

  2. Let y offset be equal to the y property of action object.

  3. Let start x be equal to the x property of input state.

  4. Let start y be equal to the y property of input state.

  5. Let origin be equal to the origin property of action object.

  6. Run the substeps of the first matching value of origin:

    "viewport"

    Let x equal x offset and y equal y offset.

    "pointer"

    Let x equal start x + x offset and y equal start y + y offset.

    An object that represents a web element
    1. Let element be equal to the result of trying to get a known element with argument origin.

    2. Let x element and y element be the result of calculating the in-view center point of element.

    3. Let x equal x element + x offset, and y equal y element + y offset.

  7. If x is less than 0 or greater than the width of the viewport in CSS reference pixels, then return error with error code move target out of bounds.

  8. If y is less than 0 or greater than the height of the viewport in CSS reference pixels, then return error with error code move target out of bounds.

  9. Let duration be equal to action object's duration property if it is not undefined, or tick duration otherwise.

  10. If duration is greater than 0 and inside any implementation-defined bounds, asynchronously wait for an implementation defined amount of time to pass.

  11. Perform a pointer move with arguments source id, input state, duration, start x, start y, x, y.

When required to perform a pointer move with arguments source id, input state, duration, start x, start y, target x and target y, an implementation must run the following steps:

  1. Let subtype equal the subtype property of input state.

  2. Let time delta be the time since the beginning of the current tick, measured in milliseconds on a monotonic clock.

  3. Let duration ratio be the ratio of time deta and duration, if duration is greater than 0, or 1 otherwise.

  4. If duration ratio is 1, or close enough to 1 that the implementation will not further subdivide the move action, let last be true. Otherwise let last be false.

  5. If last is true, let x equal target x and y equal target y.

    Otherwise let x equal an approximation to duration ratio × (target x - start x) + start x, and y equal an approximation to duration ratio × (target y - start y) + start y.

  6. Let current x equal the x property of input state.

  7. Let current y equal the y property of input state.

  8. If x is not equal to current x or y is not equal to current y, run the following steps:

    1. Let buttons be equal to input state's buttons property.

    2. Perform implementation-specific action dispatch steps equivalent to moving the pointer with ID source id having type pointerType from viewport x coordinate current x, viewport y coordinate y to viewport x coordinate x and viewport y coordinate y, with buttons buttons depressed, in accordance with the requirements of [[!UI-EVENTS]] and [[!POINTER-EVENTS]], Type specific properties for the pointer that are not exposed through the WebDriver API must be set to the default value specified for hardware that doesn't support that property. In the case where the pointerType is "pen" or "touch", and buttons is empty, this may be a no-op. For a pointer of type "mouse", this will always produce events including at least a pointerMove event.

    3. Let input state's x property equal x and y property equal y.

  9. If last is true, return.

  10. Asynchronously wait for an implementation defined amount of time to pass.

  11. Perform a pointer move with arguments source id, input state, duration, start x, start y, target x, target y.

When required to dispatch a pointerCancel action with arguments source id, action object, input state and tick duration a remote end must run the following steps:

  1. Perform implementation-specific action dispatch steps equivalent to cancelling the any action of the pointer with ID source id having type pointerType, in accordance with the requirements of [[!UI-EVENTS]] and [[!POINTER-EVENTS]].

Perform Actions

HTTP Method Path Template
POST /session/{session id}/actions

Payload Format

This section is non-normative.

Remote End Steps

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Handle any user prompts. If this results in an error, return that error.

  3. Let actions by tick be the result of trying to extract an action sequence with argument parameters.

  4. Dispatch actions with argument actions by tick. If this results in an error return that error.

  5. Return success with data null.

Release Actions

HTTP Method Path Template
DELETE /session/{session id}/actions

The Release Actions command is used to release all the keys and pointer buttons that are currently depressed. This causes events to be fired as if the state was released by an explicit series of actions. It also clears all the internal state of the virtual devices.

The remote end steps are:

  1. Let undo actions be equal to the current session's input cancel list in reverse order.

  2. Dispatch tick actions with arguments undo actions and duration 0.

  3. Let the current session's input cancel list be an empty List.

  4. Let the current session's input state table be an empty map.

  5. Let the current session's active input sources be an empty list.

  6. Return success with data null.

User Prompts

This chapter describes interaction with various types of user prompts. The common denominator for user prompts is that they are modal windows requiring users to interact with them before the event loop is unpaused and control is returned to the current top-level browsing context.

By default user prompts are not handled automatically unless a user prompt handler has been defined. When a user prompt appears, it is the task of the subsequent command to handle it. If the subsequent requested command is not one listed in this chapter, an unexpected alert open error will be returned.

User prompts that are spawned from beforeunload event handlers, are dismissed implicitly upon navigation or or close window, regardless of the defined user prompt handler.

The following table of simple dialogs enumerates all supported simple dialogs, along with the commands that are allowed to interact with it as a non-normative reference:

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

The current user prompt is said to be the active user prompt, which can be one of the entries on the table of simple dialogs, or the window.print dialog.

To dismiss the current user prompt, do so as if the user would click the Cancel or OK button, whichever is present, in that order.

To accept the current user prompt, do so as if the user would click the OK button.

A user prompt handler is an enumerated attribute defining what action the remote end must take when a user prompt is encountered. This is defined by the unhandled prompt behavior capability. The following known prompt handling approaches table lists the keywords and states for the attribute:

Keyword State Description
"dismiss" Dismiss state All simple dialogs encountered should be dismissed.
"accept" Accept state All simple dialogs encountered should be accepted.

When required to deserialize as an unhandled prompt behavior an argument value:

  1. If value is not a string return an error with error code invalid argument.

  2. If value is not present as a keyword in the known prompt handling approaches table return an error with error code invalid argument.

  3. Return success with data value.

In order to handle any user prompts a remote end must take the following steps:

  1. If there is no current user prompt, abort these steps and return success.

  2. Run the substeps of the first matching user prompt handler:

    dismiss state

    Dismiss the current user prompt.

    accept state

    Accept the current user prompt.

    missing value default state
    not in the table of simple dialogs
    1. Dismiss the current user prompt.

    2. Return error with error code unexpected alert open.

  3. Return success.

When returning an error with unexpected alert open, a remote end may return the current text (as if returned by Get Alert Text) of the prompt as the value of the text key in the JSON Object that is the value of the data key in the error response, as shown in this non-normative example:

{
    error: "unexpected alert open",
    message: "implementation defined",
    data: {
        text: "the text from the alert"
    }
}

Dismiss Alert

HTTP Method Path Template
POST /session/{session id}/alert/dismiss

The Dismiss Alert command dismisses a simple dialog if present. A request to dismiss an alert user prompt, which may not necessarily have a dismiss button, has the same effect as accepting it.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. If there is no current user prompt, return error with error code no such alert.

  3. Dismiss the current user prompt.

  4. Return success with data null.

Accept Alert

HTTP Method Path Template
POST /session/{session id}/alert/accept

The Accept Alert command accepts a simple dialog if present.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. If there is no current user prompt, return error with error code no such alert.

  3. Accept the current user prompt.

  4. Return success with data null.

Get Alert Text

HTTP Method Path Template
GET /session/{session id}/alert/text

The Get Alert Text command returns the message of the current user prompt. If there is no current user prompt, it returns an error.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. If there is no current user prompt, return error with error code no such alert.

  3. Let message be the text message associated with the current user prompt, or otherwise be null.

  4. Return success with data message.

Send Alert Text

HTTP Method Path Template
POST /session/{session id}/alert/text

The Send Alert Text command sets the text field prompt to a given value, and only makes sense on window.prompt.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. If there is no current user prompt, return error with error code no such alert.

  3. Run the substeps of the first matching current user prompt:

    alert
    confirm

    Return error with error code element not interactable.

    prompt

    Do nothing.

    Otherwise

    Return error with error code unsupported operation.

  4. Let character array be the result of getting a property value from the parameters argument.

  5. Let text be the result of joining together each item in character array to a string.

  6. Set the current user prompt’s text field value to the value of text.

  7. Return success with data null.

Screen Capture

Screenshots are a mechanism for providing additional visual diagnostic information. They work by dumping a snapshot of the initial viewport’s framebuffer as a lossless PNG image. It is returned to the local end as a Base64 encoded string.

WebDriver provides the Take Screenshot command to capture the top-level browsing context’s initial viewport, and a command Take Element Screenshot for doing the same with the visible region of an element’s bounding rectangle after it has been scrolled into view.

In order to draw a bounding box from the framebuffer, given a rectangle:

  1. If either the initial viewport’s width or height is 0 CSS reference pixels, return error with error code unable to capture screen.

  2. Let paint width be the initial viewport’s width – min(rectangle x coordinate, rectangle x coordinate + rectangle width dimension).

  3. Let paint height be the initial viewport’s height – min(rectangle y coordinate, rectangle y coordinate + rectangle height dimension).

  4. Let canvas be a new canvas element, and set its width and height to paint width and paint height, respectively.

  5. Let context, a canvas context mode, be the result of invoking the 2D context creation algorithm given canvas as the target.

  6. Complete implementation specific steps equivalent to drawing the region of the framebuffer specified by the following coordinates onto context:

    X coordinate
    rectangle x coordinate
    Y coordinate
    rectangle y coordinate
    Width
    paint width
    Height
    paint height
  7. Return success with canvas.

To encode as Base64 a canvas element:

  1. If the canvas element’s bitmap’s origin-clean flag is set to false, return error with error code unable to capture screen.

  2. If the canvas element’s bitmap has no pixels (i.e. either its horizontal dimension or vertical dimension is zero) then return error with error code unable to capture screen.

  3. Let file be a serialization of the canvas element’s bitmap as a file, using "image/png" as an argument.

  4. Let data url be a data: URL representing file. [[!RFC2397]]

  5. Let index be the index of "," in data url.

  6. Let encoded string be a substring of data url using (index + 1) as the start argument.

  7. Return success with data encoded string.

Take Screenshot

HTTP Method Path Template
GET /session/{session id}/screenshot

The Take Screenshot command takes a screenshot of the top-level browsing context’s viewport.

The remote end steps are:

  1. If the current top-level browsing context is no longer open, return error with error code no such window.

  2. Let root rect be the current top-level browsing context’s document element’s rectangle.
  3. Let screenshot be the result of trying to call draw a bounding box from the framebuffer, given root rect as an argument.

  4. Let canvas be a canvas element of screenshot result’s data.

  5. Let encoding be the result of trying encoding as Base64 canvas.

  6. Let encoded string be encoding result’s data.

  7. Return success with data encoded string.

Take Element Screenshot

HTTP Method Path Template
GET /session/{session id}/element/{element id}/screenshot

The Take Element Screenshot command takes a screenshot of the visible region encompassed by the bounding rectangle of an element. If given a parameter argument scroll that evaluates to false, the element will not be scrolled into view.

The remote end steps are:

  1. If the current browsing context is no longer open, return error with error code no such window.

  2. Let scroll be true if it is undefined.

  3. Let element be the result of trying to get a known element with argument element id.

  4. Let element rect be element’s rectangle.

  5. If asked to scroll, scroll into view the element.

  6. Let screenshot result be the result of calling draw a bounding box from the framebuffer, given element rect as an argument.

  7. If screenshot result is an error, return screenshot result.

  8. Let canvas be a canvas element of screenshot result’s data.

  9. Let encoding result be the result of encoding as Base64 canvas.

  10. If encoding result is an error, return encoding result.

  11. Let encoded string be encoding result’s data.

  12. Return success with data encoded string.

Privacy Considerations

It is advisable that remote ends create a new profile when creating a new session. This prevents potentially sensitive session data from being accessible to new sessions, ensuring both privacy and preventing state from bleeding through to the next session.

Security Considerations

A user agent can rely on a command-line flag or a configuration option to test whether to enable WebDriver, or alternatively make the user agent initiate or confirm the connection through a privileged content document or control widget, in case the user agent does not directly implement the HTTP endpoints.

It is strongly suggested that user agents require users to take explicit action to enable WebDriver, and that WebDriver remains disabled in publicly consumed versions of the user agent.

To prevent arbitrary machines on the network from connecting and creating sessions, it is suggested that only connections from loopback devices are allowed by default.

The remote end can include a configuration option to limit the accepted IP range allowed to connect and make requests. The default setting for this might be to limit connections to the IPv4 localhost CIDR range 127.0.0.0/8 and the IPv6 localhost address ::1. [[!RFC4632]]

It is also suggested that user agents make an effort to visually distinguish a user agent session that is under control of WebDriver from those used for normal browsing sessions. This can be done through a browser chrome element such as a “door hanger”, colorful decoration of the OS window, or some widget element that is prevalent in the window so that it easy to identify automation windows.

Element Displayedness

Although WebDriver does not define a primitive to ascertain the visibility of an element in the viewport, we acknowledge that it is an important feature for many users. Here we include a recommended approach which will give a simplified approximation of an element’s visibility, but please note that it relies only on tree-traversal, and only covers a subset of visibility checks.

The visibility of an element is guided by what is perceptually visible to the human eye. In this context, an element's displayedness does not relate to the visibility or display style properties.

The approach recommended to implementors to ascertain an element's visibility is based on crude approximations about its nature and relationship in the tree. An element is in general to be considered visible if any part of it is drawn on the canvas within the boundaries of the viewport.

When asked to normalize style pixel values to floating point for a value s of the type string:

  1. Let trimmed string be a substring of s where the suffix "px" is removed.

  2. Let pixels be the result of parsing trimmed string as a float.

  3. If pixels is not a float or the previous operation did not succeed, return 0.0.

  4. Round off pixels using a ceiling function so that it has no more than four decimals.

  5. Return pixels.

To normalize style pixel values to floating point is almost equivalent to calling parseFloat from [[!ECMA-262]] with the exception that non-valid float return values are returned as 0.0.

This algorithm is not the same as the one used by Selenium. To provide backwards compatibility, we should change it to be an accurate description of what Selenium does.

The element displayed algorithm is a boolean state where true signifies that the element is displayed and false signifies that the element is not displayed. To compute the state on element:

  1. If the attribute hidden is set, return false.

  2. If the computed value of the display style property is "none", return false.

  3. Not really sure what this means, needs review:

    If it has a [[!CSS3-2D-TRANSFORMS]] or [[!CSS3-3D-TRANSFORMS]] style property that gives a negative X or Y coordinates to the canvas, return false.

  4. If element is the document's root element, that is document.documentElement:

    1. If the computed value of the background-color property is "transparent", run these substeps:

      1. If element is an html element, and the computed value of the background-color style property of the first body element descendant of the element in tree order, relative to that element, is also "transparent", return false. Otherwise return true.

  5. If element is an option element or optgroup element, and element's parent node is a select element:

    1. Apply the element displayed algorithm on element's parent node.

    2. If the return value is false, abort these steps and return that value.

  6. If element is a map element:

    1. Let any images visible be a boolean initially set to false.

    2. For each img element, image element, in the document with a name attribute matching the value of element's usemap attribute, run these substeps:

      1. Run the element displayed algorithm on image element and set any images visible to any images visible bitwise OR its return value.

    3. If any images visible is true, abort these steps and return its value.

  7. If element is an area element:

    1. For each ancestral element parent, in tree order:

      1. If parent is a map element, apply the element displayed algorithm on it.

      2. If the return value is false, abort these steps and return that value.

      3. Otherwise apply step 7.1 on parent.

  8. If element is a text node, return true.

  9. If it has equal to or more than one direct descendant elements:

    1. Let visible children be a boolean initially set to false.

    2. For each direct descendant element child:

      1. Let rectangle be child’s bounding rectangle.

      2. If the value of the height property of rectangle is greater than zero CSS reference pixels, and the value of the width property of rectangle is greater than zero CSS reference pixels:

        1. Set visible children to visible children bitwise OR true.

  10. For each ancestral element parent, in tree order:

    1. Apply the element displayed algorithm to parent.

    2. If the return value is false, abort these steps and return that value.

    3. If parent is a block element box and the computed values of either overflow-x or overflow-y is "hidden":

      1. Let parent dimensions be the rectangle that is the first element of the DOMRect sequence returned by calling getClientRects on parent.

      2. Let element dimensions be the rectangle that is the first element of the DOMRect sequence returned by calling getClientRects on element.

      3. Let parent style be the computed style of parent.

      4. Return false if any the following conditions evaluate to false:

      5. Run step 10 on the parent elements of parent, if any.

  11. Return true.

Acknowledgements

There have been a lot of people that have helped make browser automation possible over the years and thereby furthered the goals of this standard. In particular, thanks goes to the Selenium Open Source community, without which this standard would never have been possible.

This standard is authored by Aleksey Chemakin, Andreas Tolfsen, Andrey Botalov, Clayton Martin, Daniel Wagner-Hall, David Burns, Eran Messeri, Erik Wilde, Gábor Csárdi, James Graham, Jason Juang, Jason Leyba, Jim Evans, John Jansen, Luke Inman-Semerau, Maja Frydrychowicz, Malini Das, Marc Fisher, Ondřej Machulda, Randall Kent, Seva Lotoshnikov, Simon Stewart, Titus Fortner, and Vangelis Katsikaros. The work is coordinated and edited by David Burns and Simon Stewart.

Thanks to Berge Schwebs Bjørlo, Malcolm Rowe, Michael[tm] Smith, Philippe Le Hégaret, Robin Berjon, Ross Patterson, and Wilhelm Joys Andersen for proofreading and suggesting areas for improvement.