> 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/get-started/hi/platform/workspaces/list-workspaces-and-projects.md).

# वर्कस्पेस और प्रोजेक्ट्स की सूची

## के बारे में

वर्कस्पेस एंडपॉइंट किसी वर्कस्पेस और उसमें मौजूद हर प्रोजेक्ट के बारे में मेटाडेटा लौटाता है - जिसमें प्रत्येक प्रोजेक्ट का प्रकार, इमेज और एनोटेशन गिनती, वर्ज़न, और डेटासेट स्प्लिट शामिल हैं। इसका उपयोग उन प्रोजेक्ट्स की सूची बनाने के लिए करें जिन्हें आपका API key एक्सेस कर सकता है (उदाहरण के लिए, डेटा अपलोड करने या किसी वर्ज़न को एक्सपोर्ट करने से पहले project IDs खोजने के लिए) और किसी प्रोजेक्ट के जनरेट किए गए वर्ज़न, प्रशिक्षित मॉडल और डेटासेट एक्सपोर्ट्स में गहराई से जाने के लिए करें। वही डेटा REST API, Python SDK और CLI के माध्यम से उपलब्ध है।

## HTTP API

यह `/:workspace` एंडपॉइंट आपको आपके वर्कस्पेस और उसके प्रोजेक्ट्स के बारे में जानकारी देता है। यह एंडपॉइंट उस वर्कस्पेस के सभी प्रोजेक्ट्स की सूची देता है जिसके विरुद्ध आपका API key प्रमाणित होता है, और आप किसी भी प्रोजेक्ट में आगे जाकर उसके जनरेट किए गए वर्ज़न, मॉडल और डेटासेट एक्सपोर्ट्स की जानकारी पा सकते हैं।

एंडपॉइंट URL है:

```url
curl "https://api.roboflow.com/roboflow?api_key=$ROBOFLOW_API_KEY"
```

यहाँ एंडपॉइंट से प्राप्त प्रतिक्रिया का एक उदाहरण है:

<pre class="language-json"><code class="lang-json"><strong>{
</strong>    "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
                }
            }
        ]
    }
}
</code></pre>

### प्रोजेक्ट प्राप्त करें और वर्ज़न सूचीबद्ध करें

आप निम्न REST एंडपॉइंट का उपयोग करके किसी प्रोजेक्ट के बारे में जानकारी प्राप्त कर सकते हैं:

```bash
curl "https://api.roboflow.com/roboflow/chess-sample-4ckfl?api_key=$ROBOFLOW_API_KEY"
```

यह एंडपॉइंट निम्न संरचना के साथ एक JSON प्रतिक्रिया लौटाता है:

```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"
            }
        ]
    }
}
```

### प्रोजेक्ट मॉडल सूचीबद्ध करें

आप किसी प्रोजेक्ट में सभी प्रशिक्षित मॉडल निम्न का उपयोग करके प्राप्त कर सकते हैं `/:workspace/:project/models` एंडपॉइंट। यह वर्ज़न-प्रशिक्षित मॉडल और स्टैंडअलोन मॉडल (जैसे NAS children) दोनों लौटाता है।

के [Roboflow के साथ साइन इन करें (शुरुआत)](https://docs.roboflow.com/reference/authentication/authentication/sign-in-with-roboflow-getting-started), उपयोग करें `Authorization: Bearer` और स्कोप `model:infer` के बजाय `api_key`:

```bash
curl -H "Authorization: Bearer $ACCESS_TOKEN" \
  "https://api.roboflow.com/:workspace/:project/models"
```

#### सभी मॉडल सूचीबद्ध करें

```bash
curl "https://api.roboflow.com/:workspace/:project/models?api_key=$ROBOFLOW_API_KEY"
```

**NAS समूह के अनुसार फ़िल्टर करें**

केवल किसी विशिष्ट NAS रन के मॉडल सूचीबद्ध करने के लिए, निम्न पास करें `समूह` क्वेरी पैरामीटर:

```bash
curl "https://api.roboflow.com/:workspace/:project/models?group=GROUP_ID&api_key=$ROBOFLOW_API_KEY"
```

यह `समूह` मान प्रत्येक मॉडल ऑब्जेक्ट पर लौटाया गया NAS रन पहचानकर्ता है। यदि समूह किसी भी मॉडल से मेल नहीं खाता, तो एंडपॉइंट एक खाली array लौटाता है।

#### प्रतिक्रिया

एंडपॉइंट मॉडल ऑब्जेक्ट्स की एक JSON array लौटाता है:

```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 मॉडल फ़ील्ड**

द्वारा बनाए गए मॉडल [न्यूरल आर्किटेक्चर सर्च](https://docs.roboflow.com/models/train/neural-architecture-search) अतिरिक्त फ़ील्ड शामिल करते हैं:

```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"]
  }
}
```

| फ़ील्ड                     | प्रकार      | विवरण                                                                                                           |
| -------------------------- | ----------- | --------------------------------------------------------------------------------------------------------------- |
| `nasFamily`                | स्ट्रिंग    | `"child"` NAS से खोजे गए मॉडलों के लिए, `null` बेसलाइन के लिए                                                   |
| `समूह`                     | स्ट्रिंग    | NAS रन पहचानकर्ता, जो उसी रन के सभी मॉडलों में साझा होता है                                                     |
| `favorites`                | ऑब्जेक्ट    | उपयोगकर्ता IDs से पसंदीदा स्थिति का मानचित्र                                                                    |
| `recommended`              | बूलियन      | तब उपस्थित होता है और `true` होता है, जब यह मॉडल कम से कम एक मेट्रिक/हार्डवेयर संयोजन के लिए अनुशंसित विकल्प हो |
| `metrics.map5095`          | संख्या      | mAP\@50-95 स्कोर (प्रतिशत)                                                                                      |
| `metrics.f1`               | संख्या      | F1 स्कोर (प्रतिशत)                                                                                              |
| `metrics.hardware`         | स्ट्रिंग    | वह हार्डवेयर लक्ष्य जिस पर मॉडल का बेंचमार्क किया गया था (जैसे `"gpu"`, `"jetson-orin-nano"`)                   |
| `metrics.latency`          | संख्या      | लक्ष्य हार्डवेयर पर मिलीसेकंड में इनफ़रेंस लेटेंसी                                                              |
| `metrics.paretoOptimalFor` | स्ट्रिंग\[] | वे हार्डवेयर लक्ष्य जिनके लिए यह मॉडल Pareto frontier पर स्थित है                                               |

ये फ़ील्ड केवल NAS मॉडलों पर मौजूद होती हैं। मानक प्रशिक्षित मॉडल इससे प्रभावित नहीं होते।

## Python SDK

प्राप्त करें `वर्कस्पेस` उस वर्कस्पेस के लिए हैंडल, जिसके विरुद्ध आपका API key प्रमाणित होता है:

```python
import roboflow

rf = roboflow.Roboflow(api_key="YOUR_API_KEY")
workspace = rf.workspace()
```

हर Roboflow API key केवल एक ही वर्कस्पेस तक सीमित होती है। किसी दूसरे वर्कस्पेस के साथ काम करने के लिए, एक अलग API key का उपयोग करें (या सार्वजनिक Universe वर्कस्पेस के लिए, वर्कस्पेस स्लग पास करें):

```python
# सार्वजनिक Universe वर्कस्पेस - केवल आपका API key चाहिए।
public_ws = rf.workspace("roboflow-100")
```

### वर्कस्पेस गुण

लौटाया गया `वर्कस्पेस` ये उपलब्ध कराता है:

* `workspace.url` - वर्कस्पेस का URL स्लग (जैसे `my-workspace`).
* `workspace.name` - वर्कस्पेस का प्रदर्शित नाम।
* `workspace.list_projects()` - वर्कस्पेस में प्रोजेक्ट्स, dicts की सूची के रूप में।
* `workspace.projects()` - वही डेटा जैसा `list_projects()` लेकिन लौटाया गया एक `प्रोजेक्ट` ऑब्जेक्ट सूची (पुराना उपनाम)।
* `workspace.list_folders()` - देखें [फ़ोल्डर्स प्रबंधित करें](https://docs.roboflow.com/datasets/manage/project-folders#python-sdk).
* `workspace.list_workflows()` - देखें [वर्कफ़्लोज़ प्रबंधित करें](https://docs.roboflow.com/workflows/manage/manage-workflows#python-sdk).
* `workspace.get_plan()` और `workspace.get_usage()` - देखें [वर्कस्पेस योजना और उपयोग](/get-started/hi/platform/billing-and-plans/credits/view-credit-usage.md#python-sdk).

### प्रोजेक्ट और वर्ज़न सूचीबद्ध करें

#### प्रोजेक्ट सूचीबद्ध करें

अपने वर्कस्पेस में प्रोजेक्ट्स प्राप्त करें:

```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"])
```

प्रत्येक प्रविष्टि में प्रोजेक्ट का id (URL स्लग), प्रदर्शित नाम, प्रोजेक्ट प्रकार, इमेज गिनती, और कुछ अन्य मेटाडेटा फ़ील्ड शामिल होती हैं।

किसी सार्वजनिक Universe वर्कस्पेस के साथ काम करने के लिए, उसका स्लग पास करें:

```python
universe_ws = rf.workspace("roboflow-100")
```

#### प्रोजेक्ट प्राप्त करें

```python
project = workspace.project("my-detector")
```

या शीर्ष-स्तरीय शॉर्टकट का उपयोग करें:

```python
project = rf.project("my-detector")
```

#### वर्ज़न सूचीबद्ध करें

```python
for version in project.versions():
    print(version.version, version.name)
```

`project.versions()` लौटाता है `वर्ज़न` ऑब्जेक्ट, जिन पर आप सीधे मेथड कॉल कर सकते हैं (`download`, `train`, `delete`, आदि)। हल्की dict प्रतिक्रिया के लिए, उपयोग करें `project.list_versions()` या `project.get_version_information()`.

#### एक वर्ज़न प्राप्त करें

```python
version = project.version(3)
```

संख्यात्मक - वर्ज़न 1 से इंडेक्स किए जाते हैं।

## CLI

### वर्कस्पेस सूचीबद्ध करें

CLI के साथ आप उन सभी वर्कस्पेस की सूची प्राप्त कर सकते हैं जिनके आप सदस्य हैं।

CLI के साथ वर्कस्पेस सूचीबद्ध करने के लिए, निम्न कमांड का उपयोग करें:

<pre class="language-bash"><code class="lang-bash"><strong>roboflow workspace list
</strong></code></pre>

यह संबंधित application links और Workspace IDs के साथ वर्कस्पेस की सूची लौटाएगा:

```
नाम             ID               डिफ़ॉल्ट
My Workspace     my-workspace     *
Other Workspace  other-ws
```

आउटपुट को JSON के रूप में प्राप्त करने के लिए (स्क्रिप्ट या AI एजेंटों में उपयोग हेतु):

```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}
]
```

### किसी वर्कस्पेस में प्रोजेक्ट सूचीबद्ध करें

किसी वर्कस्पेस में प्रोजेक्ट सूचीबद्ध करने के लिए, निम्न कमांड का उपयोग करें:

```bash
roboflow project list
```

यदि आपने एक डिफ़ॉल्ट वर्कस्पेस कॉन्फ़िगर किया है, तो `-w` फ्लैग वैकल्पिक है। अन्यथा, इसे निर्दिष्ट करें:

```bash
roboflow project list -w WORKSPACE_ID
```

यह प्रोजेक्ट्स की एक तालिका लौटाएगा:

```
नाम              ID                              प्रकार                वर्ज़न  छवियाँ
my-dataset        my-workspace/my-dataset         object-detection    3         500
classifier        my-workspace/classifier         classification      1         200
```

आउटपुट JSON के रूप में प्राप्त करने के लिए:

```bash
roboflow project list --json
```

### प्रोजेक्ट प्राप्त करें

किसी प्रोजेक्ट के बारे में विस्तृत जानकारी प्राप्त करने के लिए, निम्न कमांड का उपयोग करें:

```bash
roboflow project get PROJECT_ID
```

आप संसाधन शॉर्टहैंड का उपयोग कर सकते हैं - वर्कस्पेस को अलग से निर्दिष्ट करने की आवश्यकता नहीं है:

```bash
roboflow project get my-dataset              # डिफ़ॉल्ट वर्कस्पेस का उपयोग करता है
roboflow project get my-workspace/my-dataset  # स्पष्ट वर्कस्पेस
```

यह प्रोजेक्ट के बारे में जानकारी लौटाएगा, जिसमें इसके वर्ज़न शामिल हैं:

```
प्रोजेक्ट: my-dataset
  ID: my-workspace/my-dataset
  प्रकार: object-detection
  छवियाँ: 500
  वर्ज़न: 3
  क्लासेस: car (200), truck (150), bus (150)
  लिंक: https://app.roboflow.com/my-workspace/my-dataset
```

पूर्ण JSON प्रतिक्रिया प्राप्त करने के लिए:

```bash
roboflow project get my-dataset --json
```