> 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/workflows/hi/manage/manage-workflows.md).

# Workflows प्रबंधित करें

REST API और Python SDK के माध्यम से एक workspace में Workflows की सूची बनाएँ, प्राप्त करें, बनाएं और अपडेट करें।

## के बारे में

[Roboflow Workflows](/workflows/hi/build/create-a-workflow.md) वे विज़ुअल कंप्यूटर-विज़न पाइपलाइन हैं जिन्हें आप वेब ऐप में बनाते हैं और एक होस्ट किए गए एंडपॉइंट के रूप में डिप्लॉय करते हैं। यह पेज प्रबंधन सतह — सूची बनाना, प्राप्त करना, बनाना, और वर्कस्पेस में Workflows को अपडेट करना — को REST API और Python SDK के माध्यम से कवर करता है। किसी छवि या वीडियो स्ट्रीम पर एक Workflow चलाने के लिए, देखें [वर्कफ़्लोज़ रनटाइम दस्तावेज़](/workflows/hi/deploy/deploy-a-workflow.md).

## HTTP API

[Roboflow Workflows](/workflows/hi/build/create-a-workflow.md) वे विज़ुअल कंप्यूटर-विज़न पाइपलाइन हैं जिन्हें आप वेब ऐप में बना सकते हैं और एक होस्ट किए गए एंडपॉइंट के रूप में डिप्लॉय कर सकते हैं। REST API प्रबंधन सतह को एक्सपोज़ करती है; किसी छवि या वीडियो स्ट्रीम के विरुद्ध workflow निष्पादित करने के लिए, देखें [छवि पर मॉडल चलाएँ](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api#http-api) और [वर्कफ़्लोज़ रनटाइम दस्तावेज़](/workflows/hi/deploy/deploy-a-workflow.md).

`api_key` क्वेरी पैरामीटर के रूप में या अनुरोध बॉडी में पास किया जा सकता है। आवश्यक स्कोप प्रत्येक एंडपॉइंट पर दर्शाए गए हैं।

### प्रोजेक्ट बेस वर्कफ़्लोज़

प्रत्येक प्रोजेक्ट में एक बेस Workflow होता है जो उसके होस्ट किए गए मॉडल एंडपॉइंट को सपोर्ट करता है। उस Workflow को पढ़ने के लिए, या उसके model step द्वारा उपयोग किए गए मॉडल को चुनने के लिए, इन Project-scoped operations का उपयोग करें।

#### एक प्रोजेक्ट बेस Workflow प्राप्त करें

<mark style="color:हरा;">`GET`</mark> `/:workspace/:project/deploy`

आवश्यक स्कोप: `project:read`

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

यदि प्रोजेक्ट के पास बेस Workflow नहीं है, तो यह अनुरोध एक बनाता है। प्रतिक्रिया प्रोजेक्ट, उसका बेस Workflow, चयनित मॉडल, उसकी deployability, और उसकी Active Learning स्थिति की पहचान करती है:

```json
{
  "project": {
    "id": "abc123",
    "url": "my-project",
    "name": "मेरा प्रोजेक्ट",
    "owner": "my-workspace-id",
    "type": "object-detection",
    "classes": ["बिल्ली", "कुत्ता"],
    "multilabel": false
  },
  "workflow": {
    "id": "wf_xyz",
    "name": "मेरा प्रोजेक्ट बेस वर्कफ़्लो",
    "url": "my-project-base-workflow",
    "workspaceUrl": "my-workspace",
    "inferencePath": "/infer/workflows/my-workspace/my-project-base-workflow"
  },
  "model": {
    "id": "rfdetr-medium",
    "kind": "pretrained",
    "displayName": "RF-DETR Medium",
    "modelId": "rfdetr-medium"
  },
  "deployability": {
    "status": "deployable",
    "modelWasConfigured": false,
    "selectedModelId": null,
    "selectionReason": null
  },
  "activeLearning": {
    "enabled": false,
    "collectionLimits": {
      "dataPercentage": 100,
      "minutelyUsageLimit": 10,
      "hourlyUsageLimit": 100,
      "dailyUsageLimit": 1000,
      "labelingBatchesRecreationFrequency": "daily",
      "usageQuotaName": "upload_quota_active_learning",
      "imageCompressionLevel": 95,
      "maxImageHeight": 1080,
      "maxImageWidth": 1920,
      "persistPredictions": true
    },
    "filters": []
  },
  "baseWorkflowWasCreated": false
}
```

`मॉडल` है `null` जब कोई मॉडल कॉन्फ़िगर न हो। `deployability.status` है `"not_deployable"` जब Workflow inference सर्व नहीं कर सकता। `baseWorkflowWasCreated` बताता है कि क्या इस अनुरोध ने बेस Workflow बनाया था।

#### एक प्रोजेक्ट बेस Workflow मॉडल चुनें

<mark style="color:हरा;">`POST`</mark> `/:workspace/:project/deploy/model`

आवश्यक स्कोप: `project:update`

सेट करें `model.type` को `"model_id"`, `"sam3"`, `"astra"`, `"gemini"`, या `"clip"`:

```bash
curl -X POST "https://api.roboflow.com/my-workspace/my-project/deploy/model" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "'$ROBOFLOW_API_KEY'",
    "model": {
      "type": "model_id",
      "modelId": "rfdetr-medium"
    }
  }'
```

के लिए `"model_id"`, `modelId` आवश्यक है। `displayName` और `taskType` वैकल्पिक हैं। के लिए `"sam3"`, `"astra"`, `"gemini"`, और `"clip"`, एक गैर-रिक्त `classes` array के बजाय `modelId`. `"astra"` (GPT-6 Astra) और `"gemini"` (Gemini 3.8 Flash) केवल zero-shot object-detection मॉडल हैं; किसी अन्य प्रकार के प्रोजेक्ट पर इनमें से किसी को चुनना विफल होता है:

```json
{
  "api_key": "YOUR_API_KEY",
  "model": {
    "type": "sam3",
    "classes": ["बिल्ली", "कुत्ता"]
  }
}
```

प्रतिक्रिया का आकार इसके समान होता है [एक प्रोजेक्ट बेस Workflow प्राप्त करें](#get-a-project-base-workflow). एक `400` प्रतिक्रिया का अर्थ है कि `मॉडल` मान गायब है या अमान्य है।

डेटा संग्रह सक्षम करने, संग्रह सीमाएँ सेट करने, या समीक्षा कतार में छवियों की सूची बनाने के लिए, उपयोग करें [Active Learning HTTP API](https://docs.roboflow.com/deployment/monitoring-and-analytics/active-learning#http-api).

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

<mark style="color:हरा;">`GET`</mark> `/:workspace/workflows`

वर्कस्पेस में सभी workflows सूचीबद्ध करता है।

**क्वेरी**

<table data-search="false"><thead><tr><th>नाम</th><th>प्रकार</th><th>विवरण</th><th data-type="checkbox">आवश्यक</th></tr></thead><tbody><tr><td><code>api_key</code></td><td>string</td><td>वर्कस्पेस के लिए API key।</td><td>true</td></tr></tbody></table>

**उदाहरण अनुरोध**

```bash
curl "https://api.roboflow.com/my-workspace/workflows?api_key=$ROBOFLOW_API_KEY"
```

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

```json
{
  "workflows": [
    {
      "id": "wf_abc123",
      धीमे वेबहुक्स
      "url": "slow-webhooks",
      "createdAt": "2026-04-12T17:05:33.000Z"
    }
  ],
  "status": "ok"
}
```

आवश्यक स्कोप: `workflow:read`.

### एक Workflow प्राप्त करें

<mark style="color:हरा;">`GET`</mark> `/:workspace/workflows/:workflowUrl`

वर्कफ़्लो का specification, metadata, और (गैर-public workflows के लिए) authorization status लौटाता है।

```bash
curl "https://api.roboflow.com/my-workspace/workflows/slow-webhooks?api_key=$ROBOFLOW_API_KEY"
```

Public workflows को बिना किसी के एक्सेस किया जा सकता है `api_key`. Private workflows के लिए आवश्यक है `workflow:read` scope।

### Workflow संस्करण सूचीबद्ध करें

<mark style="color:हरा;">`GET`</mark> `/:workspace/workflows/:workflowUrl/versions`

```bash
curl "https://api.roboflow.com/my-workspace/workflows/slow-webhooks/versions?api_key=$ROBOFLOW_API_KEY"
```

वर्कफ़्लो specification के संस्करणयुक्त snapshots लौटाता है।

### एक Workflow बनाएं

<mark style="color:हरा;">`POST`</mark> `/:workspace/createWorkflow`

**हेडर**

| नाम          | मान                |
| ------------ | ------------------ |
| Content-Type | `application/json` |

**बॉडी**

<table data-search="false"><thead><tr><th width="180">नाम</th><th width="140">प्रकार</th><th>विवरण</th><th data-type="checkbox">आवश्यक</th></tr></thead><tbody><tr><td><code>api_key</code></td><td>string</td><td>वर्कस्पेस API key।</td><td>true</td></tr><tr><td><code>name</code></td><td>string</td><td>प्रदर्शित नाम।</td><td>true</td></tr><tr><td><code>url</code></td><td>string</td><td>वर्कफ़्लो के लिए URL slug।</td><td>true</td></tr><tr><td><code>config</code></td><td>string</td><td>JSON-encoded workflow specification (नीचे दिए गए नोट को देखें)।</td><td>true</td></tr><tr><td><code>template</code></td><td>string</td><td>JSON-encoded template metadata। दें <code>"{}"</code> यदि आपके पास एक नहीं है।</td><td>false</td></tr></tbody></table>

**पर नोट `config`**: API को संग्रहीत रूप की अपेक्षा होती है `{"specification": {...}}`. एक bare specification भेजना SDK adapter के माध्यम से काम करता है, जो इसे स्वतः wrap कर देता है; सीधे REST calls के लिए, इसे स्वयं wrap करें।

**उदाहरण अनुरोध**

```bash
curl -X POST "https://api.roboflow.com/my-workspace/createWorkflow" \
  -H 'Content-Type: application/json' \
  -d '{"api_key":"'$ROBOFLOW_API_KEY'","name":"My Workflow","url":"my-workflow","config":"{\"specification\":{\"version\":\"1.0\",\"inputs\":[],\"steps\":[],\"outputs\":[]}}"}'
```

आप वही फ़ील्ड query parameters के रूप में भी भेज सकते हैं, लेकिन तब `template` आवश्यक है। बड़ी specifications के लिए body का उपयोग करें, क्योंकि लंबे URLs कट जाते हैं।

```bash
curl -X POST "https://api.roboflow.com/my-workspace/createWorkflow" \
  --get \
  --data-urlencode "api_key=$ROBOFLOW_API_KEY" \
  --data-urlencode "name=My Workflow" \
  --data-urlencode "url=my-workflow" \
  --data-urlencode 'config={"specification":{"version":"1.0","inputs":[],"steps":[],"outputs":[]}}' \
  --data-urlencode 'template={}'
```

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

```json
{
  "workflows": { "id": "wf_xyz789", "url": "my-workflow" },
  "status": "ok"
}
```

आवश्यक स्कोप: `workflow:create`.

### एक Workflow अपडेट करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/updateWorkflow`

**हेडर**

| नाम          | मान                |
| ------------ | ------------------ |
| Content-Type | `application/json` |

**बॉडी**

<table data-search="false"><thead><tr><th>नाम</th><th>प्रकार</th><th>विवरण</th><th data-type="checkbox">आवश्यक</th></tr></thead><tbody><tr><td><code>id</code></td><td>string</td><td>Workflow का आंतरिक ID।</td><td>true</td></tr><tr><td><code>name</code></td><td>string</td><td>प्रदर्शित नाम।</td><td>true</td></tr><tr><td><code>url</code></td><td>string</td><td>URL slug।</td><td>true</td></tr><tr><td><code>config</code></td><td>string</td><td>JSON-encoded workflow specification (Create पर नोट देखें)।</td><td>true</td></tr></tbody></table>

```bash
curl -X POST "https://api.roboflow.com/my-workspace/updateWorkflow?api_key=$ROBOFLOW_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"id":"wf_xyz789","name":"My Workflow","url":"my-workflow","config":"{\"specification\":{\"version\":\"1.0\",\"steps\":[]}}"}'
```

आवश्यक स्कोप: `workflow:update`.

### एक Workflow Fork करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/forkWorkflow`

किसी अन्य workspace से एक workflow को इसमें कॉपी करें।

**बॉडी**

<table data-search="false"><thead><tr><th>नाम</th><th>प्रकार</th><th>विवरण</th><th data-type="checkbox">आवश्यक</th></tr></thead><tbody><tr><td><code>source_workspace</code></td><td>string</td><td>उस workspace का slug जो source workflow का स्वामी है।</td><td>true</td></tr><tr><td><code>source_workflow</code></td><td>string</td><td>source workflow का URL slug।</td><td>true</td></tr><tr><td><code>name</code></td><td>string</td><td>fork के लिए प्रदर्शित नाम। डिफ़ॉल्ट रूप से source name।</td><td>false</td></tr><tr><td><code>url</code></td><td>string</td><td>fork के लिए URL slug। छोड़ने पर स्वतः उत्पन्न होता है।</td><td>false</td></tr></tbody></table>

```bash
curl -X POST "https://api.roboflow.com/my-workspace/forkWorkflow?api_key=$ROBOFLOW_API_KEY" \
  -H 'Content-Type: application/json' \
  -d '{"source_workspace":"other-workspace","source_workflow":"their-workflow","name":"My Fork","url":"my-fork"}'
```

आवश्यक स्कोप: `workflow:create`.

### एक Workflow Token जनरेट करें

<mark style="color:हरा;">`POST`</mark> `/:workspace/workflowToken`

एक अल्पकालिक token जनरेट करें जो public client (जैसे browser) से workflow निष्पादित करने के लिए उपयुक्त हो।

```bash
curl -X POST "https://api.roboflow.com/my-workspace/workflowToken?api_key=$ROBOFLOW_API_KEY"
```

### एक Workflow हटाएँ (soft-delete करें)

<mark style="color:लाल;">`DELETE`</mark> `/:workspace/workflows/:workflowUrl`

Workflow को Trash में ले जाता है। देखें [Trash प्रबंधित करें](https://docs.roboflow.com/platform/workspaces/trash#delete-a-workflow) प्रतिक्रिया के स्वरूप और पुनर्स्थापना flow के लिए।

### एक Workflow चलाएँ

Workflow निष्पादन यहाँ होता है `https://serverless.roboflow.com`, management API में नहीं। देखें [छवि पर मॉडल चलाएँ](https://docs.roboflow.com/deployment/roboflow-cloud/serverless-api#http-api) और उत्पाद दस्तावेज़ देखें [एक workflow को deploy करना](/workflows/hi/deploy/deploy-a-workflow.md).

## Python SDK

[Roboflow Workflows](/workflows/hi/build/create-a-workflow.md) वे विज़ुअल कंप्यूटर-विज़न पाइपलाइन हैं। SDK सूची / प्राप्त / बनाना सीधे `वर्कस्पेस`; update, fork, और delete लो-लेवल में होते हैं `rfapi` adapter में।

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

```python
import roboflow

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

workflows = workspace.list_workflows()
for w in workflows:
    print(w["id"], w["name"], w["url"] )
```

### एक workflow प्राप्त करें

```python
workflow = workspace.get_workflow("slow-webhooks")
print(workflow["specification"] )
```

The `url` argument workflow का slug है (web app की URL बार में दिखाई देता है) - इसका Firestore id नहीं।

### एक workflow बनाएं

```python
workflow = workspace.create_workflow(
    name="मेरा Workflow",
    definition={
        "version": "1.0",
        "inputs": [...],
        "steps": [...],
        "outputs": [...],
    },
)
print(workflow["id"], workflow["url"])
```

पास करें `definition=None` एक खाली workflow shell बनाने के लिए, जिसे आप बाद में web app में संपादित करेंगे।

SDK एक bare specification dict (`{"version": ..., "steps": ...}`) या एक wrapped one (`{"specification": {...}}`{"specification": {...}}

### एक workflow अपडेट करें

`वर्कस्पेस` update को सीधे एक्सपोज़ नहीं करता - low-level adapter का उपयोग करें:

```python
from roboflow.adapters import rfapi

rfapi.update_workflow(
    api_key="YOUR_API_KEY",
    workspace_url=workspace.url,
    workflow_id=workflow["id"],
    workflow_name="मेरा Workflow",
    workflow_url="my-workflow",
    config={"version": "1.0", "steps": [...]},
)
```

### एक workflow fork करें

किसी अन्य workspace से एक workflow को अपने workspace में कॉपी करें। public template अपनाने के लिए उपयोगी:

```python
from roboflow.adapters import rfapi

forked = rfapi.fork_workflow(
    api_key="YOUR_API_KEY",
    workspace_url=workspace.url,
    source_workspace="other-workspace",
    source_workflow="their-workflow",
    name="मेरा फ़ोर्क",       # वैकल्पिक; डिफ़ॉल्ट रूप से source name
    url="my-fork",        # वैकल्पिक; डिफ़ॉल्ट रूप से एक generated slug
)
```

### workflow संस्करण सूचीबद्ध करें

```python
versions = rfapi.list_workflow_versions(
    api_key="YOUR_API_KEY",
    workspace_url=workspace.url,
    workflow_url="my-workflow",
)
```

### एक workflow हटाएँ (soft-delete करें)

```python
rfapi.delete_workflow(api_key="YOUR_API_KEY", workspace_url=workspace.url, workflow_url="my-workflow")
```

यह workflow को workspace के [Trash](https://docs.roboflow.com/platform/workspaces/trash#python-sdk) में ले जाता है, जहाँ यह स्थायी सफ़ाई से पहले 30 दिनों तक रहता है। इसके माध्यम से पुनर्स्थापित करें `Workspace.restore_from_trash("workflow", id)` - देखें [हटाना और पुनर्स्थापित करना](https://docs.roboflow.com/platform/workspaces/trash#workflows).

### एक workflow चलाएँ

Workflow निष्पादन इसमें होता है [Inference SDK](https://inference.roboflow.com) और [Workflows रनटाइम](/workflows/hi/deploy/deploy-a-workflow.md), न कि `roboflow` package में। Python से:

```python
from inference_sdk import InferenceHTTPClient, InferenceConfiguration

client = InferenceHTTPClient(
    api_url="https://serverless.roboflow.com",
    api_key="YOUR_API_KEY",
).configure(InferenceConfiguration(api_key_transport="header"))
result = client.run_workflow(
    workspace_name="my-workspace",
    workflow_id="my-workflow",
    images={"image": "photo.jpg"},
)
```

## CLI

आप command line से workflows को सूचीबद्ध, बनाना, अपडेट, fork, और version कर सकते हैं।

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

```bash
roboflow workflow list
```

```bash
roboflow workflow list --json
```

### Workflow विवरण प्राप्त करें

```bash
roboflow workflow get my-workflow
```

```bash
roboflow workflow get my-workflow --json
```

### एक Workflow बनाएं

```bash
roboflow workflow create --name "My Workflow"
```

एक JSON definition file के साथ:

```bash
roboflow workflow create --name "My Workflow" --definition workflow.json
```

#### विकल्प

| फ़्लैग          | विवरण                    |
| --------------- | ------------------------ |
| `--name`        | Workflow नाम (आवश्यक)    |
| `--definition`  | JSON परिभाषा फ़ाइल का पथ |
| `--description` | वर्कफ़्लो विवरण          |

### एक Workflow अपडेट करें

किसी वर्कफ़्लो की परिभाषा अपडेट करें:

```bash
roboflow workflow update my-workflow --definition updated.json
```

### Workflow संस्करण सूचीबद्ध करें

```bash
roboflow workflow version list my-workflow
```

```bash
roboflow workflow version list my-workflow --json
```

### एक Workflow Fork करें

वर्तमान कार्यस्थान से एक वर्कफ़्लो का फ़ॉर्क करें:

```bash
roboflow workflow fork my-workflow
```

किसी दूसरे कार्यस्थान से फ़ॉर्क करें:

```bash
roboflow workflow fork other-workspace/their-workflow
```

### JSON आउटपुट

सभी वर्कफ़्लो कमांड समर्थन करते हैं `--json` संरचित आउटपुट के लिए:

```bash
roboflow workflow list --json | jq '.[].name'
roboflow workflow create --name "Test" --json
```

निकास कोड: 0 = सफल, 1 = त्रुटि, 2 = प्रमाणीकरण त्रुटि, 3 = नहीं मिला।

## MCP सर्वर

अपने AI एजेंट को कनेक्ट करें [MCP सर्वर](https://docs.roboflow.com/agents/mcp-server) और यह इन टूल्स के साथ वर्कफ़्लो बना और चला सकता है:

<table data-search="false"><thead><tr><th width="290">टूल</th><th>विवरण</th></tr></thead><tbody><tr><td><code>workflows_list</code></td><td>कार्यस्थान में सहेजे गए वर्कफ़्लो की सूची बनाएं।</td></tr><tr><td><code>workflows_get</code></td><td>सहेजे गए वर्कफ़्लो का विवरण प्राप्त करें।</td></tr><tr><td><code>workflows_create</code></td><td>एक नया वर्कफ़्लो बनाएं और सहेजें।</td></tr><tr><td><code>workflows_update</code></td><td>सहेजे गए वर्कफ़्लो का नाम और परिभाषा अपडेट करें।</td></tr><tr><td><code>workflows_run</code></td><td>एक या अधिक छवियों पर सहेजे गए वर्कफ़्लो को निष्पादित करें।</td></tr><tr><td><code>workflows_delete</code></td><td>सहेजे गए वर्कफ़्लो को हटाएं, और उसे कार्यस्थान के ट्रैश में ले जाएं।</td></tr></tbody></table>