> For the complete documentation index, see [llms.txt](https://docs.roboflow.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.roboflow.com/platform/workspaces/list-workspaces-and-projects.md).
# List Workspaces and Projects
## About
The workspace endpoint returns metadata about a workspace and every project it contains - including each project's type, image and annotation counts, versions, and dataset splits. Use it to enumerate the projects your API key can access (for example, to discover project IDs before uploading data or exporting a version) and to drill into a project's generated versions, trained models, and dataset exports. The same data is available through the REST API, the Python SDK, and the CLI.
## HTTP API
The `/:workspace` endpoint gives you information about your workspace and its Projects. This endpoint lists all Projects in the Workspace your API key authenticates against, and you can dive deeper into any project to find information about its generated versions, models, and dataset exports.
The endpoint URL is:
```url
curl "https://api.roboflow.com/roboflow?api_key=$ROBOFLOW_API_KEY"
```
Here is an example of a response from the endpoint:
{
"workspace": {
"name": "Roboflow",
"url": "roboflow",
"members": 7,
"projects": [
{
"id": "roboflow/chess-sample-4ckfl",
"type": "object-detection",
"name": "Chess Sample",
"created": 1630335544.592,
"updated": 1630335741.988,
"images": 12,
"unannotated": 3,
"annotation": "pieces",
"versions": 3,
"public": false,
"splits": {
"train": 9,
"test": 1,
"valid": 2
},
"classes": {
"white-queen": 7,
"black-queen": 4,
"black-bishop": 8,
"white-knight": 10,
"white-bishop": 11,
"black-knight": 11,
"black-rook": 10,
"white-pawn": 34,
"black-pawn": 37,
"white-rook": 10,
"black-king": 8,
"white-king": 8
}
}
]
}
}
### Get a Project and List Versions
You can retrieve information about a project using the following REST endpoint:
```bash
curl "https://api.roboflow.com/roboflow/chess-sample-4ckfl?api_key=$ROBOFLOW_API_KEY"
```
This endpoint returns a JSON response with the following structure:
```bash
{
"workspace": {
"name": "Roboflow",
"url": "roboflow",
"members": 7
},
"project": {
"id": "roboflow/chess-sample-4ckfl",
"type": "object-detection",
"name": "Chess Sample",
"created": 1630335544.592,
"updated": 1630335741.988,
"images": 12,
"unannotated": 3,
"annotation": "pieces",
"public": false,
"splits": {
"valid": 2,
"train": 9,
"test": 1
},
"classes": {
"white-queen": 7,
"white-king": 8,
"black-knight": 11,
"black-pawn": 37,
"black-rook": 10,
"white-pawn": 34,
"black-bishop": 8,
"white-knight": 10,
"black-queen": 4,
"white-bishop": 11,
"black-king": 8,
"white-rook": 10
},
"versions": [
{
"id": "roboflow/chess-sample-4ckfl/3",
"name": "raw",
"created": 1630335741.989,
"images": 12,
"splits": {
"train": 9,
"test": 1,
"valid": 2
},
"preprocessing": {
"auto-orient": {
"enabled": true
}
},
"augmentation": {},
"exports": [
"coco",
"voc"
]
},
{
"id": "roboflow/chess-sample-4ckfl/2",
"name": "416x416",
"created": 1630335730.142,
"images": 12,
"splits": {
"train": 9,
"test": 1,
"valid": 2
},
"preprocessing": {
"resize": {
"enabled": true,
"format": "Stretch to",
"width": 416,
"height": 416
},
"auto-orient": {
"enabled": true
}
},
"augmentation": {},
"exports": []
},
{
"id": "roboflow/chess-sample-4ckfl/1",
"name": "augmented",
"created": 1630335698.746,
"images": 30,
"splits": {
"valid": 2,
"train": 27,
"test": 1
},
"model": {
"id": "chess-sample-4ckfl/1",
"endpoint": "https://serverless.roboflow.com/infer/chess-sample-4ckfl/1",
"start": 1630335799.682,
"end": 1630337523.889,
"fromScratch": false,
"tfjs": true,
"oak": true,
"map": "62.87",
"recall": "85.29",
"precision": "23.44"
},
"preprocessing": {
"resize": {
"enabled": true,
"width": 416,
"format": "Stretch to",
"height": 416
},
"auto-orient": {
"enabled": true
},
"grayscale": {
"enabled": true
}
},
"augmentation": {
"exposure": {
"percent": "25",
"enabled": true
},
"brightness": {
"percent": "25",
"enabled": true,
"darken": true,
"brighten": true
},
"rotate": {
"degrees": "5",
"enabled": true
},
"image": {
"enabled": true,
"versions": "3"
},
"flip": {
"enabled": true,
"horizontal": true,
"vertical": false
},
"crop": {
"min": 0,
"percent": 30,
"enabled": true
},
"noise": {
"percent": "2",
"enabled": true
}
},
"exports": [
"yolov5pytorch"
],
"versionNotes": "Fix: rotated box misalignment"
}
]
}
}
```
### List Project Models
You can retrieve all trained models in a project using the `/:workspace/:project/models` endpoint. This returns both version-trained models and standalone models (such as NAS children).
With [Sign In With Roboflow (Getting Started)](https://docs.roboflow.com/reference/authentication/authentication/sign-in-with-roboflow-getting-started), use `Authorization: Bearer` and scope `model:infer` instead of `api_key`:
```bash
curl -H "Authorization: Bearer $ACCESS_TOKEN" \
"https://api.roboflow.com/:workspace/:project/models"
```
#### List All Models
```bash
curl "https://api.roboflow.com/:workspace/:project/models?api_key=$ROBOFLOW_API_KEY"
```
**Filter by NAS Group**
To list only the models from a specific NAS run, pass the `group` query parameter:
```bash
curl "https://api.roboflow.com/:workspace/:project/models?group=GROUP_ID&api_key=$ROBOFLOW_API_KEY"
```
The `group` value is the NAS run identifier returned on each model object. If the group doesn't match any models, the endpoint returns an empty array.
#### Response
The endpoint returns a JSON array of model objects:
```json
[
{
"url": "my-workspace/my-project/3",
"version": "3",
"train": { "status": "finished" },
"modelType": "rfdetr-base",
"name": "My Model",
"created": "2026-04-01T00:00:00.000Z",
"metrics": {
"map50": 91.0,
"precision": 88.0,
"recall": 85.0
}
}
]
```
**NAS Model Fields**
Models produced by [Neural Architecture Search](https://docs.roboflow.com/models/train/neural-architecture-search) include additional fields:
```json
{
"url": "my-workspace/my-project-410-nas-gpu-066866",
"train": { "status": "finished" },
"modelType": "rfdetr-nas-S",
"name": "NAS Child 1",
"created": "2026-04-01T00:00:00.000Z",
"nasFamily": "child",
"group": "pVYKOWUB6AUIVJMgPc7u-410-rfdetrNasGroup",
"favorites": {},
"recommended": true,
"metrics": {
"map50": 81.2,
"map5095": 64.3,
"f1": 78.0,
"hardware": "gpu",
"latency": 1.157,
"paretoOptimalFor": ["gpu"]
}
}
```
| Field | Type | Description |
| -------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
| `nasFamily` | string | `"child"` for NAS-discovered models, `null` for the baseline |
| `group` | string | NAS run identifier, shared by all models in the same run |
| `favorites` | object | Map of user IDs to favorite status |
| `recommended` | boolean | Present and `true` when this model is the recommended pick for at least one metric/hardware combination |
| `metrics.map5095` | number | mAP\@50-95 score (percentage) |
| `metrics.f1` | number | F1 score (percentage) |
| `metrics.hardware` | string | Hardware target the model was benchmarked on (e.g. `"gpu"`, `"jetson-orin-nano"`) |
| `metrics.latency` | number | Inference latency in milliseconds on the target hardware |
| `metrics.paretoOptimalFor` | string\[] | Hardware targets for which this model sits on the Pareto frontier |
These fields are only present on NAS models. Standard trained models are not affected.
## Python SDK
Get a `Workspace` handle for the workspace your API key authenticates against:
```python
import roboflow
rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
workspace = rf.workspace()
```
Each Roboflow API key is scoped to a single workspace. To work against a different workspace, use a different API key (or, for public Universe workspaces, pass the workspace slug):
```python
# Public Universe workspace - only your API key is needed.
public_ws = rf.workspace("roboflow-100")
```
### Workspace properties
The returned `Workspace` exposes:
* `workspace.url` - the workspace's URL slug (e.g. `my-workspace`).
* `workspace.name` - the workspace's display name.
* `workspace.list_projects()` - projects in the workspace, as a list of dicts.
* `workspace.projects()` - same data as `list_projects()` but returned as a `Project` object list (older alias).
* `workspace.list_folders()` - see [Manage Folders](https://docs.roboflow.com/datasets/manage/project-folders#python-sdk).
* `workspace.list_workflows()` - see [Manage Workflows](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk).
* `workspace.get_plan()` and `workspace.get_usage()` - see [Workspace Plan and Usage](/platform/billing-and-plans/credits/view-credit-usage.md#python-sdk).
### List Projects and Versions
#### List Projects
Get the projects in your workspace:
```python
import roboflow
rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
workspace = rf.workspace()
for project in workspace.list_projects():
print(project["id"], project["name"], project["type"])
```
Each entry includes the project's id (URL slug), display name, project type, image count, and a few other metadata fields.
To work against a public Universe workspace, pass its slug:
```python
universe_ws = rf.workspace("roboflow-100")
```
#### Get a Project
```python
project = workspace.project("my-detector")
```
Or use the top-level shortcut:
```python
project = rf.project("my-detector")
```
#### List Versions
```python
for version in project.versions():
print(version.version, version.name)
```
`project.versions()` returns `Version` objects you can call methods on directly (`download`, `train`, `delete`, etc.). For a lightweight dict response, use `project.list_versions()` or `project.get_version_information()`.
#### Get a Version
```python
version = project.version(3)
```
Numeric - versions are 1-indexed.
## CLI
### List Workspaces
You can retrieve a list of all Workspaces of which you are a member with the CLI.
To list Workspaces with the CLI, use the following command:
roboflow workspace list
This will return a list of Workspaces with their corresponding application links and Workspace IDs:
```
NAME ID DEFAULT
My Workspace my-workspace *
Other Workspace other-ws
```
To get the output as JSON (for use in scripts or AI agents):
```bash
roboflow workspace list --json
```
```json
[
{"name": "My Workspace", "url": "my-workspace", "link": "https://app.roboflow.com/my-workspace", "default": true},
{"name": "Other Workspace", "url": "other-ws", "link": "https://app.roboflow.com/other-ws", "default": false}
]
```
### List Projects in a Workspace
To list projects in a workspace, use the following command:
```bash
roboflow project list
```
If you have a default workspace configured, the `-w` flag is optional. Otherwise, specify it:
```bash
roboflow project list -w WORKSPACE_ID
```
This will return a table of Projects:
```
NAME ID TYPE VERSIONS IMAGES
my-dataset my-workspace/my-dataset object-detection 3 500
classifier my-workspace/classifier classification 1 200
```
To get the output as JSON:
```bash
roboflow project list --json
```
### Get a Project
To get detailed information about a project, use the following command:
```bash
roboflow project get PROJECT_ID
```
You can use the resource shorthand - no need to specify the workspace separately:
```bash
roboflow project get my-dataset # uses default workspace
roboflow project get my-workspace/my-dataset # explicit workspace
```
This will return information about the project including its versions:
```
Project: my-dataset
ID: my-workspace/my-dataset
Type: object-detection
Images: 500
Versions: 3
Classes: car (200), truck (150), bus (150)
Link: https://app.roboflow.com/my-workspace/my-dataset
```
To get the full JSON response:
```bash
roboflow project get my-dataset --json
```