WebDriver

1. Conformance

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

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

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

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

Should block navigation response

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]

Keyboard event code tables

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

Keyboard modifier keys

ECMAScript

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

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

The ECMAScript Language Specification also defines the following types, 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]

2D context creation algorithm
A browsing context is discarded
Active document
Active element being the activeElement attribute on Document
A serialization of the bitmap as a file
Associated window
body element
Boolean attribute
Browsing context
Button state
Buttons
Canvas context mode
multiple attribute
Checkbox state
Checkedness
Child browsing context
Close a browsing context
Code entry-point
Cookie-averse Document object
Current entry
Determine the value of an indexed property of a Window object
Disabled
Document address
Document readiness
Document title
Element contexts
Enumerated attribute
Environment settings object
Event loop
File state
File upload state
Focusing steps
Focusable area
Getting innerText
Hidden state
Image Button state
In parallel
input event applies
input event
Selected Files
Joint session history
Mature navigation.
Missing value default state
Navigate
Navigator object
Nested browsing context
Origin-clean
Parent browsing context
HTML Pause
Prompt to unload a document
Radio Button state
Refresh state pragma directive
Replacement enabled
Reset algorithm
Reset Button state
Script execution environment
Script
Selectedness
Session history
setSelectionRange
Settings object
Simple dialogs
Strip leading and trailing whitespace
Submit Button state
Submittable elements
Top-level browsing context
Traverse the history by a delta
Traverse the history
Tree order
unfocusing steps
User prompt
value attribute
Value

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]

Content editable

The following events are also defined in the HTML specification:

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

data: URL

HTTP and related specifications

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

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

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

Status code registry

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

Proxy autoconfiguration

The specification uses URI Templates. [URI-TEMPLATE]

Infra

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

ASCII lower alpha

Page Visibility

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

Document hidden attribute

Styling

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

CSS reference pixels

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

The visibility property

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

Initial viewport, sometimes here referred to as the viewport.

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

The display property

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

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

Computed value

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

Resolved value

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

Element from point as elementFromPoint()
Elements from point as elementsFromPoint()
getClientRects
innerHeight
innerWidth
moveTo(x, y)
offsetLeft
offsetParent
offsetTop
screenX
screenY
scrollIntoView
ScrollIntoViewOptions

SOCKS Proxy and related specification:

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

Unicode

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

Unicode Standard Annex #29

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

Grapheme cluster boundaries

URLs

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

Web IDL

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

Promises Guide

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

XML Namespaces

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

qualified element name

XPATH

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

2. Design Notes

This section is non-normative

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

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

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

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

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

Note

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

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

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

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

6.1 Algorithms

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

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

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

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

The result of getting a property with 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.

6.2 Commands

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

6.3 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:

Issue 1

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

Read bytes from the connection until a complete HTTP request can be constructed from the data. Let request be a request constructed from the received data, according to the requirements of [RFC7230].
Let request match be the result of the algorithm to match a request with request’s method and URL as arguments.
If request match is of type error, send an error with request match’s error code and jump to step 1.

Otherwise, let command and url variables be request match’s data.
Let session id be the corresponding variable from url variables.
If command is not New Session:
1. If session id is not equal to the ID of any session in the list of active sessions, send an error with error code invalid session id, then jump to step 1 in this overall algorithm.
  
  Otherwise, let the current session be the session with ID session id.
If request’s method is POST:
1. Let parse result be the result of parsing as JSON with request’s body as the argument.
2. If parse result is an error or if it is a success but its associated data is not an Object, send an error with error code invalid argument and jump back to step 1 in this overall algorithm.
  
  Otherwise, let parameters be parse result’s data.
Otherwise, let parameters be null.
Wait for navigation to complete. If this returns an error return its value and jump to step 1 in this overall algorithm, otherwise continue.
Let response result be the return value obtained by running the remote end steps for command with url variables as arguments.
If response result is an error, send an error with error code equal to response result’s error code and jump back to step 1 in this overall algorithm.

Otherwise, if response result is a success, let response data be response result’s data.
Send a response with status 200 and response data.
Jump to step 1.

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

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

Let data be a new JSON Object initialised with the following properties:

error

name
message

message
stacktrace

stacktrace
Send a response with status and data as arguments.

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

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

Content-Type

"application/json; charset=utf-8"
Cache-Control

"no-cache"
If data is not null, let response’s body be a JSON Object with a key value set to the JSON serialization of data.
Let response bytes be the byte sequence resulting from serializing response according to the rules in [RFC7230].
Write response bytes to the connection.

6.4 Routing Requests

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

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

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

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

6.5 List of Endpoints

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

Method	URI Template	Command
POST	/session	New Session
DELETE	/session/{`session id`}	Delete Session
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

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

Example 2

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

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

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

Error Code	HTTP Status	JSON Error Code	Description
element 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.

6.7 Protocol Extensions

The protocol is designed to allow extension to meet vendor-specific needs. Commands that are specific to a user agent are called extension commands and behave no differently than other commands; each has a dedicated HTTP endpoint and a set of remote end steps.

Each extension command has an associated extension command name that is 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.

Example 4

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

An example new session request body might look like this:

{
  "capabilities": {
    "alwaysMatch": {
      // a cloud provider’s authentication token
      "sauce:token": "b448b871-a526-4634-aefc-26df6eede519",

      // an intermediary node’s access details
      "intermediary:login": {
        "username": "maja",
        "password": "donut"
      }
    },
    "firstMatch": [
      {
        // browser specific configuration
        "moz:firefoxOptions": {
          "binary": "/usr/bin/firefox",
          "args": ["--no-remote"],
          "prefs": {
            "dom.ipc.processCount": "8"
          },
          "log": {
            "level": "trace"
          }
        }
      }
    ]
  }
}

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

Example 5

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

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

Capability	Key	Value Type	Description
Browser name	"`browserName`"	string	Identifies the user agent.
Browser version	"`browserVersion`"	string	Identifies the version of the user agent.
Platform name	"`platformName`"	string	Identifies the operating system of the endpoint node.
Accept insecure TLS certificates	"`acceptInsecureCerts`"	boolean	Indicates whether untrusted and self-signed TLS certificates are implicitly trusted on navigation for the duration of the session.
Page load strategy	"`pageLoadStrategy`"	string	Defines the current session’s page load strategy.
Proxy configuration	"`proxy`"	JSON Object	Defines the current session’s proxy configuration.
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.

7.1 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

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.

7.2 Timeouts

The session timeouts configuration capability is a JSON Object nested within the capabilities object received when creating a new session. It consists of the properties listed in the table below. These values may be changed after creating a new session using the Set Timeouts command.

Key	Value Type	Description
"`implicit`"	number	Specifies the session implicit wait timeout.
"`page load`"	number	Specifies the session page load timeout.
"`script`"	number	Specifies the session script timeout.

7.3 Processing Capabilities

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

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.
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. If required capabilities is not a JSON Object, return error with error code invalid argument.
Let desired capabilities be the result of getting a property named "firstMatch" from capabilities request.
1. If desired capabilities is undefined, set the value to a JSON List with a single entry of an empty JSON Object.
2. If desired capabilities is not a JSON List, return error with error code invalid argument.
For each current desired capabilities corresponding to an indexed property in desired capabilities:
1. If current desired capabilities is not a JSON Object, return error with error code invalid argument.
2. Let merged capabilities be the result of trying to merge capabilities with required capabilities and current desired capabilities as arguments.
3. Let matched capabilities be the result of matching capabilities with merged capabilities as an argument.
4. Return matched capabilities if it is not null.
Return null.

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

Let result be a JSON Object with the same entries as primary.
If secondary is undefined, return result.
For each key and value of secondary's own properties:
1. Let primary value be the result of getting a property from primary called key.
2. If primary value is not undefined or equal to value return an error with error code invalid argument.
3. Set key with value value on result.
Return result.

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

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

"browserName"

Lowercase name of the user agent.
"browserVersion"

The user agent version, as a string.
"platformName"

Lowercase name of the current platform.
"acceptInsecureCerts"

Boolean initially set to false, indicating the session will not implicitly trust untrusted or self-signed TLS certificates on navigation.
Add any implementation-specific capabilities as entries to matched capabilities

Note

For example, an implementation could choose to indicate that a screenshot will be taken when returning an error by setting the capability selenium.screenshot-on-error to true.

For each capability name corresponding to a property in capabilities:

Let capability value be the value of property capability name in capabilities.

Run the substeps of the first matching capability name:

"browserName"

If capability value is null it is considered a match for the entry in matched capabilities.

Otherwise, if capability value is not a string equal to the "browserName" entry in matched capabilities, return null.

"browserVersion"

If capability value is null it is to be considered a match for the entry in matched capabilities.

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

If the two values do not match, return null.

Note

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.

"platformName"

If capability value is null it is considered a match for the entry in matched capabilities.

Otherwise, if capability value is not a string equal to the "platformName" entry in matched capabilities, return null.

Note

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
linux	Any OS based upon the Linux kernel and X Windows.
mac	Any version of Apple's OS X.
windows	Any version of Microsoft's Windows, including desktop and mobile versions.

This list is not exhaustive.

"acceptInsecureCerts"

If capability value is not a boolean or null, return error with error code invalid argument.

If capability value is true and the endpoint node does not support insecure TLS certificates, return error with error code invalid argument.

Otherwise, set the "acceptInsecureCerts" entry in matched capabilities to capability value with the null value being set to false.

"pageLoadStrategy"

If capability value is not a keyword in the table of page load strategies, return error with error code invalid argument.

Otherwise, set the "pageLoadStrategy" entry in matched capabilities to capability value.

"proxy"

If capability value is not a proxy configuration, return error with error code invalid argument.

If the endpoint node does not support the proxy configuration defined in capability value, return null.

Otherwise, set the "proxy" entry in matched capabilities to capability value.

"timeouts"

If capability value is not a session timeouts configuration object, return error with error code invalid argument.

Otherwise, set the "timeouts" entry in matched capabilities to capability value.

"unhandledPromptBehavior"

If capability value is not a user prompt handler keyword, return error with error code invalid argument.

Otherwise, set the "unhandledPromptBehavior" entry in matched capabilities to capability value.

Otherwise

If capability name is not recognized by the endpoint node, return null.

Let processed value be the result of trying implementation-specific steps to match on capability name with capability value.

Create a new entry in matched capabilities with name capability name and value processed value.

Return matched capabilities.

8. 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 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:

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

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

8.1 New Session

HTTP Method	Path Template
POST	/session

The New Session command creates a new WebDriver session with the endpoint node. If the maximum active sessions has been reached, 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.

Example 6

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

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

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

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

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

Concept	RFC 6265 Field	JSON Key	Attribute Key	Optional	Description
Cookie name	`name`	"`name`"			The name of the cookie.
Cookie value	`value`	"`value`"			The cookie value.
Cookie path	`path`	"`path`"	"`Path`"	✓	The cookie path. Defaults to "`/`" if omitted when adding a cookie.
Cookie domain	`domain`	"`domain`"	"`Domain`"	✓	The domain the cookie is visible to. Defaults to the current browsing context’s 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.

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

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

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

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

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

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

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

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

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

Keyword	State	Description
"`dismiss`"	Dismiss state	All simple dialogs encountered should be dismissed.
"`accept`"	Accept state	All simple dialogs encountered should be accepted.

Abstract

Status of This Document

1. Conformance

1.1 Dependencies

2. Design Notes

2.1 Compatibility

2.2 Simplicity

2.3 Extensions

3. Terminology

4. Interface

5. Nodes

6. Protocol

6.1 Algorithms

6.2 Commands

6.3 Processing Model

6.4 Routing Requests

6.5 List of Endpoints

6.6 Handling Errors

6.7 Protocol Extensions

7. Capabilities

7.1 Proxy

7.2 Timeouts

7.3 Processing Capabilities

8. Sessions

8.1 New Session

8.2 Delete Session

8.3 Status

8.4 Get Timeouts

8.5 Set Timeouts

9. Navigation

9.1 Go

9.2 Get Current URL

9.3 Back

9.4 Forward

9.5 Refresh

9.6 Get Title

10. Command Contexts

10.1 Get Window Handle

10.2 Close Window

10.3 Switch To Window

10.4 Get Window Handles

10.5 Switch To Frame

10.6 Switch To Parent Frame

10.7 Resizing and Positioning Windows

10.7.1 Get Window Rect

10.7.2 Set Window Rect

10.7.3 Maximize Window

10.7.4 Minimize Window

10.7.5 Fullscreen Window

11. Elements

11.1 Element Interactability

11.2 Get Active Element

12. Element Retrieval

12.1 Locator Strategies

12.1.1 CSS Selectors

12.1.2 Link Text

12.1.3 Partial Link Text

12.1.4 Tag Name

12.1.5 XPath

12.2 Find Element

12.3 Find Elements

12.4 Find Element From Element

12.5 Find Elements From Element

13. Element State

13.1 Is Element Selected

13.2 Get Element Attribute

13.3 Get Element Property

13.4 Get Element CSS Value

13.5 Get Element Text

13.6 Get Element Tag Name

13.7 Get Element Rect

13.8 Is Element Enabled

14. Element Interaction

14.1 Element Click

14.2 Element Clear

14.3 Element Send Keys

15. Document Handling

15.1 Getting Page Source

15.2 Executing Script

15.2.1 Execute Script