---
site: steel.dev
collection: docs
canonical_url: https://steel.dev/docs/sessions/extensions
markdown_url: https://steel.dev/docs/sessions/extensions.md
content_signal: ai-input=yes, ai-train=yes, search=yes
title: Extensions
description: Upload a Chrome extension to Steel once, then load it into any session with the extensionIds option.
summary: Upload a Chrome extension to Steel once, then load it into any session with the extensionIds option.
type: how-to
stage: beta
reviewed: 2026-11-12
prerequisites:
  - https://steel.dev/docs/sessions/lifecycle.md
related:
  - https://steel.dev/docs/sessions/timeouts.md
  - https://steel.dev/docs/sessions/devices.md
  - https://steel.dev/docs/sessions/metadata.md
  - https://steel.dev/docs/sessions/bandwidth.md
  - https://steel.dev/docs/sessions/files.md
agent_setup: https://setup.steel.dev/install.md
docs_index: https://steel.dev/docs/sitemap.md
---

# Extensions

Load a Chrome extension, such as a crypto wallet or a tool that your team built, into your sessions. Upload it once, and Steel stores it for your organization. Then load it into any session by its ID.

> **Note**
>
> Extensions are in Beta. They can change. See [Release stages](https://steel.dev/docs/platform/release-stages).

## Before you begin

Put your Steel API key in the `STEEL_API_KEY` environment variable. Then install the Steel SDK.

**TypeScript**

```sh
npm install steel-sdk
```

**Python**

```sh
python3 -m venv .venv
source .venv/bin/activate
pip install steel-sdk
```

**Go**

```sh
go mod init upload-extension
go get github.com/steel-dev/sdk/go
```

**Rust**

```sh
cargo new upload-extension
cd upload-extension
cargo add steel-rs
cargo add tokio --features macros,rt-multi-thread
```

## Upload an extension

Call `client.extensions.upload` with one of these sources:

- `url`: the extension's Chrome Web Store URL. Copy it from the extension's page.
- `file`: a packaged extension file of at most 500 MB. The package needs a `manifest.json` file with the extension's name and version.

This program uploads an extension from the Chrome Web Store and prints its ID.

**TypeScript**

```ts file=upload-extension.mts
import Steel from "steel-sdk";

const client = new Steel();

const extension = await client.extensions.upload({
  url: "https://chromewebstore.google.com/detail/github-isometric-contribu/mjoedlfflcchnleknnceiplgaeoegien",
});
console.log(extension.id, extension.name);
```

**Python**

```python file=upload_extension.py
from steel import Steel

client = Steel()

extension = client.extensions.upload(
    url="https://chromewebstore.google.com/detail/github-isometric-contribu/mjoedlfflcchnleknnceiplgaeoegien",
)
print(extension.id, extension.name)
```

**Go**

```go file=main.go
package main

import (
	"context"
	"fmt"
	"log"

	"github.com/steel-dev/sdk/go"
)

func main() {
	if err := run(context.Background()); err != nil {
		log.Fatal(err)
	}
}

func run(ctx context.Context) error {
	client := steel.NewClient()

	extension, err := client.Extensions.Upload(ctx, steel.ExtensionUploadParams{
		URL: steel.F("https://chromewebstore.google.com/detail/github-isometric-contribu/mjoedlfflcchnleknnceiplgaeoegien"),
	})
	if err != nil {
		return err
	}
	fmt.Println(extension.ID, extension.Name)
	return nil
}
```

**Rust**

```rust file=src/main.rs
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = steel_rs::Client::new();

    let extension = client
        .extensions()
        .upload(steel_rs::ExtensionUploadParams {
            url: Some("https://chromewebstore.google.com/detail/github-isometric-contribu/mjoedlfflcchnleknnceiplgaeoegien".to_owned()),
            ..Default::default()
        })
        .await?;
    println!("{} {}", extension.id, extension.name);
    Ok(())
}
```

Run the program:

**TypeScript**

```sh
npx tsx upload-extension.mts
```

**Python**

```sh
python upload_extension.py
```

**Go**

```sh
go run .
```

**Rust**

```sh
cargo run
```

The program prints the extension's ID and name. Keep the ID, because you load the extension by it. The ID is the Chrome extension ID, and Steel makes the name from the part of the URL before the ID.

```text nocopy
mjoedlfflcchnleknnceiplgaeoegien Github_Isometric_Contribu
```

To upload a file, pass it in `file` with its name. Steel checks that the name ends in `.zip` or `.crx`. In TypeScript, `createReadStream` sends the name of the file that it reads. In Python, pass a tuple of the name and bytes. In Go, a file that `os.Open` returns sends its name. In Rust, `steel_rs::Upload::open` keeps the name of the file that it reads. Steel takes the extension's name from its `manifest.json`.

**TypeScript**

```ts
import { createReadStream } from "node:fs";

const extension = await client.extensions.upload({
  file: createReadStream("extension.zip"),
});
```

**Python**

```python
from pathlib import Path

extension = client.extensions.upload(
    file=("extension.zip", Path("extension.zip").read_bytes()),
)
```

**Go**

```go
import (
	"io"
	"os"
)

file, err := os.Open("extension.zip")
if err != nil {
	return err
}
defer file.Close()
extension, err := client.Extensions.Upload(ctx, steel.ExtensionUploadParams{
	File: steel.F[io.Reader](file),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let extension = client
    .extensions()
    .upload(steel_rs::ExtensionUploadParams {
        file: Some(steel_rs::Upload::open("extension.zip").await?),
        ..Default::default()
    })
    .await?;
```

You can upload each extension only once. To change it, [update it](https://steel.dev/docs/sessions/extensions#update-or-delete-an-extension).

## Load extensions in a session

Pass the extensions' IDs in `extensionIds` when you create the session. Steel installs them when the session starts.

**TypeScript**

```ts
const session = await client.sessions.create({
  extensionIds: [extension.id],
});
```

**Python**

```python
session = client.sessions.create(
    extension_ids=[extension.id],
)
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	ExtensionIDs: steel.F([]string{extension.ID}),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        extension_ids: Some(vec![extension.id.clone()]),
        ..Default::default()
    })
    .await?;
```

To load all of your organization's extensions, pass `["all_ext"]`.

**TypeScript**

```ts
const session = await client.sessions.create({ extensionIds: ["all_ext"] });
```

**Python**

```python
session = client.sessions.create(extension_ids=["all_ext"])
```

**Go**

```go
session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	ExtensionIDs: steel.F([]string{"all_ext"}),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        extension_ids: Some(vec!["all_ext".to_owned()]),
        ..Default::default()
    })
    .await?;
```

A [profile](https://steel.dev/docs/logins/profiles) saves the `extensionIds` of the session that created it.

## Update or delete an extension

To replace an extension with a new version, call `client.extensions.update` with its ID and a new `url` or `file`. The ID stays the same, so your `extensionIds` stay the same.

**TypeScript**

```ts
await client.extensions.update(extension.id, {
  file: createReadStream("extension-v2.zip"),
});
```

**Python**

```python
client.extensions.update(
    extension.id,
    file=("extension-v2.zip", Path("extension-v2.zip").read_bytes()),
)
```

**Go**

```go
import (
	"io"
	"os"
)

v2, err := os.Open("extension-v2.zip")
if err != nil {
	return err
}
defer v2.Close()
if _, err := client.Extensions.Update(ctx, extension.ID, steel.ExtensionUpdateParams{
	File: steel.F[io.Reader](v2),
}); err != nil {
	return err
}
```

**Rust**

```rust
client
    .extensions()
    .update(
        &extension.id,
        steel_rs::ExtensionUpdateParams {
            file: Some(steel_rs::Upload::open("extension-v2.zip").await?),
            ..Default::default()
        },
    )
    .await?;
```

To see your extensions, call `client.extensions.list`. It returns `extensions`, each with its `id`, `name`, `createdAt` and `updatedAt`, and `count`, the number of extensions.

To remove one extension, call `client.extensions.delete` with its ID. To remove all of your organization's extensions, call `deleteAll` in TypeScript, `delete_all` in Python and Rust, or `DeleteAll` in Go.

**TypeScript**

```ts
await client.extensions.delete(extension.id);
```

**Python**

```python
client.extensions.delete(extension.id)
```

**Go**

```go
if _, err := client.Extensions.Delete(ctx, extension.ID); err != nil {
	return err
}
```

**Rust**

```rust
client.extensions().delete(&extension.id).await?;
```

## Check that it worked

Call `client.extensions.list`. It returns the extension with the `id` and `name` that the upload printed. Then start a session with that ID in `extensionIds`, open a page that the extension acts on, and watch the page in the [live view](https://steel.dev/docs/observability/live-view). The page shows what the extension adds or changes.

## Troubleshooting

### Extension already exists in your organization

```json nocopy
{
  "error": "Bad Request",
  "message": "Extension already exists in your organization. Use the update endpoint for that extension id, or upload a different extension.",
  "retryable": false,
  "linkToDocs": "https://docs.steel.dev/overview/extensions-api/overview"
}
```

**Cause:** You uploaded an extension that your organization already has.

**Fix:** Find its ID with `client.extensions.list`, and call `client.extensions.update` with that ID to change it.

**Verify:** The update returns the extension with a new `updatedAt`.

### Extension file must be a .zip archive or .crx file

```json nocopy
{
  "error": "Bad Request",
  "message": "Extension file must be a .zip archive or .crx file. Upload a packaged Chrome extension in one of those formats.",
  "retryable": false,
  "linkToDocs": "https://docs.steel.dev/overview/extensions-api/overview"
}
```

**Cause:** The uploaded file has no name, or its name does not end in `.zip` or `.crx`. A file that you pass as raw bytes, without a name, fails this way.

**Fix:** Pass the file with its name, as the examples in [Upload an extension](https://steel.dev/docs/sessions/extensions#upload-an-extension) do.

**Verify:** The upload returns the extension's `id`.

### Extension was not found in your organization

```json nocopy
{
  "error": "Not Found",
  "message": "Extension 'mjoedlfflcchnleknnceiplgaeoegien' was not found in your organization. Check the extension id, or list your extensions to confirm it exists.",
  "retryable": false,
  "linkToDocs": "https://docs.steel.dev/overview/extensions-api/overview"
}
```

**Cause:** An ID in `extensionIds`, or in an update or a delete, does not match any of your organization's extensions. Steel creates no session in that case.

**Fix:** Copy the ID from `client.extensions.list`, or pass `["all_ext"]`.

**Verify:** The session starts, and the response has a session `id`.

## Next steps

- [Extensions API](https://steel.dev/docs/reference/api/extensions): Download a stored extension as a ZIP file, or call the endpoints over HTTP.
