---
title: "SSE पर LLM स्ट्रीमिंग: चंक, डेल्टा, usage, कैंसल | BroadRouter"
description: "Chat-completion स्ट्रीमिंग वायर पर कैसे चलती है, डेल्टा से जवाब कैसे जोड़ें, आख़िरी चंक से usage पढ़ें और Python, Node व curl में साफ़ तरीक़े से कैंसल करें।"
url: https://broadrouter.com/hi/blog/llm-streaming-sse-explained/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/llm-streaming-sse-explained/) (2026-11-16 को अपडेट किया गया).

# LLM स्ट्रीमिंग समझें: SSE चंक, डेल्टा, usage और कैंसल

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित 2026-11-14 · अपडेट किया गया 2026-11-16

LLM API चैट कंप्लीशन को Server-Sent Events के रूप में स्ट्रीम करता है: हर data लाइन में एक JSON चंक होता है, जिसका choices\[0\].delta टेक्स्ट का अगला टुकड़ा लाता है। डेल्टा जोड़ते जाएँ, data: \[DONE\] पर रुकें, और stream\_options में include\_usage सेट करें ताकि ख़ाली choices सूची वाले आख़िरी चंक में टोकन की गिनती मिले। कैंसल करने के लिए कनेक्शन बंद करें।

## मुख्य बातें

-   स्ट्रीम सादा HTTP है: `Content-Type: text/event-stream`, हर चंक के लिए एक `data:` लाइन, इवेंट के बीच एक ख़ाली लाइन, और अंत में `data: [DONE]`।
-   हर चंक में पूरा मैसेज नहीं, एक `delta` होता है। जवाब दोबारा बनाने के लिए `delta.content` स्ट्रिंग जोड़ें।
-   स्ट्रीम में usage डिफ़ॉल्ट रूप से बंद रहता है। `stream_options: {"include_usage": true}` usage और ख़ाली `choices` ऐरे वाला एक आख़िरी चंक जोड़ता है।
-   हर `choices[0]` एक्सेस को सुरक्षित रखें: usage वाले चंक में कोई choice नहीं होती, और जो पार्सर मानता है कि होती है, वह क्रैश होगा।
-   HTTP कनेक्शन बंद करके कैंसल करें। `[DONE]` के बिना ख़त्म हुई स्ट्रीम अधूरा जवाब है, पूरा नहीं।

**इस पेज पर**

1.  वायर पर SSE स्ट्रीम कैसी दिखती है?
2.  एक चंक में क्या होता है?
3.  स्ट्रीम से टोकन usage कैसे निकालें?
4.  Python: स्ट्रीम करें, usage लें, कैंसल करें
5.  Node: AbortController के साथ स्ट्रीम
6.  curl: कच्चे इवेंट देखें
7.  स्ट्रीम कैसे कैंसल करें, और इसकी लागत क्या है?
8.  स्ट्रीमिंग के पाँच बग जिन्हें जाँचना चाहिए
9.  BroadNet Inference कहाँ फ़िट होता है

[स्ट्रीमिंग](https://broadrouter.com/hi/glossary/streaming/) के बिना चैट कंप्लीशन तब तक कुछ नहीं लौटाता जब तक पूरा जवाब तैयार न हो जाए। लगभग 100 टोकन प्रति सेकंड पर 600 टोकन के जवाब का मतलब है कई सेकंड की चुप्पी। स्ट्रीमिंग के साथ पहले शब्द मॉडल के लिखते ही दिखने लगते हैं। यह पोस्ट बताती है कि वायर पर असल में क्या जाता है, उसे कैसे पार्स करें, स्ट्रीम से [टोकन](https://broadrouter.com/hi/glossary/token/) usage कैसे निकालें, और उसे साफ़ तरीक़े से कैसे रोकें। BroadNet के ख़ास नियम संक्षेप में देखने के लिए [स्ट्रीमिंग रेफ़रंस गाइड](https://broadrouter.com/hi/guides/streaming-chat-completions/) देखें।

## वायर पर SSE स्ट्रीम कैसी दिखती है?

Server-Sent Events एक सादा HTTP रिस्पॉन्स है, `Content-Type: text/event-stream` के साथ। सर्वर कनेक्शन खुला रखता है और इवेंट लिखता जाता है। हर इवेंट एक या ज़्यादा `data:` लाइनें हैं, जिनके बाद एक ख़ाली लाइन आती है। OpenAI-कम्पैटिबल API हर इवेंट में एक JSON चंक रखते हैं और अंत में शब्दशः `[DONE]` भेजते हैं:

```text
data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"One, "},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"two, three."},"finish_reason":"stop"}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":6,"total_tokens":20}}

data: [DONE]
```

ऊपर का ढाँचा उदाहरण के लिए है और छोटा किया गया है। असली चंक में `model` और `created` भी होते हैं, और रीज़निंग मॉडल usage में रीज़निंग टोकन भी बता सकते हैं।

## एक चंक में क्या होता है?

| फ़ील्ड | कहाँ | मतलब |
| --- | --- | --- |
| `choices[0].delta.role` | पहला चंक | आम तौर पर `assistant`। एक बार भेजा जाता है। |
| `choices[0].delta.content` | ज़्यादातर चंक | टेक्स्ट का अगला टुकड़ा। ख़ाली भी हो सकता है। |
| `choices[0].delta.tool_calls` | टूल कॉल | फ़ंक्शन के नाम और JSON arguments के टुकड़े, जिन्हें `index` से जोड़ना है। |
| `choices[0].finish_reason` | आख़िरी कंटेंट चंक | `stop`, `length` या `tool_calls`। तब तक `null`। |
| `usage` | आख़िरी चंक, अगर माँगा गया हो | पूरे अनुरोध की कुल गिनती। बाक़ी हर जगह `null`। |

मुख्य बात है **डेल्टा, स्नैपशॉट नहीं**। हर चंक में सिर्फ़ वही होता है जो नया है। आप टुकड़ों को क्रम से जोड़कर मैसेज दोबारा बनाते हैं। [टूल कॉल](https://broadrouter.com/hi/glossary/tool-calling/) भी इसी तरह स्ट्रीम होते हैं: arguments स्ट्रिंग के टुकड़ों में आते हैं जो आख़िरी टुकड़ा आने तक वैध JSON नहीं होते, इसलिए उन्हें तभी पार्स करें जब `finish_reason` `tool_calls` हो।

## स्ट्रीम से टोकन usage कैसे निकालें?

बिना स्ट्रीम वाले रिस्पॉन्स में `usage` हमेशा होता है। स्ट्रीम में नहीं, जब तक आप न माँगें। `stream_options: {"include_usage": true}` सेट करें, और सर्वर `[DONE]` से पहले एक अतिरिक्त चंक भेजता है। उस चंक में कुल गिनती और एक **ख़ाली `choices` ऐरे** होता है। BroadNet Inference पर, जब मॉडल रिपोर्ट करे, usage में `prompt_tokens_details.cached_tokens` और `completion_tokens_details.reasoning_tokens` भी हो सकते हैं, और [लागत लॉगिंग](https://broadrouter.com/hi/blog/llm-api-usage-logging/) के लिए आपको यही चाहिए।

आम बग: जो कोड हर चंक पर `chunk.choices[0]` पढ़ता है, वह usage वाले चंक पर index एरर फेंकता है। पहले `choices` जाँचें।

## Python: स्ट्रीम करें, usage लें, कैंसल करें

```python
import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

stream = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",  # DeepSeek V4.1 Flash, a reasoning model
    messages=[{"role": "user", "content": "Explain SSE in three sentences."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=2000,  # reasoning counts toward this limit
)

def user_pressed_stop():  # replace with your own condition
    return False

parts, usage, finish = [], None, None
try:
    for chunk in stream:
        if chunk.choices:
            choice = chunk.choices[0]
            if choice.delta.content:
                parts.append(choice.delta.content)
                print(choice.delta.content, end="", flush=True)
            if choice.finish_reason:
                finish = choice.finish_reason
        if chunk.usage:
            usage = chunk.usage
        if user_pressed_stop():  # your own condition
            break
finally:
    stream.close()  # closes the HTTP connection

text = "".join(parts)
```

सिर्फ़ `break` पढ़ना रोक देता है, लेकिन सॉकेट तब तक खुला रहता है जब तक garbage collection न हो। उसे साफ़ तौर पर बंद करें ताकि सर्वर को डिस्कनेक्ट दिखे।

## Node: AbortController के साथ स्ट्रीम

```javascript
import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY });
const controller = new AbortController();
setTimeout(() => controller.abort(), 30_000); // hard stop after 30 s

const stream = await client.chat.completions.create(
  {
    model: "broadnet/deepseek-v4.1-flash",
    messages: [{ role: "user", content: "Explain SSE in three sentences." }],
    stream: true,
    stream_options: { include_usage: true },
  },
  { signal: controller.signal },
);

let text = "";
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) text += delta;
  if (chunk.usage) console.log(chunk.usage);
}
```

[openai-node README](https://github.com/openai/openai-node) `signal` विकल्प दर्ज करता है, और यह तब भी काम करता है जब बॉडी अभी पढ़ी जा रही हो। वेब सर्वर में `controller.abort()` को क्लाइंट अनुरोध के `close` इवेंट से जोड़ें, ताकि पेज छोड़ने वाला यूज़र जेनरेशन भी रोक दे। ज़्यादा सेटअप [Node SDK गाइड](https://broadrouter.com/hi/guides/openai-node-sdk/) में है।

## curl: कच्चे इवेंट देखें

```bash
curl -N https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","stream":true,"stream_options":{"include_usage":true},"messages":[{"role":"user","content":"Count to five."}]}'
```

`-N` आउटपुट बफ़रिंग बंद करता है, ताकि इवेंट आते ही प्रिंट हों। कैंसल करने के लिए Ctrl+C दबाएँ; इससे कनेक्शन बंद हो जाता है। [API रिक्वेस्ट बिल्डर](https://broadrouter.com/tools/api-request-builder/) किसी भी मॉडल और base URL के लिए यह अनुरोध, और इसके Python व Node वर्ज़न, बनाता है।

## स्ट्रीम कैसे कैंसल करें, और इसकी लागत क्या है?

SSE में कैंसल करना बस कनेक्शन बंद करना है। कोई “stop” मैसेज नहीं होता। आगे क्या होगा, यह सर्वर पर निर्भर है: ठीक से बना सर्वर बंद सॉकेट को देखकर जेनरेशन रोक देता है। उस पल से पहले बने टोकन असली काम थे। BroadNet का API रेफ़रंस कैंसल की गई स्ट्रीम की बिलिंग दर्ज नहीं करता, इसलिए मानकर योजना बनाएँ कि [उपयोग के अनुसार भुगतान](https://broadrouter.com/hi/glossary/pay-as-you-go/) पर डिस्कनेक्ट तक बने टोकन बिल होते हैं, और अपने usage रिकॉर्ड जाँचें। फ़्लैट प्लान पर कैंसल की गई स्ट्रीम का कोई अतिरिक्त ख़र्च नहीं, लेकिन सेशन तभी ख़ाली होता है जब सर्वर रुकता है।

## स्ट्रीमिंग के पाँच बग जिन्हें जाँचना चाहिए

1.  **बफ़र करने वाले प्रॉक्सी।** Nginx और कुछ CDN रिस्पॉन्स बफ़र करते हैं, इसलिए क्लाइंट को सब कुछ एक साथ मिलता है। स्ट्रीमिंग रूट के लिए प्रॉक्सी बफ़रिंग बंद करें।
2.  **`[DONE]` की जाँच नहीं।** टूटा कनेक्शन छोटे जवाब जैसा दिखता है। `[DONE]` न मिलने को अधूरा मानें और `X-Request-ID` रिकॉर्ड करें, जैसा [एरर गाइड](https://broadrouter.com/hi/guides/errors-and-retries/) बताती है।
3.  **स्ट्रीम के बीच में रीट्राई।** बॉडी आनी शुरू होने के बाद SDK रीट्राई नहीं करते। रीट्राई एक नया अनुरोध है, और उपयोग के अनुसार भुगतान पर एक नया बिल।
4.  **`finish_reason: length` को अनदेखा करना।** [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) जैसे रीज़निंग मॉडल पर थिंकिंग [max\_tokens](https://broadrouter.com/hi/glossary/max-tokens/) में गिनी जाती है, इसलिए छोटी सीमा कोई भी दिखने वाला टेक्स्ट आने से पहले स्ट्रीम रोक सकती है। [रीज़निंग टोकन की लागत क्या है](https://broadrouter.com/hi/blog/reasoning-tokens-cost/)।
5.  **लाइनें ग़लत तोड़ना।** अगर आप SSE हाथ से पार्स करते हैं, तो ख़ाली लाइन दिखने तक बाइट बफ़र करें। एक TCP रीड JSON चंक के बीच में ख़त्म हो सकती है।

## BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference स्टैंडर्ड [OpenAI-कम्पैटिबल](https://broadrouter.com/hi/glossary/openai-compatible-api/) स्ट्रीमिंग ढाँचा इस्तेमाल करता है, इसलिए Python और Node SDK इसे बिना बदलाव पार्स करते हैं। आख़िरी चंक के usage में, जब मॉडल रिपोर्ट करे, कैश्ड और रीज़निंग टोकन शामिल होते हैं। इसकी डॉक्स कहती हैं कि प्रोडक्शन से पहले हर मॉडल पर स्ट्रीमिंग की पुष्टि करनी चाहिए, इसलिए ऊपर का कोड उसी मॉडल पर चलाएँ जिसे आप शिप करते हैं। अगर आपको मुख्य रूप से यह फ़िक्र है कि पहला टोकन कितनी जल्दी आता है, तो आगे [TTFT बनाम थ्रूपुट](https://broadrouter.com/hi/blog/llm-latency-ttft-throughput/) पढ़ें। अगर आपको WebSockets पर रियलटाइम वॉइस चाहिए, तो यह API उसके लिए नहीं बना; यह चैट कंप्लीशन और फ़ाइल ट्रांसक्रिप्शन देता है।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[स्ट्रीमिंग (streaming)](https://broadrouter.com/hi/glossary/streaming/)

स्ट्रीमिंग, लैंग्वेज मॉडल के जवाब को अंत में एक साथ लौटाने के बजाय, बनते समय ही छोटे-छोटे टुकड़ों (chunks) में लौटाने का तरीक़ा है। OpenAI-कम्पैटिबल API, अनुरोध में stream को true सेट करने पर server-sent events से स्ट्रीम करते हैं।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[Server-sent events (SSE)](https://broadrouter.com/hi/glossary/sse/)

Server-sent events (SSE) एक वेब स्टैंडर्ड है, जिसमें सर्वर text/event-stream कंटेंट टाइप वाले एक लंबे खुले HTTP जवाब पर क्लाइंट को टेक्स्ट events की स्ट्रीम भेजता है। हर event में data: जैसी एक या ज़्यादा फ़ील्ड लाइनें होती हैं, और वह एक ख़ाली लाइन पर ख़त्म होता है।

[रीज़निंग टोकन (reasoning tokens)](https://broadrouter.com/hi/glossary/reasoning-tokens/)

रीज़निंग टोकन वे टोकन हैं जो रीज़निंग मॉडल अपना दिखने वाला जवाब लिखने से पहले किसी समस्या को हल करने के लिए बनाता है। इनका बिल आम तौर पर आउटपुट टोकन की तरह बनता है, ये आउटपुट लिमिट और कॉन्टेक्स्ट विंडो में गिने जाते हैं, और API इन्हें छिपा सकता है या इनका सारांश दे सकता है।

[base URL](https://broadrouter.com/hi/glossary/base-url/)

base URL किसी API का तय मूल पता है, जैसे https://api.example.com/v1, जिसे क्लाइंट /chat/completions जैसे हर एंडपॉइंट पाथ के आगे जोड़ता है। OpenAI-compatible SDK में base URL को API key और मॉडल ID के साथ बदलने से वही कोड किसी दूसरे प्रोवाइडर से जुड़ जाता है।

[टूल कॉलिंग (tool calling)](https://broadrouter.com/hi/glossary/tool-calling/)

टूल कॉलिंग, जिसे function calling भी कहते हैं, LLM API की वह सुविधा है जिसमें मॉडल डेवलपर के तय किए किसी फ़ंक्शन को चलाने का एक स्ट्रक्चर्ड अनुरोध, JSON आर्ग्युमेंट के साथ, लौटाता है। ऐप्लिकेशन फ़ंक्शन चलाकर नतीजा वापस भेजता है; मॉडल ख़ुद कभी कोड नहीं चलाता।

[थ्रूपुट (throughput)](https://broadrouter.com/hi/glossary/throughput/)

LLM सर्विंग में थ्रूपुट वह कुल काम है जो कोई सिस्टम सभी कॉन्करेंट अनुरोधों में प्रति इकाई समय पूरा करता है, आम तौर पर आउटपुट टोकन प्रति सेकंड या अनुरोध प्रति सेकंड में नापा जाता है। यह प्रति-स्ट्रीम स्पीड से अलग है, जो बताती है कि एक अनुरोध को उसके टोकन कितनी तेज़ी से मिलते हैं।

## अक्सर पूछे जाने वाले सवाल

### LLM स्ट्रीमिंग के लिए SSE और WebSockets में क्या फ़र्क़ है?

SSE एकतरफ़ा है, सर्वर से क्लाइंट की ओर, एक सामान्य HTTP रिस्पॉन्स पर। चैट कंप्लीशन को बस इतना ही चाहिए, इसलिए OpenAI-कम्पैटिबल API SSE इस्तेमाल करते हैं। WebSockets दोतरफ़ा हैं और उन्हें प्रोटोकॉल अपग्रेड चाहिए; वे रियलटाइम वॉइस के लिए इस्तेमाल होते हैं, चैट कंप्लीशन के लिए नहीं।

### मेरे स्ट्रीमिंग चंक में usage null क्यों है?

Usage तभी भेजा जाता है जब आप माँगें। stream\_options जोड़ें और उसमें include\_usage को true करें। तब आख़िरी को छोड़कर हर चंक में usage null होता है, और आख़िरी चंक ख़ाली choices सूची के साथ कुल गिनती लाता है।

### अगर मैं स्ट्रीम कैंसल करूँ तो क्या मुझसे पैसे लगेंगे?

प्रोवाइडर अलग-अलग हैं और कई इसे दर्ज नहीं करते। मानकर चलें कि सर्वर को बंद कनेक्शन का पता चलने से पहले बने टोकन बिल होते हैं। X-Request-ID लॉग करें और अपने usage रिकॉर्ड से मिलाएँ।

### कैसे पता चले कि स्ट्रीम सामान्य रूप से पूरी हुई?

आपको data: \[DONE\] मिला और आख़िरी कंटेंट चंक में stop जैसा finish\_reason था। length वाले finish\_reason का मतलब है कि max\_tokens ने जवाब काट दिया। \[DONE\] न मिले, तो कनेक्शन टूट गया।

### क्या स्ट्रीमिंग से मॉडल तेज़ हो जाता है?

नहीं। कुल जेनरेशन समय उतना ही रहता है। स्ट्रीमिंग वह समय घटाती है जब तक यूज़र को पहले शब्द दिखते हैं, और इसी से चैट इंटरफ़ेस तेज़ महसूस होता है।

## आगे पढ़ें

-   [LLM लेटेंसी: TTFT, टोकन प्रति सेकंड और एंड-टू-एंड समय](https://broadrouter.com/hi/blog/llm-latency-ttft-throughput/)
-   [LLM API usage लॉगिंग: हर यूज़र और फ़ीचर की लागत, PII हटाकर](https://broadrouter.com/hi/blog/llm-api-usage-logging/)
-   [LLM API में 429 एरर कैसे सँभालें: बैकऑफ़, जिटर और लिमिटर](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/)
-   [BroadNet का GPU हार्डवेयर और सर्विंग का तरीक़ा, BroadNet के शब्दों में](https://broadrouter.com/hi/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM API रिस्पॉन्स कैश करके लागत घटाएँ: Python में एक्ज़ैक्ट-मैच कैश](https://broadrouter.com/hi/blog/cache-llm-responses-cut-cost/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)
-   [गाइड: BroadNet Inference के साथ OpenAI Node.js SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-node-sdk/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-streaming-sse-explained&utm_content=page-cta) ·

**स्रोत**

-   [BroadNet Inference API रेफ़रंस, स्ट्रीमिंग और usage (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-llm-streaming-sse-explained&utm_content=sources#requests)
-   [MDN, Server-sent events का इस्तेमाल](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
-   [OpenAI कम्युनिटी घोषणा, स्ट्रीमिंग में usage आँकड़े (stream\_options)](https://community.openai.com/t/usage-stats-now-available-when-using-streaming-with-the-chat-completions-api-or-completions-api/738156)
-   [openai-python README, स्ट्रीमिंग जवाब और रीट्राई (2026-11-14 को देखा गया)](https://github.com/openai/openai-python)
-   [openai-node README, AbortSignal से कैंसलेशन (2026-11-14 को देखा गया)](https://github.com/openai/openai-node)
