नाटककार + स्क्रैपलेस स्क्रैपिंग ब्राउज़र: सीडीपी के माध्यम से लाइव वेब्सॉक डेटा पकड़ें

एक लाइव प्राइस टिकट, एक स्पोर्टबुक के ऑड्स बोर्ड, और एक रियल-टाइम डैशबोर्ड सभी में एक समान गुण है: स्क्रीन पर संख्या कभी भी पेज रीलोड से नहीं आई। ब्राउज़र ने एक बार एकल WebSocket कनेक्शन खोला, और तब से सर्वर उस ही सॉकेट के माध्यम से हर अपडेट को एक फ्रेम के रूप में भेज रहा है - कोई पुनरावृत्त अनुरोध नहीं, कोई नया HTML पार्स करने के लिए नहीं। एक ऐसा टूल जो केवल DOM को पढ़ता है या HTML लाता है, वह उस ट्रैफिक को नहीं देखता, क्योंकि डेटा फ्रेम में रहता है, मार्कअप में नहीं।

Playwright को Scrapeless Scraping Browser से wss://browser.scrapeless.com/api/v2/browser पर कनेक्ट करें, और नीचे का CDP सत्र आपको उन फ्रेमों को प्राप्त करते हुए पढ़ने के लिए दो अलग-अलग तरीके देता है: Playwright का अपना WebSocket इवेंट API, और Chrome DevTools प्रोटोकॉल से कच्चा Network.webSocketFrameReceived इवेंट। यह गाइड उस क्लाउड ब्राउज़र से कनेक्ट होती है, एक सार्वजनिक, नो-ऑथ मार्केट-डेटा स्ट्रीम के लिए WebSocket खोलती है, और दोनों तरीकों से फ्रेम कैप्चर करती है, हर कोड पथ को लाइव एंडपॉइंट के खिलाफ चलाती है।

क्यों WebSocket ट्रैफिक को अलग कैप्चर पथ की आवश्यकता होती है

page.query_selector_all() और समान कॉल जो भी DOM में उस क्षण में है जिसे आप उन्हें कॉल करते हैं, उसे पढ़ते हैं। एक सॉकेट-खुराक वाली विजेट जैसे-जैसे फ्रेम आते हैं, अपने स्वयं के डिस्प्ले को नोड द्वारा संशोधित करती है, इसलिए एकल DOM रीड केवल उस अंतिम मान को पकड़ता है जो हुआ। स्ट्रीम को स्वयं पढ़ना - फ्रेम, न कि प्रदर्शित पिक्सल - यह देखने का एकमात्र तरीका है कि एक टिकेट, एक ऑड्स फीड, या एक लाइव डैशबोर्ड वास्तव में हर अपडेट प्राप्त करता है।

Chrome DevTools प्रोटोकॉल सीधे उस स्ट्रीम को उजागर करता है। इसका नेटवर्क डोमेन हर फ्रेम के लिए एक इवेंट फायर करता है जो एक पेज का WebSocket भेजता है या प्राप्त करता है, उस फ्रेम के साथ पेज क्या करता है उसके बावजूद। Scrapeless Scraping Browser एक क्लाउड क्रोमियम सत्र है जो केवल CDP के माध्यम से पहुंचा जा सकता है - Puppeteer, Playwright, और अन्य CDP क्लाइंट्स इससे कनेक्ट होते हैं, लेकिन इसके साथ चलाने के लिए कोई Selenium/WebDriver एंडपॉइंट नहीं है। Playwright संयोगवश उसी CDP इवेंट की दो परतें उजागर करता है: एक पेज-स्तरीय websocket इवेंट जिसमें अपने स्वयं के फ्रेम कॉलबैक होते हैं, और, एक स्तर नीचे, CDP सत्र तक सीधी पहुंच ताकि आप स्वयं Network.webSocketFrameReceived की सदस्यता ले सकें।

पूर्वापेक्षाएँ

आपको Python 3.9 या नया, playwright पैकेज, और app.scrapeless.com पर मुफ्त योजना से एक Scrapeless API कुंजी की आवश्यकता है। स्थानीय Chrome बाइनरी की आवश्यकता नहीं है - connect_over_cdp एक ब्राउज़र तक पहुँचता है जो पहले से ही Scrapeless के क्लाउड में है, इसलिए यहाँ playwright install chromium वैकल्पिक है।

नीचे दिया गया उदाहरण Binance के सार्वजनिक स्पॉट मार्केट-डेटा स्ट्रीम के खिलाफ सीधे एक WebSocket खोलता है, जो Binance के WebSocket मार्केट स्ट्रीम संदर्भ पर दस्तावेजित है। इसे कोई API कुंजी और कोई खाता की आवश्यकता नहीं है - यह सार्वजनिक, बिना प्रमाणीकरण वाला मार्केट डेटा है। दोनों उदाहरण 24-घंटे के टिकेट स्ट्रीम की सदस्यता लेते हैं, जो प्रति सेकंड एक अपडेट भेजता है, और इन-पेज स्क्रिप्ट जैसे ही पांचवां फ्रेम arrives होता है, सॉकेट स्वयं बंद कर देता है, इसलिए कोई भी रन कनेक्शन को खुला नहीं रखता है इससे अधिक समय से जितना यह दिखाने में लगता है कि कैप्चर काम करता है।

इंस्टॉल करें

pip install playwright

export SCRAPELESS_API_KEY="your_scrapeless_api_key"

CDP के माध्यम से कनेक्ट करें

किसी भी Playwright-to-Scraping-Browser स्क्रिप्ट द्वारा उपयोग किए जाने वाले एक ही URL-निर्माता पैटर्न का पुन: उपयोग करें: एक WSS एंडपॉइंट पर तीन क्वेरी पैरामीटर।

import os
from urllib.parse import urlencode

API_KEY = os.environ["SCRAPELESS_API_KEY"]

def scraping_browser_url(proxy_country="DE", session_ttl=60):
    params = urlencode({"token": API_KEY, "sessionTTL": session_ttl, "proxyCountry": proxy_country})
    return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

proxyCountry यहां एक कारण के लिए महत्वपूर्ण है जो इस लक्ष्य के लिए विशिष्ट है: एक कनेक्शन जो संयुक्त राज्य के निकास आईपी के माध्यम से रूट किया गया है, Binance के स्पॉट स्ट्रीम के खिलाफ हैंडशेक विफल कर देता है - सॉकेट खुलता है और फिर तुरंत WebSocket बंद कोड 1006 के साथ बंद हो जाता है। जर्मनी, या अधिकांश अन्य गैर-अमेरिकी क्षेत्रों के माध्यम से रूटिंग आमतौर पर हैंडशेक को सामान्य रूप से पूरा करती है और फ्रेम आना शुरू करते हैं। नीचे के उदाहरणों में proxyCountry को उस कारण के लिए "DE" पर पिन किया गया है; इसे बदलें जिस क्षेत्र में आपका अपना लक्ष्य वास्तव में सेवा करता है।

Playwright के WebSocket इवेंट के साथ फ्रेम कैप्चर करें

Playwright एक websocket इवेंट को Page ऑब्जेक्ट पर तब फायर करता है जब भी पेज एक सॉकेट खोलता है, चाहे वह सॉकेट आपके अपने page.evaluate() कॉल से हो या लक्षित साइट के अपने जावास्क्रिप्ट से। WebSocket ऑब्जेक्ट जो आपको दिया जाता है, वह हर आने वाले फ्रेम के लिए framereceived और हर आउटगोइंग फ्रेम के लिए framesent को फायर करता है।

import json
import os
from urllib.parse import urlencode

from playwright.sync_api import sync_playwright

API_KEY = os.environ["SCRAPELESS_API_KEY"]
FRAME_LIMIT = 5

def scraping_browser_url(proxy_country="DE", session_ttl=60):
    params = urlencode({"token": API_KEY, "sessionTTL": session_ttl, "proxyCountry": proxy_country})

Here's the translation of the provided text to Hindi:

return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

फ्रेम = []

def हैंडल_websocket(ws):
    print("वेबसोकट खोला गया:", ws.url)
    ws.on("framereceived", lambda payload: फ्रेम.append(payload))

with sync_playwright() as p:
    ब्राउज़र = p.chromium.connect_over_cdp(scraping_browser_url())
    पेज = ब्राउज़र.new_page()
    पेज.on("websocket", हैंडल_websocket)

    पेज.goto("about:blank")
    पेज.evaluate(
        f"""() => {{
            window.__frameCount = 0;
            const ws = new WebSocket("wss://stream.binance.com:9443/ws/btcusdt@ticker");
            ws.onmessage = () => {{
                window.__frameCount += 1;
                if (window.__frameCount >= {FRAME_LIMIT}) {{ ws.close(); }}
            }};
            window.__ws = ws;
        }}"""
    )
    पेज.wait_for_function("window.__ws && window.__ws.readyState === 3", timeout=20000)
    पेज.wait_for_timeout(300)
    ब्राउज़र.close()

print(f"पृष्ठ.on('websocket') के माध्यम से {len(फ्रेम)} फ्रेम कैप्चर किए गए")
print(json.dumps(json.loads(फ्रेम[0]), indent=2))

पाच वास्तविक टिकी अपडेट्स वापस आते हैं, प्रत्येक एक पूरा JSON संदेश:

वेबसोकट खोला गया: wss://stream.binance.com:9443/ws/btcusdt@ticker
पृष्ठ.on('websocket') के माध्यम से 5 फ्रेम कैप्चर किए गए
{
  "e": "24hrTicker",
  "E": 1785154788015,
  "s": "BTCUSDT",
  "p": "516.30000000",
  "P": "0.800",
  "w": "65153.97639938",
  "x": "64558.24000000",
  "c": "65074.53000000",
  "Q": "0.00022000",
  "b": "65074.53000000",
  "B": "0.00376000",
  "a": "65074.54000000",
  "A": "6.01063000",
  "o": "64558.23000000",
  "h": "65744.60000000",
  "l": "64414.00000000",
  "v": "12430.45583000",
  "q": "809893625.78133730",
  "O": 1785068388012,
  "C": 1785154788012,
  "F": 6534229591,
  "L": 6536075962,
  "n": 1846372
}

इन-पृष्ठ onmessage हैंडलर खुद फ्रेम की गिनती करता है और पाँचवा आने पर ws.close() को तुरंत कॉल करता है, इसलिए सीमा स्रोत पर लागू होती है न कि पायथन से पोलिंग द्वारा - एक स्ट्रीम जो हर सेकंड एक बार से अधिक अपडेट धकेलती है, अन्यथा कई अतिरिक्त फ्रेमों को आने देती है इससे पहले कि पायथन-साइड की जांच पकड़ में आए। page.wait_for_function तब readyState के बंद होने की रिपोर्ट होने तक ब्लॉक करता है। about:blank और page.evaluate यहाँ पर पर्याप्त हैं क्योंकि लक्ष्य सॉकेट है, न कि एक पृष्ठ का मार्कअप; page.on("websocket") उसी तरह ट्रिगर करता है जब एक वास्तविक पृष्ठ अपने स्वयं के स्क्रिप्ट के माध्यम से कनेक्शन खोलता है।

सीडीपी नेटवर्क डोमेन से कच्चे फ़्रेम कैप्चर करें

Playwright का framereceived ईवेंट पहले से ही आपके लिए फ्रेम को डिकोड करता है। एक परत नीचे जाते हुए, सीधे CDP सत्र के माध्यम से, वही ईवेंट उजागर होता है जिसका उपयोग DevTools नेटवर्क पैनल करता है - जिसमें opcode भी शामिल है जो बताता है कि क्या एक फ्रेम पाठ है या बाइनरी।

import base64
import json
import os
from urllib.parse import urlencode

from playwright.sync_api import sync_playwright

API_KEY = os.environ["SCRAPELESS_API_KEY"]
FRAME_LIMIT = 5

def scraping_browser_url(proxy_country="DE", session_ttl=60):
    params = urlencode({"token": API_KEY, "sessionTTL": session_ttl, "proxyCountry": proxy_country})
    return f"wss://browser.scrapeless.com/api/v2/browser?{params}"

cdp_frames = []

def on_frame(event):
    frame = event["response"]
    payload = frame["payloadData"] if frame["opcode"] == 1 else base64.b64decode(frame["payloadData"])
    cdp_frames.append((frame["opcode"], payload))

with sync_playwright() as p:
    ब्राउज़र = p.chromium.connect_over_cdp(scraping_browser_url())
    पेज = ब्राउज़र.new_page()

    cdp = पेज.context.new_cdp_session(pेज)
    cdp.send("Network.enable")
    cdp.on("Network.webSocketFrameReceived", on_frame)

    पेज.goto("about:blank")
    पेज.evaluate(
        f"""() => {{
            window.__frameCount = 0;
            const ws = new WebSocket("wss://stream.binance.com:9443/ws/btcusdt@ticker");
            ws.onmessage = () => {{
                window.__frameCount += 1;
                if (window.__frameCount >= {FRAME_LIMIT}) {{ ws.close(); }}
            }};
            window.__ws = ws;
        }}"""
    )
    पेज.wait_for_function("window.__ws && window.__ws.readyState === 3", timeout=20000)
    पेज.wait_for_timeout(300)
    ब्राउज़र.close()

print(f"कैप्चर किए गए {len(cdp_frames)} कच्चे CDP फ्रेम")
opcode, payload = cdp_frames[0]
print(f"opcode={opcode}")
print(json.dumps(json.loads(payload), indent=2))

opcode पुष्टि करता है कि ये पाठ फ्रेम हैं, और_payload वही टिका स्कीमा है जो दूसरे कैप्चर पथ से है:

कैप्चर किए गए 5 कच्चे CDP फ्रेम
opcode=1
{
  "e": "24hrTicker",
  "E": 1785154852015,
  "s": "BTCUSDT",
  "p": "525.37000000",
  "P": "0.814",
  "w": "65154.69931666",
  "x": "64529.61000000",
  "c": "65054.99000000",
  "Q": "0.00430000",
  "b": "65054.99000000",
  "B": "4.56302000",
  "a": "65055.00000000",
  "A": "1.44666000",
  "o": "64529.62000000",
  "h": "65744.60000000",
  "l": "64414.00000000",
  "v": "12421.62669000",
  "q": "809327352.01071850",
  "O": 1785068452012,
  "C": 1785154852012,
  "F": 6534232202,
  "L": 6536078668,
  "n": 1846467
}

page.context.new_cdp_session(page) एक सत्र खोलता है जिसका CDP सत्र इंटरफ़ेस send() प्रोटोकॉल आदेशों के लिए और on() प्रोटोकॉल घटनाओं के लिए उपलब्ध कराता है — Network.enable फ्रेम रिपोर्टिंग को चालू करता है, और हर बाद की Network.webSocketFrameReceived घटना समान requestId, timestamp, और response आकार के साथ फायर होती है जैसा कि DevTools Network टैब पढ़ता है। Opcode 1 टेक्स्ट फ्रेम को WebSocket प्रोटोकॉल के अपने फ्रेम प्रारूप के तहत चिह्नित करता है, इसलिए पेलोड पहले से ही एक UTF-8 स्ट्रिंग होती है; किसी अन्य ऑपकोड के लिए base64.b64decode() चरण की आवश्यकता होती है, क्योंकि प्रोटोकॉल बाइनरी फ्रेम को base64 के रूप में ले जाता है ताकि पूरी घटना JSON-सुरक्षित रहे।

आपको क्या वापस मिलता है

दोनों पथ इस स्ट्रीम के लिए एक ही टिकर पेलोड लौटाते हैं, क्योंकि दोनों समान आधारभूत फ्रेम पढ़ रहे हैं — एक Playwright के अव्यवस्था के माध्यम से, एक सीधे प्रोटोकॉल से।

एक व्यापार स्ट्रीम उसी कनेक्शन पर (btcusdt@trade के बजाय btcusdt@ticker) हर निष्पादित व्यापार के लिए एक संदेश लौटाता है बजाय चल रहे सारांश के — छोटे पेलोड, जिसमें p (कीमत), q (मात्रा), और t (व्यापार आईडी) ऊपर के टिकर फ़ील्ड के स्थान पर होते हैं, जो एक सक्रिय युग्म पर एक सेकंड में एक बार से अधिक बार आते हैं। कैप्चर कोड नहीं बदलता; सिर्फ WebSocket URL में स्ट्रीम का नाम बदलता है।

अपने एपीआई की कुंजी मुफ्त योजना पर प्राप्त करें: app.scrapeless.com

एक असली पृष्ठ से फ्रेम पढ़ना सीधे सॉकेट के बजाय

उपरोक्त प्रत्येक उदाहरण WebSocket को स्वयं खोला है, एक अन्यथा ख़ाली पृष्ठ से, क्योंकि यह लक्ष्य को छोटा और सार्वजनिक रखता है। एक लाइव ऑड्स बोर्ड या एक्सचेंज डैशबोर्ड उसी तरह अपना स्वयं का सॉकेट खोलता है — अपने स्वयं के बंडल किए गए जावास्क्रिप्ट से, जैसे ही पृष्ठ लोड होता है — और page.on("websocket") किसी भी तरह से समान रूप से फायर करता है। वास्तविक लक्ष्य पर page.goto() कॉल करने से पहले वही हैंडलर संलग्न करें, और फ्रेम उसी समय आते हैं जब पृष्ठ का अपना स्क्रिप्ट उन्हें प्राप्त करता है; कैप्चर लॉजिक में कुछ भी नहीं बदलता क्योंकि सॉकेट किसी पृष्ठ का है बजाय आपके page.evaluate() कॉल के। जो बदलता है वह खोज है — लक्ष्य के अपने नेटवर्क पैनल को एक बार खोलें, सॉकेट URL और फ्रेम आकार को हाथ से खोजें, फिर उसे framereceived हैंडलर में अनुवादित करें बजाय एक स्ट्रीम नाम की भविष्यवाणी करने के।

निष्कर्ष

एक WebSocket कनेक्शन डेटा ले जाता है जिसे DOM पढ़ना या HTTP फ़ेच कभी नहीं देखता, क्योंकि सर्वर एक खुले सॉकेट के जरिए फ्रेम को लगातार पुश करता है बजाय अलग-अलग अनुरोधों का उत्तर देने के। Playwright का page.on("websocket") घटना और कच्चा CDP Network.webSocketFrameReceived घटना दोनों उसी स्ट्रीम को पढ़ते हैं — एक सुविधाजनक रैपर के माध्यम से, एक सीधे प्रोटोकॉल से — और दोनों सीधे सार्वजनिक बाजार डेटा स्ट्रीम के खिलाफ Scrapeless Scraping Browser के CDP कनेक्शन पर समान रूप से कार्य करते हैं। proxyCountry को एक क्षेत्र पर पिन करें जिसे आपका लक्ष्य वास्तव में सेवा करता है, इससे पहले कि आप सॉकेट बंद करने से पहले कितने फ्रेम कैप्चर करते हैं, और बाकी स्क्रिप्ट वही handful प्लेवेरीट कॉल हैं जो आप पहले से ही जानते हैं। वर्तमान सत्र और ईग्रेस सीमाओं को Scraping Browser उत्पाद पृष्ठ पर पढ़ें और मूल्य निर्धारण पृष्ठ पर योजना सीमाएँ जांचें। कनेक्शन मैकेनिक्स पर इस गाइड का निर्माण, Chrome DevTools प्रोटोकॉल स्पष्टक बताता है कि CDP नेटवर्क डोमेन के परे क्या प्रकट करता है।

एक मुफ्त योजना का दावा करने और अन्य डेवलपर्स के साथ नोटों की तुलना करने के लिए हमारे समुदाय में शामिल हों: Discord · Telegram。

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

प्रश्न: क्या मुझे इस तरीके से WebSocket फ्रेम कैप्चर करने के लिए Selenium या WebDriver की आवश्यकता है?

नहीं। Scrapeless Scraping Browser केवल Chrome DevTools प्रोटोकॉल के माध्यम से पहुंचा जा सकता है, इसलिए कोई भी क्लाइंट जो CDP से बात करता है — यहां Playwright, या Puppeteer — कनेक्ट कर सकता है और फ्रेम घटनाएँ पढ़ सकता है। वहाँ कोई WebDriver एंडपॉइंट नहीं है, इसलिए Selenium इस कनेक्शन को ड्राइव नहीं कर सकता।

प्रश्न: page.on("websocket") और कच्चा CDP Network.webSocketFrameReceived घटना के बीच क्या अंतर है?
Playwright के websocket इवेंट और इसके framereceived कॉलबैक पहले से ही एक फ्रेम को एक स्ट्रिंग में डीकोड करते हैं, जो इस गाइड में दिए गए टेक्स्ट-आधारित JSON स्ट्रीम को कवर करता है। नीचे का CDP इवेंट opcode फील्ड जोड़ता है, जिससे आप यह बता सकते हैं कि टेक्स्ट फ्रेम एक बाइनरी फ्रेम से अलग है या नहीं, इससे पहले कि आप इसे डीकोड करने का निर्णय लें।

प्रश्न: मैं पेज द्वारा भेजे गए फ्रेम कैसे पढ़ूं, न कि केवल उन फ्रेमों को जो इसे प्राप्त होते हैं?

Playwright का WebSocket ऑब्जेक्ट framereceived के साथ-साथ framesent का संचालन करता है, और CDP सत्र मिलान करने वाला Network.webSocketFrameSent इवेंट वही requestId, timestamp, और response आकार के साथ चलाती है जैसा कि प्राप्त संस्करण के लिए होता है।

प्रश्न: बाइनरी WebSocket फ्रेम का क्या होता है?

एक बाइनरी फ्रेम CDP के माध्यम से opcode को 1 के अलावा कुछ और सेट करके आता है, और payloadData में UTF-8 स्ट्रिंग के बजाय base64-कोडित बाइट्स होते हैं — इसे किसी भी बाइनरी प्रारूप को पार्स करने से पहले base64.b64decode() के साथ डीकोड करें। Playwright का खुद का framereceived इवेंट बाइनरी फ्रेम को bytes के रूप में पास करता है न कि str के रूप में।

प्रश्न: जब proxyCountry "US" था, तो कनेक्शन क्यों विफल हुआ और बंद कोड 1006 मिला?

बंद कोड 1006 का मतलब है कि कनेक्शन असामान्य रूप से समाप्त हो गया, बिना उचित बंद फ्रेम के — इस मामले में, जब निकास IP संयुक्त राज्य में था तो Binance के स्ट्रीम का हैंडशेक कभी पूरा नहीं हुआ। एक अलग proxyCountry मान के माध्यम से उसी अनुरोध को राउट करने से हैंडशेक पूरा हुआ और फ्रेम भेजना शुरू किया गया।

प्रश्न: क्या मैं एक पृष्ठ से WebSocket ट्रैफ़िक कैप्चर कर सकता हूँ न कि स्वयं सॉकेट खोलकर?

हाँ। page.on("websocket") हैंडलर को संलग्न करें, या वास्तविक लक्ष्य पर page.goto() करने से पहले CDP Network डोमेन को सक्षम करें, और पृष्ठ की अपनी स्क्रिप्ट द्वारा खोले गए किसी भी सॉकेट के लिए एक ही इवेंट ट्रिगर होते हैं — कैप्चर कोड में कुछ भी नहीं बदलता।

प्रश्न: WebSocket कितनी देर तक खुला रह सकता है?

sessionTTL क्वेरी पैरामीटर ब्राउज़र सत्र को सेकंड में सीमित करता है। एक छोटा मान इस गाइड में सीमित कैप्चर के लिए पर्याप्त है; एक लंबा मान सत्र — और किसी भी खुले सॉकेट — को लंबे समय तक चलने वाले स्ट्रीम के लिए जीवित रखता है।

प्रश्न: क्या इसे मैं जिस भी WebSocket एंडपॉइंट पर चलाता हूं, वह सुरक्षित है?

केवल सार्वजनिक, बिना प्रमाणीकरण वाले एंडपॉइंट पर, जिन्हें पढ़ने की अनुमति है, और केवल उस मात्रा में जो एंडपॉइंट की अपनी दस्तावेज़ीकरण की अनुमति है। यहां का उदाहरण Binance के दस्तावेजित सार्वजनिक मार्केट-डेटा स्ट्रीम को लक्षित करता है, किसी भी की की आवश्यकता नहीं है, और पांच फ्रेम के बाद कनेक्शन बंद कर देता है बजाय इसके कि उसे अनिश्चितकाल के लिए खोला जाए।

प्रश्न: क्या फ्रेम स्कीमा विभिन्न स्ट्रीम प्रकारों में समान रहती है?

नहीं — इस गाइड में ट ticker स्ट्रीम हर सेकंड एक चालू 24-घंटे का सारांश लौटाता है, जबकि एक व्यापार स्ट्रीम उसी कनेक्शन पर प्रति निष्पादित व्यापार एक छोटा संदेश लौटाती है, अक्सर प्रति सेकंड कई बार। कैप्चर तंत्र हर तरीके से समान है; केवल प्रत्येक फ्रेम के अंदर JSON आकार उस स्ट्रीम के साथ बदलता है, जिसमें आप सदस्यता लेते हैं।