मुख्य सामग्री पर जाएँ
    डेटा कलेक्शन और कीमतों की मॉनिटरिंग

    वेब स्क्रैपिंग के लिए मोबाइल प्रॉक्सी

    स्क्रैपर को ऐसा एड्रेस चाहिए जिसे साइट पहले सौ अनुरोधों में ही न काट दे। ऑपरेटर का एक बाहरी IP सैकड़ों सब्सक्राइबर साझा करते हैं, इसलिए उसे ब्लॉक करना साइट के लिए बहुत महँगा पड़ता है। Mobihub में प्रॉक्सी आपके अपने फ़ोन पर चलती हैं: IP आपकी स्क्रिप्ट के लिंक से या टाइमर से बदलता है, और HTTP और SOCKS5 एक ही पोर्ट पर चलते हैं।

    3 मिनट से
    टाइमर से IP बदलने का अंतराल
    1 लिंक
    आपकी स्क्रिप्ट से IP बदलना
    HTTP + SOCKS5
    एक ही पोर्ट पर
    100 Mbps
    Professional प्लान पर स्पीड
    डायग्राम: SIM कार्ड वाले तीन फ़ोन स्क्रैपर को डेटा देते हैं; IP बदलने के बाद एक जवाब 429 से 200 हो जाता है

    स्क्रैपर ब्लॉक क्यों होते हैं

    वेबसाइटें हर एड्रेस से आने वाले अनुरोध गिनती हैं। डेटा सेंटर के सबनेट लंबे समय से सूचियों में हैं, और सुरक्षित साइट ऐसे IP को अक्सर पहले ही अनुरोध पर कैप्चा दिखाती है। साफ़ एड्रेस को भी कुछ सौ अनुरोधों के बाद 429 या चैलेंज पेज मिलता है।

    मोबाइल एड्रेस को ब्लॉक करना महँगा है: उसके पीछे ऑपरेटर के आम सब्सक्राइबर होते हैं। अगर फिर भी लिमिट पूरी हो जाए, तो IP लिंक से बदलता है: फ़ोन कुछ सेकंड के लिए एयरप्लेन मोड में जाता है और ऑपरेटर से नया एड्रेस लेकर फिर ऑनलाइन आता है।

    बड़े वॉल्यूम के लिए कई फ़ोन का पूल चाहिए। नीचे दी गई स्क्रिप्ट पेज URL को प्रॉक्सी में बाँटती है और IP सिर्फ़ उसी पर बदलती है जो ब्लॉक हुई, बाकी काम करती रहती हैं।

    कीमतें

    एक महीने के लिए पाँच फ़ोन का पूल

    विजेट Professional, पाँच डिवाइस और 30 दिन पर खुलता है। स्क्रैपिंग के लिए इस प्लान का मुख्य फ़र्क स्पीड है: Beginner के 5 Mbps की जगह 100 Mbps तक। पाँच डिवाइस पर वॉल्यूम डिस्काउंट मिलता है, और “प्रति डिवाइस / महीना” वाली पंक्ति एक प्रॉक्सी की कीमत दिखाती है।

    प्लान
    डिवाइस की संख्या5
    5 और डिवाइस जोड़ें — और हर डिवाइस की कीमत 12% घट जाएगी।
    जितने ज़्यादा डिवाइस और जितना लंबा सब्सक्रिप्शन, एक डिवाइस उतना ही सस्ता।
    भुगतान अवधि
    क्या शामिल है
    HTTP, SOCKS5 और UDPलिंक से IP बदलनालॉगिन और IP से ऑथराइज़ेशनअनुमत एड्रेस की सूचीट्रैफ़िक और थ्रेड की सीमाएँAPI एक्सेस
    कुल
    $32.90
    30 दिन · 5 डिवाइस के लिए
    प्रति दिन कीमत$1.10
    प्रति डिवाइस / महीना$6.58
    वॉल्यूम छूट−6%
    1 दिन से भुगतान, ऑटो-रिन्यूअल नहीं
    निर्देश

    पूल को स्क्रैपर से कैसे जोड़ें

    कदम दो फ़ोन और बीस फ़ोन के लिए एक जैसे हैं।

    1. फ़ोन कनेक्ट करें

      दो या तीन ऑपरेटर के SIM कार्ड वाले Android फ़ोन पर Mobihub इंस्टॉल करें और हर फ़ोन पर Professional प्लान पर प्रॉक्सी बनाएँ।

    2. Unique IP चालू करें

      एड्रेस बदलते समय फ़ोन कई कोशिशें करता है, जब तक उसे ऐसा IP न मिले जो इस प्रॉक्सी पर पहले नहीं रहा; कोशिशों की संख्या सेटिंग्स में तय होती है। स्क्रैपर ऐसे एड्रेस पर कम पहुँचता है जिसे साइट ने हाल में ब्लॉक किया हो।

    3. proxies.csv बनाएँ

      हर प्रॉक्सी के लिए डैशबोर्ड से कनेक्शन एड्रेस और IP बदलने का लिंक लें। फ़ाइल में तीन कॉलम हैं: name, proxy और rotate_url।

    4. रफ़्तार तय करें

      एक फ़ोन से अनुरोधों के बीच दो से तीन सेकंड के ठहराव से शुरू करें और ब्लॉक बार-बार हों तो इसे बढ़ाएँ। बार-बार IP बदलना शांत रफ़्तार की जगह नहीं ले सकता।

    5. स्क्रिप्ट चलाएँ और सारांश पढ़ें

      हर कोशिश results.jsonl में दर्ज होती है। आख़िर में स्क्रिप्ट हर प्रॉक्सी के अनुरोध, ब्लॉक और IP बदलाव की संख्या दिखाती है।

    काम करने वाला कोड

    स्क्रिप्ट: ब्लॉक पर IP बदलने वाले पूल से स्क्रैपिंग

    स्क्रिप्ट urls.txt से URL लेकर उन्हें proxies.csv की प्रॉक्सी में बाँटती है, हर फ़ोन के लिए एक थ्रेड। 403, 429 या कैप्चा पेज को ब्लॉक माना जाता है: URL कतार में वापस जाता है, कुकीज़ साफ़ होती हैं और प्रॉक्सी का IP बदलने वाला लिंक कॉल होता है। स्क्रिप्ट नए एड्रेस का इंतज़ार करती है और आगे बढ़ती है, जबकि बाकी फ़ोन काम करते रहते हैं। अगर IP नहीं बदलता, तो फ़ोन पूल से बाहर हो जाता है और उसके URL बाकी ले लेते हैं। पेज कोड में reCAPTCHA स्क्रिप्ट को ब्लॉक नहीं माना जाता: स्क्रिप्ट वह चैलेंज टेक्स्ट ढूँढती है जो इंसान को दिखता है।

    प्रॉक्सी पूल के लिए स्क्रिप्ट का सारांश: हर फ़ोन के अनुरोध, ब्लॉक और IP बदलाव
    pool_scraper.pyPython
    import csv
    import json
    import queue
    import random
    import re
    import threading
    import time
    from concurrent.futures import ThreadPoolExecutor
    from datetime import datetime, timezone
    
    import requests
    
    PROXIES_FILE = "proxies.csv"
    URLS_FILE = "urls.txt"
    RESULTS_FILE = "results.jsonl"
    IP_ECHO = "https://api.ipify.org"
    BLOCK_CODES = {403, 429}
    BLOCK_PHRASES = ("verify you are human", "are you a robot", "unusual traffic", "access denied", "не робот")
    PAUSE = (1.5, 3.5)
    MAX_ATTEMPTS = 3
    ROTATE_TIMEOUT = 90
    REFUSED_WAIT = 60
    ROTATE_TRIES = 3
    HEADERS = {
        "User-Agent": "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 "
        "(KHTML, like Gecko) Chrome/126.0 Mobile Safari/537.36",
    }
    
    write_lock = threading.Lock()
    
    
    def exit_ip(session):
        try:
            return session.get(IP_ECHO, timeout=15).text.strip()
        except requests.RequestException:
            return None
    
    
    def request_change(proxy):
        for attempt in range(ROTATE_TRIES):
            if attempt:
                time.sleep(REFUSED_WAIT)
            try:
                answer = requests.get(proxy["rotate_url"], timeout=15).json()
            except (requests.RequestException, ValueError):
                answer = {}
            if answer.get("result") == "Success":
                return True
        return False
    
    
    def rotate(proxy, session):
        previous = exit_ip(session)
        if not request_change(proxy):
            return False
        deadline = time.time() + ROTATE_TIMEOUT
        while time.time() < deadline:
            time.sleep(5)
            current = exit_ip(session)
            if current and current != previous:
                return True
        return False
    
    
    def visible_text(html):
        html = re.sub(r"(?is)<(script|style)\b.*?</\1>", " ", html[:20000])
        return re.sub(r"<[^>]+>", " ", html).lower()
    
    
    def blocked(response):
        if response.status_code in BLOCK_CODES:
            return True
        text = visible_text(response.text)
        return any(phrase in text for phrase in BLOCK_PHRASES)
    
    
    def handle(session, proxy, stats, tasks, url, attempt):
        record = {
            "at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
            "url": url,
            "proxy": proxy["name"],
            "attempt": attempt,
        }
        retry = False
        usable = True
        try:
            response = session.get(url, timeout=30)
            stats["requests"] += 1
            record["status"] = response.status_code
            if blocked(response):
                stats["blocks"] += 1
                record["state"] = "blocked"
                retry = True
                session.cookies.clear()
                if rotate(proxy, session):
                    stats["rotations"] += 1
                else:
                    usable = False
            else:
                record["state"] = "ok"
                record["bytes"] = len(response.content)
        except requests.RequestException as error:
            record["state"] = f"error: {type(error).__name__}"
            retry = True
        if retry and attempt < MAX_ATTEMPTS:
            tasks.put((url, attempt + 1))
        return record, usable
    
    
    def worker(proxy, tasks, results):
        session = requests.Session()
        session.proxies = {"http": proxy["proxy"], "https": proxy["proxy"]}
        session.headers.update(HEADERS)
        stats = {"name": proxy["name"], "requests": 0, "blocks": 0, "rotations": 0}
        while True:
            try:
                url, attempt = tasks.get(timeout=1)
            except queue.Empty:
                if tasks.unfinished_tasks == 0:
                    return stats
                continue
            try:
                record, usable = handle(session, proxy, stats, tasks, url, attempt)
            finally:
                tasks.task_done()
            with write_lock:
                results.write(json.dumps(record, ensure_ascii=False) + "\n")
                results.flush()
            if not usable:
                print(f"{proxy['name']}: IP did not change, the proxy leaves the pool")
                return stats
            time.sleep(random.uniform(*PAUSE))
    
    
    def main():
        with open(PROXIES_FILE, newline="") as f:
            pool = list(csv.DictReader(f))
        tasks = queue.Queue()
        with open(URLS_FILE) as f:
            for line in f:
                if line.strip():
                    tasks.put((line.strip(), 1))
    
        with open(RESULTS_FILE, "a") as results, ThreadPoolExecutor(len(pool)) as executor:
            summary = list(executor.map(lambda proxy: worker(proxy, tasks, results), pool))
    
        print(f"{'proxy':<12}{'requests':>10}{'blocks':>8}{'rotations':>11}")
        for row in summary:
            print(f"{row['name']:<12}{row['requests']:>10}{row['blocks']:>8}{row['rotations']:>11}")
        if tasks.qsize():
            print(f"{tasks.qsize()} URLs left: every proxy in the pool is blocked")
    
    
    if __name__ == "__main__":
        main()

    IP बदलने वाला लिंक कोड 200 के साथ जवाब देता है और बॉडी में Success या Failure लिखता है। Failure तब आता है, उदाहरण के लिए, जब बदलाव बहुत बार माँगे जाएँ: स्क्रिप्ट एक मिनट रुकती है और दो बार और कोशिश करती है। जब तक फ़ोन एयरप्लेन मोड में है, उसकी प्रॉक्सी उपलब्ध नहीं होती, इसलिए एक बदलाव में दसियों सेकंड लगते हैं।

    प्लान

    स्क्रैपिंग के लिए कौन सा प्लान लें

    स्क्रैपिंग के लिए प्लान का फ़र्क स्पीड और ट्रैफ़िक की बचत पर आकर टिकता है।

    Beginner

    साइट टेस्ट करना और स्क्रिप्ट डीबग करना

    5 Mbps तक की स्पीड यह देखने के लिए काफ़ी है कि साइट मोबाइल एड्रेस पर कैसी प्रतिक्रिया देती है, और पेजों की छोटी सूची पर स्क्रैपर डीबग करने के लिए भी।

    • 30 दिन के लिए प्रति डिवाइस $4
    • 5 Mbps तक स्पीड
    • लिंक और टाइमर से IP बदलना
    • लॉगिन या अनुमत IP सूची से एक्सेस
    चुनें Beginner
    प्लान की पूरी तुलना
    सुझाव

    एड्रेस जलाए बिना डेटा कैसे जुटाएँ

    सिर्फ़ सार्वजनिक डेटा

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

    रफ़्तार रोटेशन से ज़्यादा अहम है

    साइट एड्रेस से पहले रफ़्तार पर ध्यान देती है। अनुरोधों के बीच रैंडम ठहराव बार-बार IP बदलने से ज़्यादा ब्लॉक घटाता है।

    कुकीज़ एक एड्रेस से जुड़ी होती हैं

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

    पूल में कई ऑपरेटर

    दो या तीन ऑपरेटर के SIM कार्ड अलग-अलग सबनेट के एड्रेस देते हैं, और एक ऑपरेटर में दिक्कत होने पर पूरा पूल नहीं रुकता।

    सिर्फ़ ज़रूरी बाइट

    इमेज और स्क्रिप्ट वाला पेज कई मेगाबाइट का होता है। साइट का HTML या API बिना अतिरिक्त रिसोर्स के माँगें, और Professional पर कनेक्शन के लिए ट्रैफ़िक लिमिट सेट करें।

    FAQ

    सवाल और जवाब

    लिंक से IP कितनी बार बदला जा सकता है?

    एक बदलाव में एयरप्लेन मोड का समय, 1 से 20 सेकंड, और फ़ोन के दोबारा कनेक्ट होने के लिए लगभग 20 सेकंड लगते हैं। बहुत बार आने वाले अनुरोधों को लिंक Failure जवाब के साथ ठुकरा देता है। टाइमर से बदलाव तीन मिनट से शुरू होने वाले अंतराल के साथ सेट किया जा सकता है।

    एक फ़ोन से स्क्रैपर के कितने थ्रेड चलाने चाहिए?

    एक या दो से शुरू करें। स्पीड मोबाइल नेटवर्क पर टिकी है, और साइट हर थ्रेड को एक ही एड्रेस से देखती है और उसे जल्दी सीमित करती है। वॉल्यूम पूल में फ़ोन की संख्या से बढ़ाएँ। Professional पर आप हर कनेक्शन के लिए एक साथ चलने वाले कनेक्शन की सीमा तय कर सकते हैं।

    क्या प्रॉक्सी Selenium और Playwright के साथ काम करती हैं?

    हाँ। Playwright ब्राउज़र लॉन्च के विकल्पों में प्रॉक्सी एड्रेस, लॉगिन और पासवर्ड लेता है। Selenium के लिए अपने सर्वर का IP अनुमत सूची में जोड़ना और बिना पासवर्ड प्रॉक्सी से कनेक्ट करना आसान है।

    क्या मैं ऐसी साइटें स्क्रैप कर सकता हूँ जो सिर्फ़ एक देश से खुलती हैं?

    हाँ, अगर लोकल ऑपरेटर के SIM वाला फ़ोन उसी देश में काम करता है: साइट ऑपरेटर का एड्रेस देखती है। अगर वहाँ आपका फ़ोन नहीं है, तो उस देश की मोबाइल प्रॉक्सी Mobihub Market पर किराये पर ली जा सकती है।

    IP बदलने के बाद भी साइट ब्लॉक क्यों करती रहती है?

    साइट स्क्रैपर को एड्रेस के अलावा भी पहचान सकती है: कुकीज़, हेडर, ब्राउज़र फ़िंगरप्रिंट और अनुरोधों की रफ़्तार से। IP बदलने के साथ सेशन साफ़ करें, User-Agent जाँचें और ठहराव बढ़ाएँ। अगर ब्लॉक हर एड्रेस पर बना रहता है, तो कलेक्शन का तरीका ही सीमित है।

    स्क्रैपिंग के लिए मोबाइल प्रॉक्सी सर्वर प्रॉक्सी से बेहतर क्यों है?

    सर्वर प्रॉक्सी सस्ती और तेज़ है, लेकिन कई सुरक्षित साइटें डेटा सेंटर के सबनेट को पूरी तरह सीमित करती हैं। मोबाइल एड्रेस ऑपरेटर के आम सब्सक्राइबर साझा करते हैं, इसलिए वह कम ब्लॉक होता है। बिना सुरक्षा वाली साइटों के लिए सर्वर एड्रेस काफ़ी हैं; सुरक्षित साइटों पर मोबाइल प्रॉक्सी कैप्चा और दोबारा कोशिशों में लगने वाला समय बचाती है।
    समाधान

    दूसरे कामों के लिए मोबाइल प्रॉक्सी

    Instagram के लिए मोबाइल प्रॉक्सीहर सेशन के लिए नया IP और SMM टीम के लिए लॉगिन जर्नल।Facebook के लिए मोबाइल प्रॉक्सीविज्ञापन अकाउंट के लिए साफ़ एड्रेस और आपके सिम के IP पूल की जाँच।TikTok के लिए मोबाइल प्रॉक्सीअकाउंट का क्षेत्र आपके फ़ोन की जगह से और पोस्ट से पहले जियो की जाँच।Avito के लिए मोबाइल प्रॉक्सीआपके क्षेत्र का ऑपरेटर एड्रेस और लिस्टिंग की तय समय पर जाँच।एंटीडिटेक्ट ब्राउज़र के लिए मोबाइल प्रॉक्सीDolphin Anty, Octo, AdsPower और दूसरों के लिए तैयार इंपोर्ट सूचियाँ।Telegram के लिए मोबाइल प्रॉक्सीअकाउंट के लिए ऑपरेटर का अपना एड्रेस और तैयार t.me/socks लिंक।Google Ads के लिए मोबाइल प्रॉक्सीक्लाइंट अकाउंट अलग एड्रेस पर और मोबाइल नेटवर्क से लैंडिंग पेज की जाँच।YouTube के लिए मोबाइल प्रॉक्सीक्लाइंट चैनल अलग-अलग एड्रेस पर, और वीडियो की जाँच दर्शकों के देश से।SEO के लिए मोबाइल प्रॉक्सीफ़ोन के क्षेत्र के मोबाइल सर्च नतीजे और अलग-अलग ऑपरेटर से साइट की जाँच।रीसेलिंग के लिए मोबाइल प्रॉक्सीहर ख़रीदार के लिए अलग एक्सेस और लिमिट, साथ में किराये और भुगतान की रिपोर्ट।मार्केटप्लेस पर मोबाइल प्रॉक्सी से पैसे कमाएँख़रीदार कैटलॉग से आते हैं, किराया प्रति मिनट लगता है, कमाई USDT में निकलती है।पुराने फ़ोन से पैसे कमाएँSIM कार्ड वाला पुराना Android मोबाइल प्रॉक्सी के रूप में किराये पर जाता है।अपना मोबाइल प्रॉक्सी फ़ार्मफ़ोन, SIM कार्ड, बिजली, लागत और रैक की मॉनिटरिंग।

    अपनी साइट को मोबाइल IP पर टेस्ट करें

    नए ग्राहकों को सपोर्ट 24 घंटे का मुफ़्त एक्सेस देता है। फ़ोन कनेक्ट करें, पेजों की छोटी सूची पर स्क्रिप्ट चलाएँ और देखें कि कितने ब्लॉक बचे।