---
site: steel.dev
collection: docs
canonical_url: https://steel.dev/docs/account/projects
markdown_url: https://steel.dev/docs/account/projects.md
content_signal: ai-input=yes, ai-train=yes, search=yes
title: Projects
description: Create projects to separate environments or products inside one organization, each with its own sessions, profiles, and keys.
summary: Create projects to separate environments or products inside one organization, each with its own sessions, profiles, and keys.
type: how-to
reviewed: 2026-11-12
prerequisites: []
related:
  - https://steel.dev/docs/account/api-keys.md
  - https://steel.dev/docs/account/organizations-and-members.md
agent_setup: https://setup.steel.dev/install.md
docs_index: https://steel.dev/docs/sitemap.md
---

# Projects

A project separates the work of one environment or product from the rest of your organization. Sessions, profiles, credentials and Quick actions belong to a project, and a project key reaches only its own project. Use projects to keep staging apart from production, or one product apart from another. Every organization has a default project, named `Default project`. [Projects and namespaces](https://steel.dev/docs/production/projects-and-namespaces) explains what a project holds.

The plan limits, such as concurrent sessions, apply to the whole organization, not to each project. See [Limits](https://steel.dev/docs/platform/limits).

## Before you begin

Put your Steel API key in the `STEEL_API_KEY` environment variable, and install the Steel SDK for your language: [TypeScript](https://steel.dev/docs/reference/sdks/typescript#install), [Python](https://steel.dev/docs/reference/sdks/python#install), [Go](https://steel.dev/docs/reference/sdks/go#install) or [Rust](https://steel.dev/docs/reference/sdks/rust#install).

## Create a project

An organization admin creates projects in the dashboard. Members who are not admins, and API keys, cannot create, change or delete projects.

1. Open the project menu at the top of the dashboard. It shows the current project's name.
2. Click **Create project**.
3. Under **Name your project**, type a name.
4. To make it a production project, turn on **Production**.
5. Click **Create project**.

The dashboard switches to the new project. Steel makes the slug from the name. The project menu also has **View & manage projects**, which opens [Project Settings](https://app.steel.dev/settings/projects). There an admin can create, rename, promote and delete projects, and copy each project ID.

A project has these properties:

| Property | Rule |
| - | - |
| Name | 1 to 100 characters |
| Slug | Lower-case letters, digits and hyphens. It must be unique in the organization. |
| Production | A project is a development project or a production project. Promoting a development project to production cannot be undone. |
| Default | One project of the organization is the default. The default project cannot be deleted. |

After you create a project, create a key for it. See [API keys](https://steel.dev/docs/account/api-keys).

## Switch projects

Each interface picks its project in its own way:

| Interface | How to use another project |
| - | - |
| Your code, with a project key | Use a key of the other project |
| Your code, with an organization key | Pass the other project's ID in `projectId` |
| [MCP server](https://steel.dev/docs/control/mcp-server), with sign-in | Sign in again, and pick the other project |
| MCP server, with an API key | Use a key of the other project |

In the dashboard, open the project menu at the top of the page, and click the other project. Each project in the menu has a **Prod** or **Dev** badge. The dashboard then shows that project's sessions, API keys, profiles and credentials. It remembers your choice for each organization. Until you choose, it uses the default project.

## Use a project from the API

To use a project from your code, you need its ID. This program lists the projects that your key reaches, with their IDs.

**TypeScript**

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

const client = new Steel();
const { projects } = await client.projects.list();

for (const project of projects) {
  console.log(project.id, project.name, project.isDefault ? "(default)" : "");
}
```

**Python**

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

client = Steel()
response = client.projects.list()

for project in response.projects:
    print(project.id, project.name, "(default)" if project.is_default else "")
```

**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()
	response, err := client.Projects.List(ctx)
	if err != nil {
		return err
	}

	for _, project := range response.Projects {
		label := ""
		if project.IsDefault {
			label = "(default)"
		}
		fmt.Println(project.ID, project.Name, label)
	}
	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 projects = client.projects().list().await?.projects;

    for project in projects {
        let label = if project.is_default { "(default)" } else { "" };
        println!("{} {} {label}", project.id, project.name);
    }
    Ok(())
}
```

Run the program:

**TypeScript**

```sh
npx tsx projects.mts
```

**Python**

```sh
python projects.py
```

**Go**

```sh
go run .
```

**Rust**

```sh
cargo run
```

With an organization key, the program prints every project in the organization. With a project key, it prints only the key's project.

```text nocopy
e4aa5c83-05bd-49eb-a83f-d36f710976b0 Default project (default)
```

What `projectId` does depends on your key's scope:

- A project key always uses its own project. Steel does not read `projectId` from the request.
- An organization key needs `projectId` to create a session, run a Quick action, or work with profiles or credentials. Without it, the request gets a `400` error. A list of sessions covers every project unless you pass `projectId`.

With an organization key, pass the ID when you create a session:

**TypeScript**

```ts
const session = await client.sessions.create({
  projectId: process.env.STEEL_PROJECT_ID,
});
```

**Python**

```python
import os

session = client.sessions.create(
    project_id=os.environ["STEEL_PROJECT_ID"],
)
```

**Go**

```go
import "os"

session, err := client.Sessions.New(ctx, steel.SessionNewParams{
	ProjectID: steel.F(os.Getenv("STEEL_PROJECT_ID")),
})
if err != nil {
	return err
}
```

**Rust**

```rust
let session = client
    .sessions()
    .create(steel_rs::SessionCreateParams {
        project_id: Some(std::env::var("STEEL_PROJECT_ID")?),
        ..Default::default()
    })
    .await?;
```

The session runs in that project, and the response's `projectId` field shows it. Release the session in a `finally` block, as in [Create a session](https://steel.dev/docs/sessions). In Go, release it in a `defer`. In Rust, release it after the `async` block. Every endpoint for projects is on [Projects API](https://steel.dev/docs/reference/api/projects).

## Check that it worked

Open the project menu at the top of the dashboard. It lists the new project, with a **Prod** badge if you turned on **Production**, or **Dev** if not. With an organization key, the program in [Use a project from the API](https://steel.dev/docs/account/projects#use-a-project-from-the-api) prints the new project's ID and name. A session that you create with that ID has it in `projectId`, and it is among that project's sessions in the dashboard.

## Next steps

- [Billing and usage](https://steel.dev/docs/platform/billing-and-usage#see-your-usage): Filter your usage and spend by project.
- [Track cost per customer](https://steel.dev/docs/production/track-cost-per-customer): Attribute the cost of sessions to your own customers.
