> 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/deployment/hi/roboflow-cloud/cloud-streaming/live-results.md).

# लाइव नतीजे

WebSocket फ़ीड के ज़रिए चल रहे Cloud Streaming जॉब के हर JSON नतीजे को अपने ऐप्लिकेशन में पाएँ और कनेक्शन टूटने के बाद फिर से वहीं से शुरू करें।

लाइव परिणाम फ़ीड एक WebSocket है, जो चलते हुए Cloud Streaming जॉब का हर JSON परिणाम आपके एप्लिकेशन तक Workflow द्वारा तैयार किए जाने के साथ ही पहुँचाता है। परिणाम क्रमांकित होते हैं, इसलिए आपका क्लाइंट फिर से कनेक्ट कर सकता है, उसे प्राप्त हुए आखिरी परिणाम के बाद से आगे जारी रख सकता है और यह देख सकता है कि कोई परिणाम छूट गया है या नहीं।

जब आपकी सेवा को हर प्रोसेस किए गए फ़्रेम का परिणाम चाहिए (जैसे: गिनती करना, लॉग करना या डैशबोर्ड चलाना), तो इस फ़ीड का उपयोग करें। केवल चुने हुए परिणामों को HTTPS एंडपॉइंट पर भेजने के लिए, उपयोग करें [Workflow sink](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming/consume-results.md#send-results-with-a-workflow-sink)। एनोटेट किया हुआ वीडियो देखने के लिए, अनुरोध करें [watch grant](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming/consume-results.md#watch-live-output).

फ़ीड, स्ट्रीमिंग विकल्प है। सब्सक्रिप्शन एक `pollUrl` भी लौटाता है, जो उन्हीं परिणामों को सीमित JSON पेजों के रूप में उपलब्ध कराता है—उन क्लाइंट के लिए जो WebSocket को खुला नहीं रख सकते। सर्वर-सेंट इवेंट्स के लिए यह कोई URL नहीं लौटाता।

{% hint style="info" %}
फ़ीड केवल तब उपलब्ध होती है, जब कोई जॉब क्लेम की गई हो या चल रही हो। ऐसे किसी अन्य जॉब के लिए जो अभी समाप्त नहीं हुई है, सब्सक्रिप्शन फ़ीड के बजाय `retryAfterSeconds` लौटाता है। कनेक्ट करने से पहले के परिणाम संग्रहित नहीं होते: परिणाम सुरक्षित रखने के लिए, फ़ीड को लगातार पढ़ें या Workflow sink का उपयोग करें।
{% endhint %}

## शुरू करने से पहले

आपको चाहिए:

* एक Cloud Streaming जॉब। [HTTP API से एक शुरू करें](https://docs.roboflow.com/deployment/hi/roboflow-cloud/cloud-streaming/run-a-workflow.md#http-api) या Web App में शुरू करके उसका job ID कॉपी करें।
* एक workspace API key, जिसमें `video-inference-job:read` स्कोप हो। देखें [scoped API keys](https://docs.roboflow.com/reference/authentication/authentication/scoped-api-keys)। इस key को अपने सर्वर पर रखें।

परिणाम पढ़ने के लिए दो चरण हैं: Roboflow API से पूछें कि जॉब की फ़ीड कहाँ है, फिर उससे मिले WebSocket को खोलें।

## किसी जॉब की सदस्यता लें

सब्सक्राइब करने से जॉब में कोई बदलाव नहीं होता और वीडियो शुरू नहीं होता। हर कनेक्शन से पहले और कनेक्शन समाप्त होने पर फिर से इसे कॉल करें।

{% openapi src="/files/b0e522ab41386af273dcd678aa1bfa8c7468d95d" path="/{workspace}/video-jobs/v1/{jobId}/results/subscribe" method="post" %}
[cloud-streaming.yaml](https://2297977984-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoksNmwps1HmYr8TqHDnX%2Fuploads%2Fgit-blob-2927c06848d4341631bbd3bafea073b855e32b47%2Fcloud-streaming.yaml?alt=media)
{% endopenapi %}

जवाब तीन में से एक होगा। उन्हें इस क्रम में जाँचें:

1. `ended` का मान `true`है: जॉब अब और परिणाम नहीं देगी। अगर `successorJobId` मौजूद है, तो जॉब उस ID के तहत जारी रहती है, इसलिए उसकी सदस्यता लें। अन्यथा रुक जाएँ।
2. `retryAfterSeconds` मौजूद है: जॉब की फ़ीड अभी उपलब्ध नहीं है (जैसे: वह कतार में है, अपने स्रोत की प्रतीक्षा कर रही है या फिर से शुरू हो रही है)। उतने सेकंड प्रतीक्षा करें और फिर से सब्सक्राइब करें।
3. `eventsUrl` और `accessToken` मौजूद हैं: फ़ीड से कनेक्ट करें।

## फ़ीड से कनेक्ट करें

यहाँ WebSocket खोलें `eventsUrl` को, जैसा लौटाया गया है ठीक वैसा ही, और `accessToken` को इस `Authorization` हेडर में भेजें:

```
GET /PROCESSOR_ID/events/ws?job=JOB_ID HTTP/1.1
Host: processor.example.invalid
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Version: 13
Sec-WebSocket-Key: ...
Authorization: Bearer lr1.1800000600.RESULTS_TOKEN_SIGNATURE
```

जो क्लाइंट हेडर सेट नहीं कर सकता, वह टोकन को एक `access_token` क्वेरी पैरामीटर के रूप में जोड़ सकता है। क्वेरी स्ट्रिंग अक्सर लॉग की जाती हैं, इसलिए हेडर को प्राथमिकता दें।

कनेक्शन टूटने के बाद फिर से शुरू करने के लिए, `after` में `seq` आपको मिले आखिरी नतीजे का मान जोड़ें (उदाहरण: `&after=1041` ). इसके बाद फ़ीड उस नतीजे के बाद आए नतीजों को फिर से भेजता है। `after`के बिना, फ़ीड अगला नया नतीजा भेजना शुरू करता है।

फ़ीड हर 15 सेकंड में WebSocket ping भेजता है और ping भेजने के बाद 30 सेकंड तक आपके क्लाइंट से कोई जवाब न मिलने पर कनेक्शन बंद कर देता है। अधिकांश WebSocket लाइब्रेरी आपके लिए ping का जवाब देती हैं। फ़ीड एकतरफ़ा है: यह आपके क्लाइंट द्वारा भेजे गए संदेशों को अनदेखा करता है।

अगर फ़ीड कनेक्शन स्वीकार नहीं करता, तो वह साधारण HTTP स्थिति कोड के साथ जवाब देता है:

<table data-search="false"><thead><tr><th>स्थिति</th><th>अर्थ</th><th>क्या करें</th></tr></thead><tbody><tr><td>400</td><td>अनुरोध मान्य WebSocket अपग्रेड नहीं है।</td><td>क्लाइंट ठीक करें।</td></tr><tr><td>401</td><td>टोकन मौजूद नहीं है, इसकी अवधि समाप्त हो गई है, या यह जॉब के पिछले निष्पादन से है।</td><td>नया टोकन पाने के लिए फिर से सदस्यता लें।</td></tr><tr><td>404</td><td>यह जॉब अब इस प्रोसेसर पर चल नहीं रहा है।</td><td>फिर से सदस्यता लें।</td></tr><tr><td>429</td><td>इस जॉब के पहले से ही 16 सब्सक्राइबर हैं।</td><td>कम-से-कम 5 सेकंड प्रतीक्षा करें, फिर दोबारा सदस्यता लें।</td></tr></tbody></table>

## संदेश

हर संदेश एक JSON टेक्स्ट फ़्रेम है, जिसमें `type`.

<table data-search="false"><thead><tr><th>प्रकार</th><th>भेजे जाने का समय</th><th>फ़ील्ड</th></tr></thead><tbody><tr><td><code>hello</code></td><td>एक बार, सबसे पहले</td><td><code>protocol</code>, <code>jobId</code>, <code>executionGeneration</code>, <code>nextSeq</code></td></tr><tr><td><code>result</code></td><td>हर Workflow नतीजे के लिए एक बार</td><td><code>seq</code>, <code>result</code></td></tr><tr><td><code>gap</code></td><td>नतीजे छूट जाने पर</td><td><code>fromSeq</code>, <code>toSeq</code></td></tr><tr><td><code>end</code></td><td>एक बार, सबसे आखिर में, रन रुकने पर</td><td><code>reason</code></td></tr></tbody></table>

### hello

`nextSeq` अगले परिणाम का `seq` है, जिसे यह कनेक्शन भेजता है। `protocol` है `1`.

```json
{"type": "hello", "protocol": 1, "jobId": "JOB_ID", "executionGeneration": 1, "nextSeq": 1042}
```

### परिणाम

`seq` किसी जॉब के एक निष्पादन के भीतर परिणामों की गिनती 0 से करता है। `result` फ़्रेम के Workflow आउटपुट को उनके नामों के साथ रखता है। फ़ीड पर छवियाँ कभी नहीं भेजी जातीं: छवि आउटपुट, एक `image_ref` प्लेसहोल्डर के रूप में दिखाई देता है। `latencyMs` हो सकता है `null`.

```json
{
  "type": "result",
  "seq": 1042,
  "result": {
    "frameId": 31260,
    "timestamp": "2026-01-15T17:04:05.123456Z",
    "latencyMs": 41.7,
    "outputs": {
      "predictions": {
        "image": {"width": 1920, "height": 1080},
        "predictions": [
          {
            "x": 812.5,
            "y": 440.0,
            "width": 96.0,
            "height": 210.0,
            "confidence": 0.91,
            "class": "person",
            "class_id": 0,
            "detection_id": "0f6b2c1e-7a4d-4c39-9d0e-5b1f8a2c3d4e"
          }
        ]
      },
      "bounding_box_visualization": {"type": "image_ref", "output": "bounding_box_visualization"}
    }
  }
}
```

हर प्रविष्टि का आकार `outputs` आपके Workflow के ब्लॉक्स पर निर्भर करता है।

### अंतराल

एक `gap` उन परिणामों की सूचना देता है जिन्हें आपका कनेक्शन अब प्राप्त नहीं कर सकता— `fromSeq` से लेकर `toSeq` तक, दोनों सीमाओं सहित। इसे तब भेजा जाता है जब आप उन परिणामों के बाद फिर से शुरू करते हैं जो रीप्ले विंडो से बाहर जा चुके हैं, या जब आपका क्लाइंट जॉब द्वारा परिणाम उत्पन्न करने की गति से धीमे परिणाम पढ़ता है।

```json
{"type": "gap", "fromSeq": 1043, "toSeq": 1100}
```

### समाप्ति

रन रुकने पर, फ़ीड भेजता है `end` और WebSocket को कोड 1000 के साथ बंद करता है। `reason` है `completed`, `error`, `stopped`, या `replaced` (काम के नए निष्पादन ने इसकी जगह ले ली)।

```json
{"type": "end", "reason": "completed"}
```

रुका हुआ काम बिना किसी `end` संदेश के भी कनेक्शन बंद कर सकता है, इसलिए यह जानने के लिए `end` पर निर्भर न रहें कि काम पूरा हो गया है।

## फिर से कनेक्ट करें और काम को फ़ॉलो करें

बंद होने के कारण की परवाह किए बिना, हर बार एक जैसा व्यवहार करें: फिर से सब्सक्राइब करें और जवाब को फ़ॉलो करें।

1. आपको प्राप्त हुए अंतिम `seq` का `result` मान याद रखें।
2. कनेक्शन समाप्त होने पर, फिर से सब्सक्राइब करें। जवाब बताता है कि काम समाप्त हुआ, अगले काम को सौंपा गया, अभी उसका कोई फ़ीड नहीं है, या ऐसा फ़ीड है जिससे फिर से कनेक्ट करना है।
3. अगर `executionGeneration` उस मान से अलग है जिसे आप पढ़ रहे थे, तो काम फिर से शुरू हुआ है और क्रमांकन दोबारा 0 से शुरू हुआ है। अपने अंतिम `seq` को भूल जाएँ और `after`.
4. के बिना कनेक्ट करें। `after` को अपने अंतिम `seq`.
5. कनेक्शन कम-से-कम एक सेकंड के अंतराल पर शुरू करें। अगर फ़ीड बार-बार कनेक्शन अस्वीकार करे, तो प्रतीक्षा का समय बढ़ाएँ (उदाहरण: 1, 2, 4 और अधिकतम 30 सेकंड)।

फ़ीड किसी रन के सबसे हाल के 300 परिणामों को दोबारा चलाने के लिए रखता है, या 4 MiB से अधिक होने पर इससे कम (30 परिणाम प्रति सेकंड की दर से लगभग 10 सेकंड)। इससे भी पुराने स्थान से फिर शुरू करने पर सबसे पहले `gap`.

## Python क्लाइंट

यह उदाहरण एक बार सब्सक्राइब करता है, कनेक्ट करता है और हर संदेश प्रिंट करता है। इसके लिए `websockets` पैकेज आवश्यक है (`pip install websockets`)। `ROBOFLOW_API_KEY` सेट करें और `YOUR_WORKSPACE` और `JOB_ID`.

```python
import json
import os
import urllib.request

from websockets.sync.client import connect

url = "https://api.roboflow.com/YOUR_WORKSPACE/video-jobs/v1/JOB_ID/results/subscribe"
headers = {"Authorization": f"Bearer {os.environ['ROBOFLOW_API_KEY']}", "Content-Type": "application/json"}
request = urllib.request.Request(url, method="POST", data=b"{}", headers=headers)
grant = json.load(urllib.request.urlopen(request))

token = {"Authorization": f"Bearer {grant['accessToken']}"}
with connect(grant["eventsUrl"], additional_headers=token) as feed:
    for message in feed:
        print(message)
```

## Node.js क्लाइंट

यह उदाहरण Node.js 18 या उसके बाद के संस्करण और  `ws`  पैकेज के साथ वही काम करता है (`npm install ws`).

```javascript
const WebSocket = require("ws");

const url = "https://api.roboflow.com/YOUR_WORKSPACE/video-jobs/v1/JOB_ID/results/subscribe";
const headers = { Authorization: `Bearer ${process.env.ROBOFLOW_API_KEY}`, "Content-Type": "application/json" };

fetch(url, { method: "POST", headers, body: "{}" })
  .then((response) => response.json())
  .then((grant) => {
    const token = { Authorization: `Bearer ${grant.accessToken}` };
    const feed = new WebSocket(grant.eventsUrl, { headers: token });
    feed.on("message", (message) => console.log(message.toString()));
  });
```

दोनों उदाहरण कनेक्शन समाप्त होने पर रुक जाते हैं, और अगर जॉब का फ़ीड अभी उपलब्ध नहीं है तो विफल हो जाते हैं। लगातार चलते रहने वाले क्लाइंट के लिए, सदस्यता के तीनों जवाबों को संभालें और  [फिर से कनेक्ट करें और जॉब को फ़ॉलो करें](#reconnect-and-follow-the-job).

## सीमाएँ और सुरक्षा

* एक जॉब एक समय में अधिकतम 16 परिणाम सब्सक्राइबर को सेवा देता है। 17वें कनेक्शन को HTTP 429 के साथ अस्वीकार कर दिया जाता है।
* हर सब्सक्राइबर की कतार में 200 परिणाम होते हैं। जो क्लाइंट इससे भी अधिक पीछे रह जाता है, उसे छूटे हुए परिणामों की जगह एक  `gap`  मिलता है। जॉब किसी सब्सक्राइबर के लिए कभी धीमा नहीं होता।
* `accessToken` सदस्यता के जवाब के दस मिनट बाद समाप्त हो जाता है (`accessTokenExpiresAt`, मिलीसेकंड में Unix समय)। समाप्ति से पहले खोला गया कनेक्शन उसके बाद भी खुला रहता है। हर नए कनेक्शन के लिए फिर से सदस्यता लें।
* जॉब के नए execution पर जाने पर टोकन काम करना बंद कर देता है। मौजूदा execution के लिए टोकन पाने हेतु फिर से सदस्यता लें।
* यह टोकन केवल परिणामों के लिए है। इससे फ़ीड और  `pollUrl` खोले जा सकते हैं। इससे लाइव वीडियो, जॉब की स्थिति या परिणाम फ़ाइलें नहीं खोली जा सकतीं, और न ही जॉब में बदलाव किया जा सकता है।
* को  `eventsUrl`  और  `accessToken`  को प्रमाण-पत्र मानें: इन्हें लॉग, साझा लिंक और सोर्स कंट्रोल में न रखें। अपनी API key को ब्राउज़र में न भेजें। सदस्यता अपने सर्वर से लें।
