असिंक्रोनस पायथन वेब स्क्रैपिंग: aiohttp और Scrapeless के साथ 10,000+ URLs तक स्केल करें

pip install aiohttp scrapeless playwright
playwright install chromium

export SCRAPELESS_API_KEY="your_api_token_here"
export SCRAPELESS_CHANNEL_ID="your_channel_id"          # उपयोगकर्ता नाम की शुरुआत में प्रिंट किया गया
export SCRAPELESS_PROXY_PASS="your_channel_password"
export SCRAPELESS_PROXY_GATEWAY="gw-us.scrapeless.io"   # क्षेत्रीय गेटवे के लिए नीचे देखें

import asyncio
import os
import aiohttp

PROXY = (
    f"http://{os.environ['SCRAPELESS_CHANNEL_ID']}-proxy-country_US"
    f":{os.environ['SCRAPELESS_PROXY_PASS']}"
    f"@{os.environ['SCRAPELESS_PROXY_GATEWAY']}:8789"
)

async def fetch(session: aiohttp.ClientSession, url: str) -> str:
    timeout = aiohttp.ClientTimeout(total=30)
    async with session.get(url, proxy=PROXY, timeout=timeout) as resp:
        resp.raise_for_status()
        return await resp.text()

async def main() -> None:
    async with aiohttp.ClientSession() as session:
        html = await fetch(session, "https://books.toscrape.com/")
        print(f"Fetched {len(html):,} chars via US residential egress")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import os
import aiohttp

PROXY = (
    f"http://{os.environ['SCRAPELESS_CHANNEL_ID']}-proxy-country_US"
    f":{os.environ['SCRAPELESS_PROXY_PASS']}"
    f"@{os.environ['SCRAPELESS_PROXY_GATEWAY']}:8789"
)

# प्रति होस्ट 5 समवर्ती अनुरोधों पर कैप। लक्ष्य के अनुसार समायोजित करें — सार्वजनिक कैटलॉग
# उच्च सहन करते हैं, एंटी-बॉट-संरक्षित मूल कम चाहते हैं।
PER_HOST = asyncio.Semaphore(5)

async def fetch(session: aiohttp.ClientSession, url: str) -> str:
    async with PER_HOST:
        timeout = aiohttp.ClientTimeout(total=30)
        async with session.get(url, proxy=PROXY, timeout=timeout) as resp:

resp.raise_for_status()
            return await resp.text()

async def main() -> None:
    urls = [
        f"https://books.toscrape.com/catalogue/page-{n}.html"
        for n in range(1, 51)  # 50 कैटलॉग पृष्ठ
    ]
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        pages = await asyncio.gather(*tasks)
    print(f"कुल {len(pages)} पृष्ठ मिले, कुल {sum(len(p) for p in pages):,} अक्षर")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import json
import aiohttp

async def fetch_safe(session, url):
    try:
        async with session.get(
            url, timeout=aiohttp.ClientTimeout(total=30)
        ) as resp:
            resp.raise_for_status()
            return {"url": url, "html": await resp.text()}
    except (aiohttp.ClientError, asyncio.TimeoutError) as exc:
        return {"url": url, "error": repr(exc)}

async def main(urls):
    async with aiohttp.ClientSession() as session:
        results = await asyncio.gather(
            *(fetch_safe(session, u) for u in urls)
        )

    ok = [r for r in results if "html" in r]
    failed = [r for r in results if "error" in r]
    print(f"सफल: {len(ok)}   विफल: {len(failed)}")

    # अलग समीक्षा के लिए डेड-लेटर फ़ाइल — पाइपलाइन कभी भी विफलताओं पर रुकती नहीं है
    with open("dead_letter.jsonl", "w", encoding="utf-8") as f:
        for r in failed:
            f.write(json.dumps(r) + "\n")

import asyncio
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from playwright.async_api import async_playwright

async def render_via_cloud_browser(url: str, country: str = "US") -> str:
    client = Scrapeless()  # पर्यावरण से SCRAPELESS_API_KEY पढ़ता है
    session = client.browser.create(
        ICreateBrowser(proxy_country=country, session_ttl=240)
    )

    async with async_playwright() as p:
        browser = await p.chromium.connect_over_cdp(session.browser_ws_endpoint)
        context = browser.contexts[0] if browser.contexts else await browser.new_context()
        page = context.pages[0] if context.pages else await context.new_page()
        await page.goto(url, wait_until="networkidle", timeout=60_000)
        html = await page.content()
        await browser.close()
        return html

async def मुख्य():
    # quotes.toscrape.com/js/ कैननिकल "JS की ज़रूरत" सैंडबॉक्स है।
    # साधारण HTTP 0 उद्धरण तत्व लौटाता है; क्लाउड-Rendered 10 लौटाता है।
    html = await render_via_cloud_browser("https://quotes.toscrape.com/js/")
    print(f"Rendered {len(html):,} अक्षर पोस्ट-पेंट DOM सहित")

if __name__ == "__main__":
    asyncio.runमुख्य())

import asyncio
import os
import aiohttp
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from playwright.async_api import async_playwright

PROXY = (
    f"http://{os.environ['SCRAPELESS_CHANNEL_ID']}-proxy-country_US"
    f":{os.environ['SCRAPELESS_PROXY_PASS']}"
    f"@{os.environ['SCRAPELESS_PROXY_GATEWAY']}:8789"
)
HTTP_LIMIT = asyncio.Semaphore(10)      # aiohttp स्तर
BROWSER_LIMIT = asyncio.Semaphore(3)    # क्लाउड ब्राउज़र स्तर

async def http_fetch(session: aiohttp.ClientSession, url: str) -> str | None:
    async with HTTP_LIMIT:
        try:
            async with session.get(
                url, proxy=PROXY,
                timeout=aiohttp.ClientTimeout(total=30),
            ) as resp:
                resp.raise_for_status()
                return await resp.text()
        except (aiohttp.ClientError, asyncio.TimeoutError):
            return None

async def browser_fetch(client: Scrapeless, url: str) -> str:
    async with BROWSER_LIMIT:
        session = client.browser.create(
            ICreateBrowser(proxy_country="US", session_ttl=240)
        )
        async with async_playwright() as p:
            browser = await p.chromium.connect_over_cdp(session.browser_ws_endpoint)
            context = (
                browser.contexts[0] if browser.contexts
                else await browser.new_context()
            )
            page = await context.new_page()
            await page.goto(url, wait_until="networkidle", timeout=60_000)
            html = await page.content()
            await browser.close()
            return html

from urllib.parse import urlparse

# (a) ज्ञात JS-भारी होस्ट हमेशा वृद्धि — सबसे विश्वसनीय संकेत।
JS_HEAVY_HOSTS = {"quotes.toscrape.com"}

def should_escalate(url: str, html: str | None) -> bool:
    # (a) अनुमति सूची हिट — स्पष्ट JS-भारी होस्ट।
    if urlparse(url).hostname in JS_HEAVY_HOSTS:
        return True
    # (b) पोस्ट-पार्स संकेत — खाली शरीर या पहचानने योग्य ऐप शेल।
    if html is None or len(html) < 2000 or '<div id="root"></div>' in html:
        return True
    return False

async def scrape_one(http_session, client, url):
    html = await http_fetch(http_session, url)
    tier = "http"
    if should_escalate(url, html):
        tier = "browser"
        html = await browser_fetch(client, url)
    return {"url": url, "tier": tier, "html_len": len(html) if html else 0}

async def मुख्य(urls):
    client = Scrapeless()
    async with aiohttp.ClientSession() as http_session:
        results = await asyncio.gather(
            *(scrape_one(http_session, client, u) for u in urls)
        )
    return results

if __name__ == "__main__":
    urls = [
        "https://books.toscrape.com/",       # स्थिर — aiohttp स्तर
        "https://quotes.toscrape.com/js/",   # JS — बढ़ता है
    ]
    print(asyncio.run(main(urls)))

[
  {
    "url": "https://books.toscrape.com/",
    "tier": "http",
    "html_len": 51274
  },
  {
    "url": "https://quotes.toscrape.com/js/",
    "tier": "browser",
    "html_len": 9246
  }
]

- **शीतल कनेक्शन लागत वास्तविक है।** एक ताजे `ClientSession` पर पहला अनुरोध TLS + DNS का भुगतान करता है; उसी सत्र पर बाद के अनुरोध कनेक्शन का पुन: उपयोग करते हैं। प्रति अनुरोध सत्र को फिर से न बनाएं।
- **समानांतरता सीमाएं लक्ष्य पर निर्भर करती हैं, aiohttp पर नहीं।** सार्वजनिक कैटलॉग के लिए प्रति होस्ट पाँच एक सुरक्षित प्रारंभिक बिंदु है; एंटी-बॉट-रक्षित मूल के लिए तीन सुरक्षित हैं; मित्रवत APIs के लिए दस वास्तविकता है।
- **क्लाउड-ब्राउज़र सत्र एकल पृष्ठ लोड से लंबे होते हैं।** यदि एक पाइपलाइन को लॉगिन के साथ-साथ यात्रा करने और निकालने की आवश्यकता है, तो एक तार्किक कार्य-यूनिट के लिए एक सत्र बनाएं और उस इकाई के भीतर पृष्ठों के बीच इसका पुन: उपयोग करें — `context.new_page()` उसी सत्र के भीतर सस्ता है।
- **DNS समाधान aiohttp के भीतर रहता है।** कनेक्टर `ClientSession` की अवधि के लिए हल किए गए IP को कैश करता है। लंबे समय तक चलने वाले क्रॉलर्स के लिए, हर कुछ घंटों में सत्र को पुनर्नवीनीकरण करें ताकि DNS बासी न हो जाए।
- **`ClientTimeout(total=30)` प्रति अनुरोध है, न कि प्रति-`gather`।** 1,000-URL फैन-आउट 30 सेकंड में टाइमआउट नहीं होता — प्रत्येक अनुरोध को अपना 30-सेकंड का बजट मिलता है।

---

## निष्कर्ष: अपने असिंक्रोनस Python स्क्रैपर्स को स्केल करें

असिंक्रोनस पैटर्न चार चालों में घटता है: एक `ClientSession` शुरू करें, `Semaphore` के साथ समानांतरता को सीमित करें, Scrapeless आवासीय प्रॉक्सी के माध्यम से फैन-आउट को रूट करें, और जावास्क्रिप्ट-रेन्डर किए गए अल्पसंख्यक को Scrapeless स्क्रैपिंग ब्राउज़र तक बढ़ाएं, Python SDK और Playwright के असिंक्रोनस API के माध्यम से।

अवासी-प्रॉक्सी परत पर गहराई में जाने के लिए, जो प्रत्येक असिंक्रोनस फ़ेच को रूट करता है, देखें [SSL प्रॉक्सी क्या है?](https://www.scrapeless.com/hi/blog/what-is-an-ssl-proxy-2026)।

प्रॉक्सी उपयोगकर्ता नाम पर देश के उपसर्ग के साथ ईग्रेस को पिन करें, प्रति-होस्ट सेमाफोर्स को कसकर रखें, सफलतापूर्वक बनाम विफलता की आकृति पर शाखा करें न कि अपवादों को इनलाइन में पकड़ते हुए, और एक खाली HTTP प्रतिक्रिया को बढ़ाने का संकेत मानें — न कि उत्तर।

---

## क्या आप अपने AI-संचालित डेटा पाइपलाइन बनाने के लिए तैयार हैं?

हमारे समुदाय में शामिल हों ताकि एक मुफ्त योजना प्राप्त कर सकें और डेवलपर्स के साथ जुड़ सकें जो असिंक्रोनस स्क्रैपिंग पाइपलाइनों का निर्माण कर रहे हैं: [Discord](https://discord.gg/scrapeless) · [Telegram](https://t.me/scrapeless)。

मुफ्त स्क्रैपिंग ब्राउज़र रनटाइम के लिए [Scrapeless](https://app.scrapeless.com/passport/login/?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=async) पर साइन अप करें और ऊपर दिए गए पैटर्नों को कैटलॉग, फ़ीड और क्षेत्रों में अनुकूलित करें जिनकी पाइपलाइन को आवश्यकता है। मूल्य निर्धारण विवरण देखें [scrapeless.com/en/pricing](https://www.scrapeless.com/hi/pricing); आवासीय प्रॉक्सी का दस्तावेजीकरण [scrapeless.com/en/product/proxy-solutions](https://www.scrapeless.com/hi/product/proxy-solutions) पर है; पूर्ण SDK संदर्भ [docs.scrapeless.com](https://docs.scrapeless.com) पर है।

---

## सामान्य प्रश्न

**प्रश्न 1: मैं प्रति होस्ट कितने समवर्ती अनुरोध चलाना चाहिए?**

सार्वजनिक कैटलॉग के लिए जिनमें कोई एंटी-बॉट स्टैक नहीं है, प्रति होस्ट 10 इन-फ्लाइट अनुरोध एक सुरक्षित सीमा है। एंटी-बॉट-रक्षित मूल के लिए, 3 अधिक वास्तविक है। सेमाफोर एक लिवर है; कम से शुरू करें, 429 प्रतिक्रियाओं के लिए देखें, और वहां से ट्यून करें।

**प्रश्न 2: क्या मुझे Scrapeless आवासीय प्रॉक्सी की आवश्यकता है यदि मेरा लक्ष्य मेरे डेटा सेंटर से अनब्लॉक है?**

अनब्लॉक HTTP लक्ष्यों के लिए, नहीं — aiohttp प्रॉक्सी के बिना काम करता है। Scrapeless प्रॉक्सी परत अपनी जगह तब कमाती है जब लक्ष्य भू-सीमित होता है (आपको यूएस/यूके/जेपी ईग्रेस की आवश्यकता होती है), जब आपका डेटा सेंटर IP दर-सीमित या अवरुद्ध होता है, या जब आपको कई मूल के बीच उड़ान पूल फैलाने के लिए प्रत्येक अनुरोध के लिए एक ताजा आवासीय IP की आवश्यकता होती है।

**प्रश्न 3: मुझे कब aiohttp से Scrapeless स्क्रैपिंग ब्राउज़र पर बढ़ाना चाहिए?**

जब HTML जो aiohttp लौटाता है, एक JS-एप्लिकेशन शेल है जिसमें कोई सामग्री नहीं है। ह्यूरिस्टिक: पहले स्तर के फ़ेच के बाद आप जिन तत्वों की परवाह करते हैं उनकी गिनती करें; यदि गिनती शून्य या अपेक्षित से बहुत कम है, तो पृष्ठ क्लाइंट-साइड में रेंडर होता है। क्लाउड ब्राउज़र स्तर उनका प्रबंधन करता है।

**प्रश्न 4: क्या असिंक्रोनस स्क्रैपिंग कानूनी है?**

असिंक्रोनस एक परिवहन पैटर्न है; वैधता इस पर निर्भर करती है कि आप क्या स्क्रैप करते हैं, कहाँ से, और किन शर्तों के तहत। सार्वजनिक रूप से दृश्य डेटा आमतौर पर सुलभ होता है; न्यायालयों में भिन्नता होती है; साइट सेवा की शर्तें लागू होती हैं; उच्च-दांव उपयोग मामलों के लिए सलाह लेने के लिए परामर्श करें। Scrapeless केवल सार्वजनिक रूप से उपलब्ध डेटा पर पहुंचता है।

**प्रश्न 5: क्या मैं Scrapeless स्क्रैपिंग ब्राउज़र के बिना aiohttp का उपयोग कर सकता हूँ?**

हाँ। aiohttp स्तर (चरण 3–5) किसी भी लक्ष्य के लिए एक पूर्ण असिंक्रोनस स्क्रैपर के रूप में काम करता है जो रेंडर किया गया HTML भेजता है। Scrapeless स्क्रैपिंग ब्राउज़र बढ़ाने की परत है — केवल तब बुलाया जाता है जब HTTP स्तर खाली लौटता है।

**प्रश्न 6: मैं किसी विशिष्ट देश के लिए ईग्रेस को कैसे पिन करूं?**

देश को Scrapeless आवासीय-प्रॉक्सी उपयोगकर्ता नाम में `country_<CC>` (बड़े अक्षर दो-लेटर कोड, अंडरस्कोर से अलग किया गया) के रूप में डालें: `country_US`, `country_UK`, `country_DE`, `country_JP`। उपयोगकर्ता नाम स्ट्रिंग में चरण को बदलें और गेटवे हर अनुरोध को उस देश में आवासीय IP के माध्यम से रूट करता है। ब्राउज़र-स्तरीय अनुरोधों के लिए, क्लाउड-ब्राउज़र सत्र को बनाते समय `ICreateBrowser(...)` में `proxy_country="US"` पास करें।

**प्रश्न 7: Playwright के असिंक्रोनस API का उपयोग क्यों करें न कि एक समन्वयित ब्राउज़र क्लाइंट?**
सिंक ब्राउज़र क्लाइंट इवेंट लूप को रोकते हैं। asyncio का पूरा उद्देश्य लूप को फ्री रखना है; एक coroutine के अंदर से सिंक `page.goto(...)` को कॉल करने से हर अन्य चलती हुई टास्क रुक जाती है। Playwright का `async_playwright` ही एकमात्र मानक पायथन विकल्प है जो क्लाउड-ब्राउज़र स्तर को coroutine-मित्रवत रखता है। Scrapeless SDK अभी भी सत्र को मिंट करता है — Playwright केवल `browser_ws_endpoint` के लिए CDP से बात करता है।