***

title: Playwright Frame
description: Complete Frame method reference for the Playwright driver.
-----------------------------------------------------------------------

All `Frame` methods available when using the **Playwright** driver.

Access via `frame` after launching a Playwright runtime.

<Accordion title="How these methods work over HTTP">
  Every method below is a remote call. The SDK translates it into a structured step sent to a single endpoint:

  ```
  POST /v1/workspaces/{workspaceId}/execute
  ```

  ```json
  {
    "runtime": "my-browser",
    "steps": [
      {
        "call": "frame.goto",
        "args": ["https://example.com"]
      }
    ]
  }
  ```

  The `call` field maps directly to the method name. `args` is a JSON array of the method's arguments. You can batch multiple steps in one request.
</Accordion>

## Navigation

### goto(url, options?)

Returns the main resource response.

<Note>
  Navigates the frame to the given URL. In case of multiple redirects, the navigation will resolve with the first non-redirect response. The method will throw an error if navigation fails. The method will not throw an error when any valid HTTP status code is returned by the remote server.
</Note>

```ts
await frame.goto('...');
```

| Parameter | Type                    | Required | Description |
| --------- | ----------------------- | -------- | ----------- |
| `url`     | `string`                | Yes      | —           |
| `options` | `PlaywrightGotoOptions` | No       | —           |

**Returns** `SerializedHandle \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-goto)

***

### waitForURL(url, options?)

Waits for the frame to navigate to the given URL.

<Note>
  This method can be used after an action that causes navigation. A glob pattern, regex pattern or predicate receiving URL to match while waiting for the navigation.
</Note>

```ts
await frame.waitForURL(/* url */);
```

| Parameter | Type                                             | Required | Description |
| --------- | ------------------------------------------------ | -------- | ----------- |
| `url`     | `string \| RegExp \| ((url: URL) =&gt; boolean)` | Yes      | —           |
| `options` | `PlaywrightWaitForURLOptions`                    | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-wait-for-url)

***

### waitForLoadState(state?, options?)

Waits for the required load state to be reached.

<Note>
  This method returns when the page reaches a required load state, 'load' by default. The navigation must have been committed when this method is called.
</Note>

```ts
await frame.waitForLoadState();
```

| Parameter | Type                                            | Required | Description                          |
| --------- | ----------------------------------------------- | -------- | ------------------------------------ |
| `state`   | `"load" \| "domcontentloaded" \| "networkidle"` | No       | State to wait for, defaults to load. |
| `options` | `{ timeout?: number }`                          | No       | —                                    |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-wait-for-load-state)

***

## Page Info

### url()

Returns frame's URL.

```ts
await frame.url();
```

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-url)

***

### title()

Returns the page title.

```ts
await frame.title();
```

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-title)

***

### content()

Gets the full HTML contents of the frame, including the doctype.

```ts
await frame.content();
```

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-content)

***

### setContent(html, options?)

Sets the content of the frame.

<Note>
  This method takes the HTML to set as the frame's content. The default waitUntil is 'load'.
</Note>

```ts
await frame.setContent('...');
```

| Parameter | Type                                                                                          | Required | Description |
| --------- | --------------------------------------------------------------------------------------------- | -------- | ----------- |
| `html`    | `string`                                                                                      | Yes      | —           |
| `options` | `{ timeout?: number; waitUntil?: "load" \| "domcontentloaded" \| "networkidle" \| "commit" }` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-set-content)

***

## Actions

### click(selector, options?)

Clicks an element matching selector.

<Note>
  This method waits for actionability checks, scrolls element into view, and then clicks the center of the element. Discouraged: use locator-based locator.click() instead.
</Note>

```ts
await frame.click('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightClickOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-click)

***

### dblclick(selector, options?)

Double-clicks an element matching selector.

<Note>
  This method waits for actionability checks, scrolls element into view, and then double-clicks the center of the element. Discouraged: use locator-based locator.dblclick() instead.
</Note>

```ts
await frame.dblclick('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightClickOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-dblclick)

***

### fill(selector, value, options?)

Fills a form field with text.

<Note>
  This method waits for an element matching selector, waits for actionability checks, focuses the element, fills it and triggers an input event. Discouraged: use locator-based locator.fill() instead.
</Note>

```ts
await frame.fill('...', '...');
```

| Parameter  | Type                    | Required | Description |
| ---------- | ----------------------- | -------- | ----------- |
| `selector` | `string`                | Yes      | —           |
| `value`    | `string`                | Yes      | —           |
| `options`  | `PlaywrightFillOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-fill)

***

### type(selector, text, options?)

Types into an element matching selector.

<Note>
  Sends a keydown, keypress/input, and keyup event for each character in the text. Discouraged: In most cases, you should use locator.fill() instead.
</Note>

```ts
await frame.type('...', '...');
```

| Parameter  | Type                    | Required | Description |
| ---------- | ----------------------- | -------- | ----------- |
| `selector` | `string`                | Yes      | —           |
| `text`     | `string`                | Yes      | —           |
| `options`  | `PlaywrightTypeOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-type)

***

### press(selector, key, options?)

Presses a key.

<Note>
  Focuses the element matching selector, and then uses keyboard.press. Discouraged: use locator-based locator.press() instead.
</Note>

```ts
await frame.press('...', '...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `key`      | `string`                 | Yes      | —           |
| `options`  | `PlaywrightPressOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-press)

***

### hover(selector, options?)

Hovers over an element matching selector.

<Note>
  This method waits for actionability checks, scrolls element into view, and then hovers over the center of the element. Discouraged: use locator-based locator.hover() instead.
</Note>

```ts
await frame.hover('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightHoverOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-hover)

***

### focus(selector, options?)

Fetches the element matching selector and focuses it.

<Note>
  If there is no element matching selector, the method waits until a matching element appears in the DOM. Discouraged: use locator-based locator.focus() instead.
</Note>

```ts
await frame.focus('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightFocusOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-focus)

***

### tap(selector, options?)

Taps an element matching selector.

<Note>
  This method waits for actionability checks, scrolls element into view, and then taps the center of the element. Discouraged: use locator-based locator.tap() instead.
</Note>

```ts
await frame.tap('...');
```

| Parameter  | Type                                                                                                                                                                                            | Required | Description |
| ---------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ----------- |
| `selector` | `string`                                                                                                                                                                                        | Yes      | —           |
| `options`  | `{ force?: boolean; modifiers?: ("Alt" \| "Control" \| "Meta" \| "Shift")[]; noWaitAfter?: boolean; position?: { x: number; y: number }; strict?: boolean; timeout?: number; trial?: boolean }` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-tap)

***

### check(selector, options?)

Checks a checkbox or radio element.

<Note>
  This method checks an element matching selector by performing the following steps: scrolls element into view, and then uses click to check the element. Discouraged: use locator-based locator.check() instead.
</Note>

```ts
await frame.check('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightCheckOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-check)

***

### uncheck(selector, options?)

Unchecks a checkbox element.

<Note>
  This method unchecks an element matching selector by scrolling element into view and using click to uncheck the element. Discouraged: use locator-based locator.uncheck() instead.
</Note>

```ts
await frame.uncheck('...');
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `options`  | `PlaywrightCheckOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-uncheck)

***

### setChecked(selector, checked, options?)

Checks or unchecks a checkbox or radio element.

<Note>
  This method checks or unchecks an element matching selector. Discouraged: use locator-based locator.setChecked() instead.
</Note>

```ts
await frame.setChecked('...', true);
```

| Parameter  | Type                     | Required | Description |
| ---------- | ------------------------ | -------- | ----------- |
| `selector` | `string`                 | Yes      | —           |
| `checked`  | `boolean`                | Yes      | —           |
| `options`  | `PlaywrightCheckOptions` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-set-checked)

***

### selectOption(selector, values, options?)

Selects option(s) in the select element.

<Note>
  Returns array of selected option values. Shortcuts such as "blue" match both value and label. Objects such as \{ label: "blue" } match by label only. Discouraged: use locator-based locator.selectOption() instead.
</Note>

```ts
await frame.selectOption('...', /* values */);
```

| Parameter  | Type                                                                                                                                       | Required | Description |
| ---------- | ------------------------------------------------------------------------------------------------------------------------------------------ | -------- | ----------- |
| `selector` | `string`                                                                                                                                   | Yes      | —           |
| `values`   | `string \| string[] \| { value?: string; label?: string; index?: number } \| { value?: string; label?: string; index?: number }[] \| null` | Yes      | —           |
| `options`  | `PlaywrightSelectOptionOptions`                                                                                                            | No       | —           |

**Returns** `string[]`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-select-option)

***

### setInputFiles(selector, files, options?)

Sets the file input element to the given files.

<Note>
  Empty array clears the selected files. Discouraged: use locator-based locator.setInputFiles() instead.
</Note>

```ts
await frame.setInputFiles('...', /* files */);
```

| Parameter  | Type                                                                                                                               | Required | Description |
| ---------- | ---------------------------------------------------------------------------------------------------------------------------------- | -------- | ----------- |
| `selector` | `string`                                                                                                                           | Yes      | —           |
| `files`    | `string \| string[] \| { name: string; mimeType: string; buffer: Buffer } \| { name: string; mimeType: string; buffer: Buffer }[]` | Yes      | —           |
| `options`  | `{ noWaitAfter?: boolean; strict?: boolean; timeout?: number }`                                                                    | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-set-input-files)

***

### dragAndDrop(source, target, options?)

Drags source element to target element.

<Note>
  This method drags the source element to the target element. It will first move to the source element, perform a mousedown, then move to the target element and perform a mouseup.
</Note>

```ts
await frame.dragAndDrop('...', '...');
```

| Parameter | Type                                                                                                                                                                                    | Required | Description |
| --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------- | ----------- |
| `source`  | `string`                                                                                                                                                                                | Yes      | —           |
| `target`  | `string`                                                                                                                                                                                | Yes      | —           |
| `options` | `{ force?: boolean; noWaitAfter?: boolean; sourcePosition?: { x: number; y: number }; strict?: boolean; targetPosition?: { x: number; y: number }; timeout?: number; trial?: boolean }` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-drag-and-drop)

***

### dispatchEvent(selector, type, eventInit?, options?)

Dispatches an event on the element.

<Note>
  This method dispatches a DOM event on the element matching selector. Events are composed, cancelable, and bubble by default. Discouraged: use locator-based locator.dispatchEvent() instead.
</Note>

```ts
await frame.dispatchEvent('...', '...');
```

| Parameter   | Type                                     | Required | Description |
| ----------- | ---------------------------------------- | -------- | ----------- |
| `selector`  | `string`                                 | Yes      | —           |
| `type`      | `string`                                 | Yes      | —           |
| `eventInit` | `unknown`                                | No       | —           |
| `options`   | `{ strict?: boolean; timeout?: number }` | No       | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-dispatch-event)

***

## Queries

### page()

Returns the page containing this frame.

<Note>
  Returns the cached page reference passed at construction time.
</Note>

```ts
frame.page();
```

**Returns** `RemotePlaywrightPage`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-page)

***

### locator(selector, options?)

The method returns a Locator for the given selector.

<Note>
  The locator is a building block for accessing and interacting with elements on the page. Locators are strict by default - they will throw if more than one element matches the selector.
</Note>

```ts
frame.locator('...');
```

| Parameter  | Type                                                                                                                             | Required | Description |
| ---------- | -------------------------------------------------------------------------------------------------------------------------------- | -------- | ----------- |
| `selector` | `string`                                                                                                                         | Yes      | —           |
| `options`  | `{ has?: RemotePlaywrightLocator; hasNot?: RemotePlaywrightLocator; hasText?: string \| RegExp; hasNotText?: string \| RegExp }` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-locator)

***

### frameLocator(selector)

Returns a FrameLocator for the given selector.

<Note>
  Use this when the \<iframe> is lazy loaded. Use has and hasText options to locate elements inside a frame based on their content.
</Note>

```ts
frame.frameLocator('...');
```

| Parameter  | Type     | Required | Description |
| ---------- | -------- | -------- | ----------- |
| `selector` | `string` | Yes      | —           |

**Returns** `RemotePlaywrightFrameLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-frame-locator)

***

### getByRole(role, options?)

Allows locating elements by their ARIA role, ARIA attributes and accessible name.

```ts
frame.getByRole(/* role */);
```

| Parameter | Type                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | Required | Description |
| --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------- | ----------- |
| `role`    | `"alert" \| "alertdialog" \| "application" \| "article" \| "banner" \| "blockquote" \| "button" \| "caption" \| "cell" \| "checkbox" \| "code" \| "columnheader" \| "combobox" \| "complementary" \| "contentinfo" \| "definition" \| "deletion" \| "dialog" \| "directory" \| "document" \| "emphasis" \| "feed" \| "figure" \| "form" \| "generic" \| "grid" \| "gridcell" \| "group" \| "heading" \| "img" \| "insertion" \| "link" \| "list" \| "listbox" \| "listitem" \| "log" \| "main" \| "marquee" \| "math" \| "meter" \| "menu" \| "menubar" \| "menuitem" \| "menuitemcheckbox" \| "menuitemradio" \| "navigation" \| "none" \| "note" \| "option" \| "paragraph" \| "presentation" \| "progressbar" \| "radio" \| "radiogroup" \| "region" \| "row" \| "rowgroup" \| "rowheader" \| "scrollbar" \| "search" \| "searchbox" \| "separator" \| "slider" \| "spinbutton" \| "status" \| "strong" \| "subscript" \| "superscript" \| "switch" \| "tab" \| "table" \| "tablist" \| "tabpanel" \| "term" \| "textbox" \| "time" \| "timer" \| "toolbar" \| "tooltip" \| "tree" \| "treegrid" \| "treeitem"` | Yes      | —           |
| `options` | `PlaywrightGetByRoleOptions`                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-role)

***

### getByText(text, options?)

Allows locating elements that contain given text.

<Note>
  Matching by text always normalizes whitespace, even with exact match. For example, it turns multiple spaces into one, turns line breaks into spaces and ignores leading and trailing whitespace.
</Note>

```ts
frame.getByText(/* text */);
```

| Parameter | Type                         | Required | Description |
| --------- | ---------------------------- | -------- | ----------- |
| `text`    | `string \| RegExp`           | Yes      | —           |
| `options` | `PlaywrightGetByTextOptions` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-text)

***

### getByLabel(text, options?)

Allows locating input elements by the text of the associated \<label> or aria-labelledby element, or by the aria-label attribute.

```ts
frame.getByLabel(/* text */);
```

| Parameter | Type                          | Required | Description |
| --------- | ----------------------------- | -------- | ----------- |
| `text`    | `string \| RegExp`            | Yes      | —           |
| `options` | `PlaywrightGetByLabelOptions` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-label)

***

### getByPlaceholder(text, options?)

Allows locating input elements by the placeholder text.

```ts
frame.getByPlaceholder(/* text */);
```

| Parameter | Type                                | Required | Description |
| --------- | ----------------------------------- | -------- | ----------- |
| `text`    | `string \| RegExp`                  | Yes      | —           |
| `options` | `PlaywrightGetByPlaceholderOptions` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-placeholder)

***

### getByAltText(text, options?)

Allows locating elements by their alt text.

<Note>
  This method allows locating elements by their alt text. It works with \<img> and \<area> elements.
</Note>

```ts
frame.getByAltText(/* text */);
```

| Parameter | Type                            | Required | Description |
| --------- | ------------------------------- | -------- | ----------- |
| `text`    | `string \| RegExp`              | Yes      | —           |
| `options` | `PlaywrightGetByAltTextOptions` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-alt-text)

***

### getByTitle(text, options?)

Allows locating elements by their title attribute.

```ts
frame.getByTitle(/* text */);
```

| Parameter | Type                          | Required | Description |
| --------- | ----------------------------- | -------- | ----------- |
| `text`    | `string \| RegExp`            | Yes      | —           |
| `options` | `PlaywrightGetByTitleOptions` | No       | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-title)

***

### getByTestId(testId)

Locate element by the test id.

<Note>
  By default, the data-testid attribute is used as a test id. Use selectors.setTestIdAttribute() to configure a different test id attribute if necessary.
</Note>

```ts
frame.getByTestId(/* testId */);
```

| Parameter | Type               | Required | Description |
| --------- | ------------------ | -------- | ----------- |
| `testId`  | `string \| RegExp` | Yes      | —           |

**Returns** `RemotePlaywrightLocator`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-by-test-id)

***

### \$(selector)

Returns the ElementHandle pointing to the frame element.

<Note>
  This method queries the frame for the given selector. If no element matches the selector, returns null. Discouraged: use locator-based frame.locator() instead.
</Note>

```ts
await frame.$('...');
```

| Parameter  | Type     | Required | Description |
| ---------- | -------- | -------- | ----------- |
| `selector` | `string` | Yes      | —           |

**Returns** `RemotePlaywrightElementHandle \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-query-selector)

***

### \$\$(selector)

Returns the ElementHandles pointing to the frame elements.

<Note>
  This method queries the frame for all elements matching the given selector. Returns empty array if no elements match. Discouraged: use locator-based frame.locator() instead.
</Note>

```ts
await frame.$$('...');
```

| Parameter  | Type     | Required | Description |
| ---------- | -------- | -------- | ----------- |
| `selector` | `string` | Yes      | —           |

**Returns** `RemotePlaywrightElementHandle[]`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-query-selector-all)

***

## Content

### textContent(selector, options?)

Returns the element.textContent.

<Note>
  Discouraged: use locator-based locator.textContent() instead.
</Note>

```ts
await frame.textContent('...');
```

| Parameter  | Type                           | Required | Description |
| ---------- | ------------------------------ | -------- | ----------- |
| `selector` | `string`                       | Yes      | —           |
| `options`  | `PlaywrightTextContentOptions` | No       | —           |

**Returns** `string \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-text-content)

***

### innerText(selector, options?)

Returns the element.innerText.

<Note>
  Discouraged: use locator-based locator.innerText() instead.
</Note>

```ts
await frame.innerText('...');
```

| Parameter  | Type                         | Required | Description |
| ---------- | ---------------------------- | -------- | ----------- |
| `selector` | `string`                     | Yes      | —           |
| `options`  | `PlaywrightInnerTextOptions` | No       | —           |

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-inner-text)

***

### innerHTML(selector, options?)

Returns the element.innerHTML.

<Note>
  Discouraged: use locator-based locator.innerHTML() instead.
</Note>

```ts
await frame.innerHTML('...');
```

| Parameter  | Type                         | Required | Description |
| ---------- | ---------------------------- | -------- | ----------- |
| `selector` | `string`                     | Yes      | —           |
| `options`  | `PlaywrightInnerHTMLOptions` | No       | —           |

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-inner-html)

***

### getAttribute(selector, name, options?)

Returns element attribute value.

<Note>
  Discouraged: use locator-based locator.getAttribute() instead.
</Note>

```ts
await frame.getAttribute('...', '...');
```

| Parameter  | Type                            | Required | Description |
| ---------- | ------------------------------- | -------- | ----------- |
| `selector` | `string`                        | Yes      | —           |
| `name`     | `string`                        | Yes      | —           |
| `options`  | `PlaywrightGetAttributeOptions` | No       | —           |

**Returns** `string \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-get-attribute)

***

### inputValue(selector, options?)

Returns input.value for the selected \<input> or \<textarea> or \<select> element.

<Note>
  Throws for non-input elements. Discouraged: use locator-based locator.inputValue() instead.
</Note>

```ts
await frame.inputValue('...');
```

| Parameter  | Type                          | Required | Description |
| ---------- | ----------------------------- | -------- | ----------- |
| `selector` | `string`                      | Yes      | —           |
| `options`  | `PlaywrightInputValueOptions` | No       | —           |

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-input-value)

***

## State Checks

### isDetached()

Returns `true` if the frame has been detached, or `false` otherwise.

```ts
frame.isDetached();
```

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-detached)

***

### isChecked(selector, options?)

Returns whether the element is checked.

<Note>
  Throws if the element is not a checkbox or radio input. Discouraged: use locator-based locator.isChecked() instead.
</Note>

```ts
await frame.isChecked('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-checked)

***

### isDisabled(selector, options?)

Returns whether the element is disabled.

<Note>
  Discouraged: use locator-based locator.isDisabled() instead.
</Note>

```ts
await frame.isDisabled('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-disabled)

***

### isEditable(selector, options?)

Returns whether the element is editable.

<Note>
  Discouraged: use locator-based locator.isEditable() instead.
</Note>

```ts
await frame.isEditable('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-editable)

***

### isEnabled(selector, options?)

Returns whether the element is enabled.

<Note>
  Discouraged: use locator-based locator.isEnabled() instead.
</Note>

```ts
await frame.isEnabled('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-enabled)

***

### isHidden(selector, options?)

Returns whether the element is hidden.

<Note>
  Opposite of isVisible(). Discouraged: use locator-based locator.isHidden() instead.
</Note>

```ts
await frame.isHidden('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-hidden)

***

### isVisible(selector, options?)

Returns whether the element is visible.

<Note>
  Element is considered visible if it has non-zero bounding box and is not visibility:hidden. Discouraged: use locator-based locator.isVisible() instead.
</Note>

```ts
await frame.isVisible('...');
```

| Parameter  | Type                  | Required | Description |
| ---------- | --------------------- | -------- | ----------- |
| `selector` | `string`              | Yes      | —           |
| `options`  | `PlaywrightIsOptions` | No       | —           |

**Returns** `boolean`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-is-visible)

***

## Waiting

### waitForSelector(selector, options?)

Returns when element specified by selector satisfies state option.

<Note>
  Returns null if waiting for hidden or detached. Returns the ElementHandle matching the selector in visible/attached states. Discouraged: use locator-based locator.waitFor() instead.
</Note>

```ts
await frame.waitForSelector('...');
```

| Parameter  | Type                               | Required | Description |
| ---------- | ---------------------------------- | -------- | ----------- |
| `selector` | `string`                           | Yes      | —           |
| `options`  | `PlaywrightWaitForSelectorOptions` | No       | —           |

**Returns** `RemotePlaywrightElementHandle \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-wait-for-selector)

***

### waitForTimeout(timeout)

Waits for the given timeout in milliseconds.

<Note>
  Note: This should never be used in production. Tests that wait for time are inherently flaky. Use Locator actions and web assertions that wait automatically.
</Note>

```ts
await frame.waitForTimeout(0);
```

| Parameter | Type     | Required | Description |
| --------- | -------- | -------- | ----------- |
| `timeout` | `number` | Yes      | —           |

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-wait-for-timeout)

***

### waitForFunction(pageFunction, arg?, options?)

Returns when the pageFunction returns a truthy value.

<Note>
  It resolves to a JSHandle of the truthy value. The function is called periodically. You can pass a polling interval.
</Note>

```ts
await frame.waitForFunction('...');
```

| Parameter      | Type                                                           | Required | Description |
| -------------- | -------------------------------------------------------------- | -------- | ----------- |
| `pageFunction` | `string \| ((...args: unknown[]) =&gt; R \| Promise&lt;R&gt;)` | Yes      | —           |
| `arg`          | `unknown`                                                      | No       | —           |
| `options`      | `{ timeout?: number; polling?: number \| "raf" }`              | No       | —           |

**Returns** `unknown`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-wait-for-function)

***

## Evaluation

### evaluate(pageFunction, arg?)

Evaluates JavaScript in the frame context.

<Note>
  Returns the return value of pageFunction. If the function returns a Promise, evaluate will wait for that Promise to resolve and return its value.
</Note>

```ts
await frame.evaluate('...');
```

| Parameter      | Type                                                           | Required | Description |
| -------------- | -------------------------------------------------------------- | -------- | ----------- |
| `pageFunction` | `string \| ((...args: unknown[]) =&gt; R \| Promise&lt;R&gt;)` | Yes      | —           |
| `arg`          | `unknown`                                                      | No       | —           |

**Returns** `R`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-evaluate)

***

### evaluateHandle(pageFunction, arg?)

Evaluates a function in the frame's context and returns a handle to the result.

<Note>
  Returns a JSHandle for the in-page object. Unlike evaluate, this does not return the value of the function, but a handle pointing to the value.
</Note>

```ts
await frame.evaluateHandle('...');
```

| Parameter      | Type                                                           | Required | Description |
| -------------- | -------------------------------------------------------------- | -------- | ----------- |
| `pageFunction` | `string \| ((...args: unknown[]) =&gt; R \| Promise&lt;R&gt;)` | Yes      | —           |
| `arg`          | `unknown`                                                      | No       | —           |

**Returns** `unknown`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-evaluate-handle)

***

### \$eval(selector, pageFunction, arg?)

Finds an element matching selector and passes it to pageFunction.

<Note>
  Returns the value of pageFunction. Throws if selector matches no elements. Discouraged: use locator-based locator.evaluate() instead.
</Note>

```ts
await frame.$eval('...', '...');
```

| Parameter      | Type                                                                             | Required | Description |
| -------------- | -------------------------------------------------------------------------------- | -------- | ----------- |
| `selector`     | `string`                                                                         | Yes      | —           |
| `pageFunction` | `string \| ((element: Element, ...args: unknown[]) =&gt; R \| Promise&lt;R&gt;)` | Yes      | —           |
| `arg`          | `unknown`                                                                        | No       | —           |

**Returns** `R`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector)

***

### \$\$eval(selector, pageFunction, arg?)

Finds all elements matching selector and passes them to pageFunction.

<Note>
  Returns the value of pageFunction. Discouraged: use locator-based locator.evaluateAll() instead.
</Note>

```ts
await frame.$$eval('...', '...');
```

| Parameter      | Type                                                                                | Required | Description |
| -------------- | ----------------------------------------------------------------------------------- | -------- | ----------- |
| `selector`     | `string`                                                                            | Yes      | —           |
| `pageFunction` | `string \| ((elements: Element[], ...args: unknown[]) =&gt; R \| Promise&lt;R&gt;)` | Yes      | —           |
| `arg`          | `unknown`                                                                           | No       | —           |

**Returns** `R`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-eval-on-selector-all)

***

## Other

### frameElement()

Returns the frame element associated with this frame.

<Note>
  Returns the ElementHandle for the \<iframe> or \<frame> tag for this frame. Returns null for the main frame.
</Note>

```ts
await frame.frameElement();
```

**Returns** `RemotePlaywrightElementHandle`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-frame-element)

***

### name()

Returns frame's name attribute as specified in the tag.

<Note>
  If the name is empty, returns the id attribute instead. Returns empty string if both name and id are empty.
</Note>

```ts
await frame.name();
```

**Returns** `string`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-name)

***

### parentFrame()

Parent frame, if any. Detached frames and main frames return null.

```ts
await frame.parentFrame();
```

**Returns** `RemotePlaywrightFrame \| null`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-parent-frame)

***

### childFrames()

Returns child frames of this frame.

```ts
await frame.childFrames();
```

**Returns** `RemotePlaywrightFrame[]`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-child-frames)

***

### addScriptTag(options?)

Adds a \<script> tag into the page with the desired url or content.

<Note>
  Returns the added tag when the script's onload fires or when the script content was injected into frame.
</Note>

```ts
await frame.addScriptTag();
```

| Parameter | Type                                                               | Required | Description |
| --------- | ------------------------------------------------------------------ | -------- | ----------- |
| `options` | `{ content?: string; path?: string; type?: string; url?: string }` | No       | —           |

**Returns** `RemotePlaywrightElementHandle`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-add-script-tag)

***

### addStyleTag(options?)

Adds a \<style> tag into the page with the desired url or content.

<Note>
  Returns the added tag when the stylesheet's onload fires or when the CSS content was injected into frame.
</Note>

```ts
await frame.addStyleTag();
```

| Parameter | Type                                                | Required | Description |
| --------- | --------------------------------------------------- | -------- | ----------- |
| `options` | `{ content?: string; path?: string; url?: string }` | No       | —           |

**Returns** `RemotePlaywrightElementHandle`

[Upstream docs](https://playwright.dev/docs/api/class-frame#frame-add-style-tag)

***