> 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 प्रबंधित करें

## के बारे में

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

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

### प्रोजेक्ट बेस Workflows

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

#### एक प्रोजेक्ट बेस 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, चयनित मॉडल, उसकी डिप्लॉय-योग्यता, और उसकी 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": "मेरा प्रोजेक्ट बेस Workflow",
    "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 मध्यम",
    "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 इन्फ़रेंस सर्व नहीं कर सकता। `baseWorkflowWasCreated` यह बताता है कि क्या इस अनुरोध ने बेस Workflow बनाया था।

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

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

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

सेट करें `model.type` को `"model_id"`, `"sam3"`या `"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"` और `"clip"`एक गैर-खाली `classes` ऐरे के बजाय `modelId`:

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

वर्कस्पेस में सभी वर्कफ़्लोज़ की सूची देता है।

**क्वेरी**

<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>स्ट्रिंग</td><td>वर्कस्पेस के लिए API कुंजी।</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",
      "name": "धीमे वेबहुक्स",
      "url": "slow-webhooks",
      "createdAt": "2026-04-12T17:05:33.000Z"
    }
  ],
  "status": "ok"
}
```

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

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

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

Workflow का विनिर्देशन, मेटाडेटा, और (गैर-सार्वजनिक workflows के लिए) प्राधिकरण स्थिति लौटाता है।

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

सार्वजनिक workflows को बिना एक `api_key`तक एक्सेस किया जा सकता है। निजी workflows को `workflow:read` स्कोप की आवश्यकता होती है।

### 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"
```

Workflow विनिर्देशन के संस्करणित स्नैपशॉट लौटाता है।

### एक 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>स्ट्रिंग</td><td>वर्कस्पेस API कुंजी।</td><td>true</td></tr><tr><td><code>नाम</code></td><td>स्ट्रिंग</td><td>प्रदर्शित नाम।</td><td>true</td></tr><tr><td><code>url</code></td><td>स्ट्रिंग</td><td>Workflow के लिए URL स्लग।</td><td>true</td></tr><tr><td><code>config</code></td><td>स्ट्रिंग</td><td>JSON-एन्कोडेड Workflow विनिर्देशन (नीचे दिए गए नोट को देखें)।</td><td>true</td></tr><tr><td><code>template</code></td><td>स्ट्रिंग</td><td>JSON-एन्कोडेड टेम्पलेट मेटाडेटा। <code>"{}"</code> यदि आपके पास कोई नहीं है, तो पास करें।</td><td>false</td></tr></tbody></table>

**पर नोट `config`**: API संग्रहीत आकार की अपेक्षा करता है `{"specification": {...}}`. केवल स्पेसिफिकेशन पास करना SDK एडाप्टर के माध्यम से काम करता है, जो इसे अपने आप लपेट देता है; सीधे REST कॉल के लिए, इसे स्वयं लपेटें।

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

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

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

```bash
curl -X POST "https://api.roboflow.com/my-workspace/createWorkflow" \\
  --get \\
  --data-urlencode "api_key=$ROBOFLOW_API_KEY" \\
  --data-urlencode "name=मेरा 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>स्ट्रिंग</td><td>Workflow का आंतरिक ID।</td><td>true</td></tr><tr><td><code>नाम</code></td><td>स्ट्रिंग</td><td>प्रदर्शित नाम।</td><td>true</td></tr><tr><td><code>url</code></td><td>स्ट्रिंग</td><td>URL स्लग।</td><td>true</td></tr><tr><td><code>config</code></td><td>स्ट्रिंग</td><td>JSON-एन्कोडेड Workflow विनिर्देशन (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":"मेरा Workflow","url":"my-workflow","config":"{\"specification\":{\"version\":\"1.0\",\"steps\":[]}}"}'
```

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

### एक Workflow Fork करें

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

एक workflow को किसी दूसरे workspace से इसमें कॉपी करें।

**बॉडी**

<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>स्ट्रिंग</td><td>उस workspace का स्लग जो स्रोत workflow का स्वामी है।</td><td>true</td></tr><tr><td><code>source_workflow</code></td><td>स्ट्रिंग</td><td>स्रोत workflow का URL स्लग।</td><td>true</td></tr><tr><td><code>नाम</code></td><td>स्ट्रिंग</td><td>Fork के लिए प्रदर्शित नाम। डिफ़ॉल्ट रूप से स्रोत नाम होगा।</td><td>false</td></tr><tr><td><code>url</code></td><td>स्ट्रिंग</td><td>Fork के लिए URL स्लग। यदि छोड़ा जाए तो अपने आप जनरेट हो जाता है।</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":"मेरा Fork","url":"my-fork"}'
```

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

### Workflow टोकन जनरेट करें

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

एक अल्पकालिक टोकन जनरेट करें जो सार्वजनिक क्लाइंट (जैसे ब्राउज़र) से 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) प्रतिक्रिया संरचना और पुनर्स्थापना प्रवाह के लिए।

### एक Workflow चलाएँ

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

## Python SDK

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

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

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

```

### एक वर्कफ़्लो प्राप्त करें

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

```

यह `url` तर्क वर्कफ़्लो का slug है (वेब ऐप की URL पट्टी में दिखाई देता है) - इसका Firestore id नहीं।

### एक वर्कफ़्लो बनाएं

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

```

पास करें `definition=None` ताकि एक खाली वर्कफ़्लो शेल बनाया जा सके जिसे आप बाद में वेब ऐप में संपादित करेंगे।

SDK या तो एक सादा स्पेसिफिकेशन dict (`{"version": ..., "steps": ...}`) या एक रैप किया हुआ (`{"specification": {...}}`); यह आपके लिए रैपिंग को सामान्य करता है और मौजूद होने पर UTF-8 BOM हटा देता है।

### एक वर्कफ़्लो अपडेट करें

`Workspace` update को सीधे उपलब्ध नहीं कराता - निम्न-स्तरीय एडाप्टर का उपयोग करें:

```python
from roboflow.adapters import rfapi

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

### वर्कफ़्लो फोर्क करें

किसी दूसरे Workspace से एक वर्कफ़्लो को अपने Workspace में कॉपी करें। सार्वजनिक टेम्पलेट अपनाने के लिए उपयोगी:

```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="My Fork",       # वैकल्पिक; डिफ़ॉल्ट स्रोत नाम होगा
    url="my-fork",        # वैकल्पिक; डिफ़ॉल्ट रूप से एक जनरेट किया गया slug होगा
)
```

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

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

### एक वर्कफ़्लो हटाएं (सॉफ्ट-डिलीट)

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

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

### वर्कफ़्लो चलाएं

वर्कफ़्लो निष्पादन इसमें होता है [Inference SDK](https://inference.roboflow.com) और [वर्कफ़्लो रनटाइम](/workflows/hi/deploy/deploy-a-workflow.md), न कि `roboflow` पैकेज। 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

आप कमांड लाइन से वर्कफ़्लो सूचीबद्ध, बना, अपडेट, फोर्क, और संस्करणित कर सकते हैं।

### वर्कफ़्लोज़ की सूची बनाएं

```bash
roboflow workflow list
```

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

### वर्कफ़्लो विवरण प्राप्त करें

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

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

### एक Workflow बनाएं

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

एक JSON परिभाषा फ़ाइल के साथ:

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

#### विकल्प

| ध्वज            | विवरण                    |
| --------------- | ------------------------ |
| `--name`        | वर्कफ़्लो नाम (आवश्यक)   |
| `--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 करें

वर्तमान workspace से एक workflow fork करें:

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

किसी अन्य workspace से fork करें:

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

### JSON आउटपुट

सभी workflow कमांड समर्थन करते हैं `--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) और यह इन टूल्स के साथ Workflows बना और चला सकता है:

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