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

स्क्रैपर ब्लॉक क्यों होते हैं
वेबसाइटें हर एड्रेस से आने वाले अनुरोध गिनती हैं। डेटा सेंटर के सबनेट लंबे समय से सूचियों में हैं, और सुरक्षित साइट ऐसे IP को अक्सर पहले ही अनुरोध पर कैप्चा दिखाती है। साफ़ एड्रेस को भी कुछ सौ अनुरोधों के बाद 429 या चैलेंज पेज मिलता है।
मोबाइल एड्रेस को ब्लॉक करना महँगा है: उसके पीछे ऑपरेटर के आम सब्सक्राइबर होते हैं। अगर फिर भी लिमिट पूरी हो जाए, तो IP लिंक से बदलता है: फ़ोन कुछ सेकंड के लिए एयरप्लेन मोड में जाता है और ऑपरेटर से नया एड्रेस लेकर फिर ऑनलाइन आता है।
बड़े वॉल्यूम के लिए कई फ़ोन का पूल चाहिए। नीचे दी गई स्क्रिप्ट पेज URL को प्रॉक्सी में बाँटती है और IP सिर्फ़ उसी पर बदलती है जो ब्लॉक हुई, बाकी काम करती रहती हैं।
एक महीने के लिए पाँच फ़ोन का पूल
विजेट Professional, पाँच डिवाइस और 30 दिन पर खुलता है। स्क्रैपिंग के लिए इस प्लान का मुख्य फ़र्क स्पीड है: Beginner के 5 Mbps की जगह 100 Mbps तक। पाँच डिवाइस पर वॉल्यूम डिस्काउंट मिलता है, और “प्रति डिवाइस / महीना” वाली पंक्ति एक प्रॉक्सी की कीमत दिखाती है।
पूल को स्क्रैपर से कैसे जोड़ें
कदम दो फ़ोन और बीस फ़ोन के लिए एक जैसे हैं।
फ़ोन कनेक्ट करें
दो या तीन ऑपरेटर के SIM कार्ड वाले Android फ़ोन पर Mobihub इंस्टॉल करें और हर फ़ोन पर Professional प्लान पर प्रॉक्सी बनाएँ।
Unique IP चालू करें
एड्रेस बदलते समय फ़ोन कई कोशिशें करता है, जब तक उसे ऐसा IP न मिले जो इस प्रॉक्सी पर पहले नहीं रहा; कोशिशों की संख्या सेटिंग्स में तय होती है। स्क्रैपर ऐसे एड्रेस पर कम पहुँचता है जिसे साइट ने हाल में ब्लॉक किया हो।
proxies.csv बनाएँ
हर प्रॉक्सी के लिए डैशबोर्ड से कनेक्शन एड्रेस और IP बदलने का लिंक लें। फ़ाइल में तीन कॉलम हैं: name, proxy और rotate_url।
रफ़्तार तय करें
एक फ़ोन से अनुरोधों के बीच दो से तीन सेकंड के ठहराव से शुरू करें और ब्लॉक बार-बार हों तो इसे बढ़ाएँ। बार-बार IP बदलना शांत रफ़्तार की जगह नहीं ले सकता।
स्क्रिप्ट चलाएँ और सारांश पढ़ें
हर कोशिश results.jsonl में दर्ज होती है। आख़िर में स्क्रिप्ट हर प्रॉक्सी के अनुरोध, ब्लॉक और IP बदलाव की संख्या दिखाती है।
स्क्रिप्ट: ब्लॉक पर IP बदलने वाले पूल से स्क्रैपिंग
स्क्रिप्ट urls.txt से URL लेकर उन्हें proxies.csv की प्रॉक्सी में बाँटती है, हर फ़ोन के लिए एक थ्रेड। 403, 429 या कैप्चा पेज को ब्लॉक माना जाता है: URL कतार में वापस जाता है, कुकीज़ साफ़ होती हैं और प्रॉक्सी का IP बदलने वाला लिंक कॉल होता है। स्क्रिप्ट नए एड्रेस का इंतज़ार करती है और आगे बढ़ती है, जबकि बाकी फ़ोन काम करते रहते हैं। अगर IP नहीं बदलता, तो फ़ोन पूल से बाहर हो जाता है और उसके URL बाकी ले लेते हैं। पेज कोड में reCAPTCHA स्क्रिप्ट को ब्लॉक नहीं माना जाता: स्क्रिप्ट वह चैलेंज टेक्स्ट ढूँढती है जो इंसान को दिखता है।

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 तब आता है, उदाहरण के लिए, जब बदलाव बहुत बार माँगे जाएँ: स्क्रिप्ट एक मिनट रुकती है और दो बार और कोशिश करती है। जब तक फ़ोन एयरप्लेन मोड में है, उसकी प्रॉक्सी उपलब्ध नहीं होती, इसलिए एक बदलाव में दसियों सेकंड लगते हैं।
स्क्रैपिंग के लिए कौन सा प्लान लें
स्क्रैपिंग के लिए प्लान का फ़र्क स्पीड और ट्रैफ़िक की बचत पर आकर टिकता है।
साइट टेस्ट करना और स्क्रिप्ट डीबग करना
5 Mbps तक की स्पीड यह देखने के लिए काफ़ी है कि साइट मोबाइल एड्रेस पर कैसी प्रतिक्रिया देती है, और पेजों की छोटी सूची पर स्क्रैपर डीबग करने के लिए भी।
- 30 दिन के लिए प्रति डिवाइस $4
- 5 Mbps तक स्पीड
- लिंक और टाइमर से IP बदलना
- लॉगिन या अनुमत IP सूची से एक्सेस
लगातार डेटा कलेक्शन
प्रति डिवाइस 100 Mbps तक, Unique IP और SmartRelay: फ़ोन पेज मोबाइल नेटवर्क से डाउनलोड करता है और Wi‑Fi से सर्वर को भेजता है, इसलिए SIM का डेटा प्लान लगभग आधी रफ़्तार से ख़त्म होता है।
- 30 दिन के लिए प्रति डिवाइस $7
- 100 Mbps तक स्पीड
- बदलाव के बाद Unique IP
- SmartRelay और वॉल्यूम डिस्काउंट
एड्रेस जलाए बिना डेटा कैसे जुटाएँ
सिर्फ़ सार्वजनिक डेटा
वही जुटाएँ जो साइट बिना लॉग इन के दिखाती है, उसकी शर्तों और निजी डेटा के क़ानूनों का पालन करें। एड्रेस बदलने से मना किया गया कलेक्शन क़ानूनी नहीं हो जाता।
रफ़्तार रोटेशन से ज़्यादा अहम है
साइट एड्रेस से पहले रफ़्तार पर ध्यान देती है। अनुरोधों के बीच रैंडम ठहराव बार-बार IP बदलने से ज़्यादा ब्लॉक घटाता है।
कुकीज़ एक एड्रेस से जुड़ी होती हैं
अगर साइट पहली विज़िट पर कुकीज़ सेट करती है, तो उन्हें एक प्रॉक्सी के सेशन में रखें और हर IP बदलाव पर साफ़ करें। एक एड्रेस को दी गई कुकीज़ दूसरे एड्रेस से आएँ, तो यह संदिग्ध लगता है।
पूल में कई ऑपरेटर
दो या तीन ऑपरेटर के SIM कार्ड अलग-अलग सबनेट के एड्रेस देते हैं, और एक ऑपरेटर में दिक्कत होने पर पूरा पूल नहीं रुकता।
सिर्फ़ ज़रूरी बाइट
इमेज और स्क्रिप्ट वाला पेज कई मेगाबाइट का होता है। साइट का HTML या API बिना अतिरिक्त रिसोर्स के माँगें, और Professional पर कनेक्शन के लिए ट्रैफ़िक लिमिट सेट करें।
सवाल और जवाब
लिंक से IP कितनी बार बदला जा सकता है?
एक फ़ोन से स्क्रैपर के कितने थ्रेड चलाने चाहिए?
क्या प्रॉक्सी Selenium और Playwright के साथ काम करती हैं?
क्या मैं ऐसी साइटें स्क्रैप कर सकता हूँ जो सिर्फ़ एक देश से खुलती हैं?
IP बदलने के बाद भी साइट ब्लॉक क्यों करती रहती है?
स्क्रैपिंग के लिए मोबाइल प्रॉक्सी सर्वर प्रॉक्सी से बेहतर क्यों है?
दूसरे कामों के लिए मोबाइल प्रॉक्सी
अपनी साइट को मोबाइल IP पर टेस्ट करें
नए ग्राहकों को सपोर्ट 24 घंटे का मुफ़्त एक्सेस देता है। फ़ोन कनेक्ट करें, पेजों की छोटी सूची पर स्क्रिप्ट चलाएँ और देखें कि कितने ब्लॉक बचे।