> ## Documentation Index
> Fetch the complete documentation index at: https://e2b-banner-hover-tooltip.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Desktop

## Sandbox

```python theme={null}
class Sandbox(SandboxBase)
```

### create

```python theme={null}
@classmethod
def create(cls,
           template: Optional[str] = None,
           resolution: Optional[Tuple[int, int]] = None,
           dpi: Optional[int] = None,
           display: Optional[str] = None,
           timeout: Optional[int] = None,
           metadata: Optional[Dict[str, str]] = None,
           envs: Optional[Dict[str, str]] = None,
           secure: bool = True,
           allow_internet_access: bool = True,
           **opts: Unpack[ApiParams]) -> Self
```

Create a new sandbox.

By default, the sandbox is created from the default `desktop` sandbox template.

**Arguments**:

* `template`: Sandbox template name or ID
* `resolution`: Startup the desktop with custom screen resolution. Defaults to (1024, 768)
* `dpi`: Startup the desktop with custom DPI. Defaults to 96
* `display`: Startup the desktop with custom display. Defaults to ":0"
* `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. The maximum time a sandbox can be kept alive is 24 hours (86\_400 seconds) for Pro users and 1 hour (3\_600 seconds) for Hobby users.
* `metadata`: Custom metadata for the sandbox
* `envs`: Custom environment variables for the sandbox
* `secure`: Envd is secured with access token and cannot be used without it
* `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.

**Returns**:

A Sandbox instance for the new sandbox
Use this method instead of using the constructor to create a new sandbox.

### beta\_create

```python theme={null}
@classmethod
def beta_create(cls,
                template: Optional[str] = None,
                resolution: Optional[Tuple[int, int]] = None,
                dpi: Optional[int] = None,
                display: Optional[str] = None,
                timeout: Optional[int] = None,
                auto_pause: Optional[bool] = False,
                metadata: Optional[Dict[str, str]] = None,
                envs: Optional[Dict[str, str]] = None,
                secure: bool = True,
                allow_internet_access: bool = True,
                **opts: Unpack[ApiParams]) -> Self
```

\[BETA] This feature is in beta and may change in the future.

Create a new sandbox.

By default, the sandbox is created from the default `desktop` sandbox template.

**Arguments**:

* `template`: Sandbox template name or ID
* `resolution`: Startup the desktop with custom screen resolution. Defaults to (1024, 768)
* `dpi`: Startup the desktop with custom DPI. Defaults to 96
* `display`: Startup the desktop with custom display. Defaults to ":0"
* `timeout`: Timeout for the sandbox in **seconds**, default to 300 seconds. The maximum time a sandbox can be kept alive is 24 hours (86\_400 seconds) for Pro users and 1 hour (3\_600 seconds) for Hobby users.
* `auto_pause`: Automatically pause the sandbox after the timeout expires. Defaults to `False`.
* `metadata`: Custom metadata for the sandbox
* `envs`: Custom environment variables for the sandbox
* `secure`: Envd is secured with access token and cannot be used without it
* `allow_internet_access`: Allow sandbox to access the internet, defaults to `True`.

**Returns**:

A Sandbox instance for the new sandbox
Use this method instead of using the constructor to create a new sandbox.

### screenshot

```python theme={null}
@overload
def screenshot(format: Literal["stream"]) -> Iterator[bytes]
```

Take a screenshot and return it as a stream of bytes.

### screenshot

```python theme={null}
@overload
def screenshot(format: Literal["bytes"]) -> bytearray
```

Take a screenshot and return it as a bytearray.

### screenshot

```python theme={null}
def screenshot(format: Literal["bytes", "stream"] = "bytes")
```

Take a screenshot and return it in the specified format.

**Arguments**:

* `format`: The format of the screenshot. Can be 'bytes', 'blob', or 'stream'.

**Returns**:

The screenshot in the specified format.

### left\_click

```python theme={null}
def left_click(x: Optional[int] = None, y: Optional[int] = None)
```

Left click on the mouse position.

### double\_click

```python theme={null}
def double_click(x: Optional[int] = None, y: Optional[int] = None)
```

Double left click on the mouse position.

### middle\_click

```python theme={null}
def middle_click(x: Optional[int] = None, y: Optional[int] = None)
```

Middle click on the mouse position.

### scroll

```python theme={null}
def scroll(direction: Literal["up", "down"] = "down", amount: int = 1)
```

Scroll the mouse wheel by the given amount.

**Arguments**:

* `direction`: The direction to scroll. Can be "up" or "down".
* `amount`: The amount to scroll.

### move\_mouse

```python theme={null}
def move_mouse(x: int, y: int)
```

Move the mouse to the given coordinates.

**Arguments**:

* `x`: The x coordinate.
* `y`: The y coordinate.

### mouse\_press

```python theme={null}
def mouse_press(button: Literal["left", "right", "middle"] = "left")
```

Press the mouse button.

### mouse\_release

```python theme={null}
def mouse_release(button: Literal["left", "right", "middle"] = "left")
```

Release the mouse button.

### get\_cursor\_position

```python theme={null}
def get_cursor_position() -> tuple[int, int]
```

Get the current cursor position.

**Raises**:

* `RuntimeError`: If the cursor position cannot be determined

**Returns**:

A tuple with the x and y coordinates

### get\_screen\_size

```python theme={null}
def get_screen_size() -> tuple[int, int]
```

Get the current screen size.

**Raises**:

* `RuntimeError`: If the screen size cannot be determined

**Returns**:

A tuple with the width and height

### write

```python theme={null}
def write(text: str, *, chunk_size: int = 25, delay_in_ms: int = 75) -> None
```

Write the given text at the current cursor position.

**Arguments**:

* `text`: The text to write.
* `chunk_size`: The size of each chunk of text to write.
* `delay_in_ms`: The delay between each chunk of text.

### press

```python theme={null}
def press(key: Union[str, list[str]])
```

Press a key.

**Arguments**:

* `key`: The key to press (e.g. "enter", "space", "backspace", etc.).

### drag

```python theme={null}
def drag(fr: tuple[int, int], to: tuple[int, int])
```

Drag the mouse from the given position to the given position.

**Arguments**:

* `from`: The starting position.
* `to`: The ending position.

### wait

```python theme={null}
def wait(ms: int)
```

Wait for the given amount of time.

**Arguments**:

* `ms`: The amount of time to wait in milliseconds.

### open

```python theme={null}
def open(file_or_url: str)
```

Open a file or a URL in the default application.

**Arguments**:

* `file_or_url`: The file or URL to open.

### get\_current\_window\_id

```python theme={null}
def get_current_window_id() -> str
```

Get the current window ID.

### get\_application\_windows

```python theme={null}
def get_application_windows(application: str) -> list[str]
```

Get the window IDs of all windows for the given application.

### get\_window\_title

```python theme={null}
def get_window_title(window_id: str) -> str
```

Get the title of the window with the given ID.

### launch

```python theme={null}
def launch(application: str, uri: Optional[str] = None)
```

Launch an application.