اس مضمون میں
گوگل سرچ کے مطابق، ایک دن میں 10 ارب سے زیادہ سرچز ہوتی ہیں۔ ایپس کا کاروبار. ہم میں سے ہر ایک روزانہ درجنوں مخصوص درخواستیں کرتا ہے۔ گوگل خود ایپلی کیشنز اور سروسز کے ایک پیچیدہ نظام میں تیار ہوا ہے جو صارفین کو مختلف پوچھ گچھ کو حل کرنے میں مدد کرتا ہے۔ Google Maps ان میں سے ایک ہے، اور خیال کیا جاتا ہے کہ جب یہ نیویگیشن اور سفر کے لیے پلیٹ فارمز کا انتخاب کرنے کی بات آتی ہے تو یہ فہرست میں پہلے نمبر پر آتا ہے۔
ہمارا بلاگ پہلے ہی کور کر چکا ہے۔ ایمیزون پروڈکٹ ڈیٹا سکریپنگ اور GitHub سے رجحان ساز ذخیروں کا مجموعہ. اس گائیڈ میں، ہم وضاحت کرتے ہیں کہ گوگل سرچ اور میپس کو چند مراحل میں کیسے اسکریپ کیا جائے۔ ہم ساتھ ساتھ پراکسی بھی استعمال کریں گے۔ dataimpulse.com 90 ملین سے زیادہ اخلاقی طور پر حاصل کردہ رہائشی پراکسی فراہم کرنے والا ہے اور اس کے پاس 20 ملین ڈیٹا سینٹر اور 16 ملین موبائل پراکسیز کا نیٹ ورک ہے۔
کلیدی حقائق
- گوگل سروسز ہر جگہ وسیع پیمانے پر استعمال ہوتی ہیں، اس لیے یہ جاننا کہ مقام پر مبنی ڈیٹا کو کیسے اسکریپ کرنا ہے کسی بھی ڈویلپر کے لیے مہارت کا ہونا ضروری ہے۔
- سکریپنگ شروع کرنے کے لیے، صارفین کو Playwright کے ساتھ Python انسٹال کرنا چاہیے اور مزید کنفیگریشن کے لیے پراکسی اسناد کو محفوظ کرنا چاہیے۔
- DataImpulse سے پراکسی سیشنز کے دوران مستحکم کنکشن اور پوشیدہ ہونے کو یقینی بنائیں، جو محفوظ سکریپنگ سرگرمی کے لیے ناقابلِ مذاکرات ہیں۔
- ٹارگٹ ویب سائٹس کی سروس کی شرائط کو ہمیشہ چیک کریں اور ان کا احترام کریں۔ غیر قانونی سرگرمیوں کے لیے سکریپنگ کا استعمال نہ کریں۔
شرطیں
اگر آپ Google SERP ڈیٹا اسکریپ کرنے جا رہے ہیں، تو آپ کو یقینی طور پر آلات کے ایک مخصوص سیٹ کی ضرورت ہوگی۔ ان میں سے کچھ یہ ہیں:
- ازگر، تازہ ترین ورژن۔ ہم اس گائیڈ کے لیے macOS استعمال کر رہے ہیں۔ ڈاؤن لوڈ کریں۔ یہاں، VS کوڈ میں Python ایکسٹینشن انسٹال کریں۔ ٹرمینل کھولیں، چیک کریں کہ آیا یہ انسٹال ہے:
python3 --version
- بصری اسٹوڈیو کوڈ (یا دوسرا کوڈ ایڈیٹر)۔ ڈاؤن لوڈ کریں۔ یہاںاپنے پروجیکٹ فولڈر کو انسٹال کریں اور کھولیں۔
- ڈرامہ نگار براؤزر سیٹ اپ. اپنے ٹرمینل میں چلا کر Playwright انسٹال کریں:
pip3 install playwright
- پراکسی اسناد DataImpulse ڈیش بورڈ سے۔ سائن ان کریں۔ DataImpulse پر جائیں اور اپنی پراکسی تفصیلات کاپی کریں، جیسے ہوسٹ، پورٹ، لاگ ان، اور پاس ورڈ۔
- بلٹ ان ازگر لائبریریاں. ہمیں ضرورت ہو گی۔ asyncio اور بے ترتیب، جو پہلے سے نصب ہیں۔
- بلاک کا پتہ لگانے اور دوبارہ کوشش کرنے کا طریقہ کار. سکریپر جیسے سگنلز کے لیے یو آر ایل کو ٹریک کرکے گوگل کے اینٹی بوٹ اقدامات کے ذریعے بلاک ہونے کا پتہ لگاتا ہے۔ /sorry/ “غیر معمولی ٹریفک” پیغامات کے لیے صفحہ کے مواد کو ری ڈائریکٹ اور اسکین کرنا۔ اگر بلاک نے کام کیا ہے یا صفحہ خالی نتیجہ لوٹا ہے، تو نظام نہیں رکتا۔ یہ بے ترتیب وقفے کو برداشت کرتا ہے، ایک نیا براؤزر سیشن شروع کرتا ہے، اور ایک تازہ پراکسی سرور کے ذریعے اگلی درخواست کو چھوڑ دیتا ہے۔ یہ لوپ کئی بار دہرایا جاتا ہے۔ ایک ہی ڈٹیکشن ٹرگرز کو دو بار ٹرپ کیے بغیر گزرنا کافی ہے۔
دوبارہ کوشش کرنے کا طریقہ کار اس طرح نظر آتا ہے:
for attempt in range(1, MAX_ATTEMPTS + 1):
wait_time = RETRY_DELAY_SECONDS + random.randint(1, 7)
await asyncio.sleep(wait_time)
- DOM نکالنے کی منطق۔ رزلٹ کنٹینرز کو ٹارگٹ کرکے، ٹائٹل یا URL کو پارس کرکے، اور اشتہارات اور ڈپلیکیٹس کو فلٹر کرکے گوگل کے دستاویز آبجیکٹ ماڈل سے آرگینک نتائج کا تجزیہ اور نکالتا ہے۔
گوگل سرچ کے نتائج کو سکریپ کرنا
یہاں وہ اہم وجوہات ہیں جن کی وجہ سے آپ کو گوگل سرچ ڈیٹا اسکریپ کرنے کی ضرورت پڑسکتی ہے۔
- سائٹ کی پوزیشنوں کی SEO کی نگرانی اور حریفوں کے آؤٹ پٹ کا حقیقی وقت کا تجزیہ۔
- مسابقتی ذہانت یہ معلوم کرنے کے لیے کہ مقام پر کون غلبہ رکھتا ہے اور حریف کون سی اشتہاری حکمت عملی استعمال کرتے ہیں۔
- رجحانات، مقبول درخواستوں اور صارفین کی طلب میں تبدیلیوں کی مارکیٹ ریسرچ۔
- کاروباری ڈائریکٹریز اور مقامی تقسیم کے ذریعے لیڈ جنریشن۔
- برانڈ کا تحفظ اور نگرانی جو کہ گوگل برانڈ کے سوالات اور کمپنی کے تذکروں کے ذریعے دکھاتا ہے۔
ہم نے جو کوڈ تیار کیا ہے وہ Playwright براؤزر اور DataImpulse پراکسی کے ذریعے گوگل کی تلاش کو خودکار کرتا ہے۔ اسکرپٹ گوگل کو کھولتا ہے، دی گئی تلاش کے سوال میں داخل ہوتا ہے، عام صارف کے رویے کی نقل کرتا ہے، چیک کرتا ہے کہ آیا کیپچا یا لاک ظاہر ہوا ہے، اور پھر نامیاتی تلاش کے نتائج جمع کرتا ہے۔
ہر نتیجے کے لیے، اسکرپٹ ویب سائٹ کا لنک، ایک عنوان، اور ایک مختصر تفصیل نکالتا ہے۔ تیزی سے کام کرنے کے لیے، کوڈ تصاویر اور میڈیا کو اپ لوڈ کرنے سے روکتا ہے۔ اگر گوگل درخواست کو روکتا ہے یا نتائج نہیں ملتے ہیں، تو اسکرپٹ وقفے کے ساتھ کئی کوششیں کرتا ہے۔ یہ ایک نام نہاد پراکسی گردش ہے۔
نتیجتاً، پروگرام مخصوص کلیدی لفظ کے لیے پہلے 10 نامیاتی نتائج کو براہ راست کنسول میں آؤٹ پٹ کرتا ہے۔ اسے مختصراً بتانے کے لیے، تین اہم مراحل ہیں۔
مرحلہ 1۔ ایک کنٹرول شدہ براؤزنگ ماحول بنائیں۔
سب سے پہلے، ہمیں براؤزر سیشن کو شروع اور ترتیب دینا ہوگا۔ ایک Playwright کے زیر کنٹرول Chromium مثال لانچ کریں، پراکسیز کے ذریعے ٹریفک کو روٹ کرنا شروع کریں، اور جیو اور فنگر پرنٹ کی ترتیبات لاگو کریں۔
مرحلہ 2۔ انسان نما صارف کے رویے کی تقلید کریں اور بلاکس کو ہینڈل کریں۔
حقیقی صارف کے تعامل کی نقل کرنے کے لیے، ماؤس کی حرکت اور کوکی ہینڈلنگ شامل کریں۔ ایسا لگتا ہے:
await page.goto(google_home_url, wait_until="domcontentloaded", timeout=60000)
await page.wait_for_timeout(random.randint(1200, 2500))
await accept_google_cookies(page)
await check_google_block(page)
search_box = page.locator('textarea[name="q"], input[name="q"]').first
await search_box.click()
await page.mouse.move(
random.randint(250, 900),
random.randint(180, 650),
steps=8
)
for char in keyword:
await search_box.type(char, delay=random.randint(35, 110))
await search_box.press("Enter")
کیپچا یا بلاکس کی جانچ کریں اور تازہ سیشنز کے ساتھ دوبارہ کوشش کی منطق کا اطلاق کریں۔
مرحلہ 3۔ حتمی نتائج نکالیں اور تصدیق کریں۔
اس مرحلے کے دوران، ہم DOM کو پارس کرتے ہیں اور ساختی SERP ڈیٹا نکالتے ہیں۔ اس ٹیوٹوریل کے لیے، ہم نے ‘یوکرین لوکیشنز’ کو بطور کلیدی لفظ استعمال کیا۔
یہاں کوڈ کا آخری ٹکڑا ہے:
*پراکسی کنفیگریشن کو اپنی منفرد پراکسی اسناد سے بدلنا نہ بھولیں۔
#!/usr/bin/env python3
import asyncio
import random
from playwright.async_api import async_playwright
# ====== EDIT THESE VALUES ======
PROXY_HOSTNAME = "gw.dataimpulse.com"
PROXY_PORT = "823"
PROXY_LOGIN = "LOGIN"
PROXY_PASSWORD = "PASS"
keyword = "Ukraine locations"
# ===============================
RESULTS_LIMIT = 10
GOOGLE_COUNTRY = "US"
GOOGLE_LANGUAGE = "en"
BLOCK_RESOURCE_TYPES = {"image", "media"}
MAX_ATTEMPTS = 5
RETRY_DELAY_SECONDS = 8
HEADLESS = True
async def block_slow_resources(route):
if route.request.resource_type in BLOCK_RESOURCE_TYPES:
await route.abort()
else:
await route.continue_()
async def accept_google_cookies(page):
buttons = [
'button:has-text("Accept all")',
'button:has-text("I agree")',
'button:has-text("Accept")',
'button:has-text("Reject all")',
"#L2AGLb",
]
for selector in buttons:
try:
button = page.locator(selector).first
if await button.is_visible(timeout=1500):
await button.click()
await page.wait_for_timeout(700)
return
except Exception:
pass
async def check_google_block(page):
current_url = page.url.lower()
if "/sorry/" in current_url or "captcha" in current_url:
raise RuntimeError("Google returned CAPTCHA / unusual traffic page.")
body_text = (await page.locator("body").inner_text(timeout=5000)).lower()
block_texts = [
"our systems have detected unusual traffic",
"unusual traffic from your computer network",
"detected suspicious traffic",
"captcha",
]
if any(text in body_text for text in block_texts):
raise RuntimeError("Google returned CAPTCHA / unusual traffic page.")
async def human_like_google_search(page):
google_home_url = (
"https://www.google.com/"
f"?hl={GOOGLE_LANGUAGE}"
f"&gl={GOOGLE_COUNTRY}"
"&pws=0"
)
await page.goto(google_home_url, wait_until="domcontentloaded", timeout=60000)
await page.wait_for_timeout(random.randint(1200, 2500))
await accept_google_cookies(page)
await check_google_block(page)
search_box = page.locator('textarea[name="q"], input[name="q"]').first
await search_box.wait_for(state="visible", timeout=30000)
await search_box.click()
await page.mouse.move(random.randint(250, 900), random.randint(180, 650), steps=8)
await page.wait_for_timeout(random.randint(400, 900))
for char in keyword:
await search_box.type(char, delay=random.randint(35, 110))
await page.wait_for_timeout(random.randint(500, 1100))
await search_box.press("Enter")
await page.wait_for_load_state("domcontentloaded", timeout=60000)
async def extract_results(page):
return await page.evaluate(
"""
() => {
const cleanText = (value) => (value || '').replace(/\\s+/g, ' ').trim();
const cleanUrl = (href) => {
if (!href) return '';
try {
const parsed = new URL(href, window.location.href);
if (parsed.hostname.includes('google.') && parsed.pathname === '/url') {
return parsed.searchParams.get('q') || parsed.searchParams.get('url') || '';
}
return parsed.href;
} catch {
return href;
}
};
const isNormalWebsite = (href) => {
if (!href || !/^https?:\\/\\//i.test(href)) return false;
try {
const host = new URL(href).hostname.replace(/^www\\./, '');
return !host.startsWith('google.') &&
!host.endsWith('.google.com') &&
host !== 'webcache.googleusercontent.com';
} catch {
return false;
}
};
const root = document.querySelector('#rso') || document.querySelector('#search') || document.body;
const blocks = [...root.querySelectorAll('div.tF2Cxc, div.MjjYud, div.g')];
const results = [];
const seenUrls = new Set();
for (const block of blocks) {
const titleElement = block.querySelector('h3');
if (!titleElement) continue;
const linkElement = titleElement.closest('a') || block.querySelector('a[href]');
const websiteUrl = cleanUrl(linkElement && linkElement.href);
if (!isNormalWebsite(websiteUrl) || seenUrls.has(websiteUrl)) continue;
const blockText = cleanText(block.innerText).toLowerCase();
if (blockText.startsWith('sponsored') || blockText.startsWith('ad ')) continue;
const descriptionElement =
block.querySelector('.VwiC3b, .IsZvec, .GI74Re, [data-sncf], .kb0PBd') ||
[...block.querySelectorAll('span, div')]
.find((node) => cleanText(node.innerText).length > 80);
results.push({
website_url: websiteUrl,
title: cleanText(titleElement.innerText),
description: cleanText(descriptionElement && descriptionElement.innerText),
});
seenUrls.add(websiteUrl);
}
return results;
}
"""
)
async def scrape_google_serp():
proxy_server = f"http://{PROXY_HOSTNAME}:{PROXY_PORT}"
async with async_playwright() as playwright:
browser = await playwright.chromium.launch(
headless=HEADLESS,
proxy={
"server": proxy_server,
"username": PROXY_LOGIN,
"password": PROXY_PASSWORD,
},
args=[
"--disable-blink-features=AutomationControlled",
"--disable-dev-shm-usage",
"--no-first-run",
],
)
context = await browser.new_context(
viewport={
"width": random.choice([1280, 1366, 1440]),
"height": random.choice([720, 768, 900]),
},
locale=f"{GOOGLE_LANGUAGE}-{GOOGLE_COUNTRY}",
timezone_id="America/New_York",
color_scheme="light",
user_agent=(
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/126.0.0.0 Safari/537.36"
),
)
await context.add_init_script(
"""
Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
"""
)
await context.route("**/*", block_slow_resources)
page = await context.new_page()
try:
await human_like_google_search(page)
await check_google_block(page)
await page.wait_for_selector("#search, #rso", timeout=30000)
results = await extract_results(page)
return results[:RESULTS_LIMIT]
finally:
await browser.close()
async def main():
print(f"Query: {keyword}")
print("Searching Google through DataImpulse proxy...\n")
results = []
for attempt in range(1, MAX_ATTEMPTS + 1):
print(f"Attempt {attempt}/{MAX_ATTEMPTS}")
try:
results = await scrape_google_serp()
except Exception as error:
print(f"Attempt failed: {error}")
if attempt < MAX_ATTEMPTS:
wait_time = RETRY_DELAY_SECONDS + random.randint(1, 7)
print(f"Retrying with a fresh browser context in {wait_time}s...\n")
await asyncio.sleep(wait_time)
continue
print("\nFinished without crashing, but Google still returned a block page.")
print("Try again later, lower request volume, or use DataImpulse country targeting like login__cr.us.")
return
if results:
break
if attempt < MAX_ATTEMPTS:
wait_time = RETRY_DELAY_SECONDS + random.randint(1, 7)
print(f"No results found. Retrying in {wait_time}s...\n")
await asyncio.sleep(wait_time)
else:
print("No results found after all attempts.")
if not results:
print("Finished successfully, but no organic results were found.")
return
print("Success. Organic results extracted.\n")
for index, result in enumerate(results, start=1):
print(f"#{index}")
print(f"Query: {keyword}")
print(f"Website URL: {result['website_url']}")
print(f"Title: {result['title']}")
print(f"Description: {result['description']}")
print("-" * 80)
if __name__ == "__main__":
asyncio.run(main())
ہمارے معاملے میں، پہلی دو کوششیں ناکام ہوئیں، لیکن تیسری نے آخر کار کام کیا:
ازگر کے ساتھ گوگل میپس کو سکریپ کرنا
محل وقوع پر مبنی ڈیٹا ہمیشہ سے بہت سے کاروباری منصوبوں کے لیے ایک قیمتی وسیلہ رہا ہے، بشمول تجزیہ اور نگرانی کے پہلو۔ نیچے کا کوڈ Playwright اور DataImpulse پراکسی کے ذریعے Google Maps سے ڈیٹا اکٹھا کرنے کو خودکار کرتا ہے۔ یہ Google Maps کو دی گئی استفسار کے ساتھ کھولتا ہے، جیسے “نیویارک میں دندان ساز”، ایک باقاعدہ براؤزر کی نقل کرتا ہے، کوکیز کو قبول کرتا ہے، چیک کرتا ہے کہ گوگل نے کیپچا نہیں دکھایا، اور پھر نتائج کی فہرست میں اسکرول کرتا ہے۔
اس کے بعد، اسکرپٹ دریافت شدہ مقامات کے لنکس جمع کرتا ہے، ہر کاروباری پروفائل کو ایک ایک کرکے کھولتا ہے، اور نام، پتہ، فون نمبر، ویب سائٹ، درجہ بندی، اور Google Maps URLs جیسی اہم معلومات نکالتا ہے۔
اسکرپٹ تصاویر اور میڈیا فائلوں کی لوڈنگ کو بھی روکتا ہے۔ یہ براؤزر کو کم خودکار نظر آنے کے لیے اسٹیلتھ سیٹنگز، صارف ایجنٹ، بے ترتیب اسکرین کا سائز، اور قدرتی تاخیر کا بھی استعمال کرتا ہے۔
اگر Google Maps درخواست کو روکتا ہے یا کوئی ڈیٹا نہیں ملتا ہے، تو اسکرپٹ نئے براؤزر سیاق و سباق کے ساتھ کئی بار دوبارہ کوشش کرتا ہے۔ نتیجے کے طور پر، یہ دیئے گئے مطلوبہ الفاظ کا استعمال کرتے ہوئے 10 کے مماثل مقامات کو کنسول تک پہنچاتا ہے۔
سکریپنگ پائپ لائن اس طرح نظر آتی ہے:
- 1۔ براؤزر سیشن کو شروع اور ترتیب دیں۔
- 2۔ گوگل میپس کھولیں اور تلاش کے نتائج لوڈ کریں۔
- 3۔ کاروباری ڈیٹا کو نکالیں اور اس کی تصدیق کریں۔
- 4۔ بلاکس کا پتہ لگائیں اور بازیافت کریں۔
یہاں کوڈ کا آخری ٹکڑا ہے:
*پراکسی کنفیگریشن کو اپنی منفرد پراکسی اسناد سے بدلنا نہ بھولیں۔
#!/usr/bin/env python3
"""
Simple Google Maps address scraper through a DataImpulse proxy.
Before first run:
python3 -m pip install playwright playwright-stealth
python3 -m playwright install chromium
Then edit the values below and run:
python3 google_maps_address_scraper.py
"""
import asyncio
import random
from urllib.parse import quote_plus
from playwright.async_api import TimeoutError as PlaywrightTimeoutError
from playwright.async_api import async_playwright
# ====== EDIT THESE VALUES ======
PROXY_HOSTNAME = "gw.dataimpulse.com"
PROXY_PORT = "823"
PROXY_LOGIN = "LOGIN"
PROXY_PASSWORD = "PASS"
keyword = "dentist in New York"
# ===============================
RESULTS_LIMIT = 10
GOOGLE_COUNTRY = "US"
GOOGLE_LANGUAGE = "en"
HEADLESS = True
MAX_ATTEMPTS = 3
RETRY_DELAY_SECONDS = 8
BLOCK_RESOURCE_TYPES = {"image", "media"}
async def block_slow_resources(route):
if route.request.resource_type in BLOCK_RESOURCE_TYPES:
await route.abort()
else:
await route.continue_()
async def apply_stealth_if_available(page):
try:
from playwright_stealth import Stealth
except ImportError:
try:
from playwright_stealth import stealth_async
except ImportError:
print("playwright-stealth is not installed for this Python.")
print("Optional install: python3 -m pip install playwright-stealth\n")
return
await stealth_async(page)
print("playwright-stealth applied.\n")
return
await Stealth().apply_stealth_async(page)
print("playwright-stealth applied.\n")
async def accept_google_cookies(page):
buttons = [
'button:has-text("Accept all")',
'button:has-text("I agree")',
'button:has-text("Accept")',
'button:has-text("Reject all")',
"#L2AGLb",
]
for selector in buttons:
try:
button = page.locator(selector).first
if await button.is_visible(timeout=1500):
await button.click()
await page.wait_for_timeout(700)
return
except Exception:
pass
async def check_google_block(page):
current_url = page.url.lower()
if "/sorry/" in current_url or "captcha" in current_url:
raise RuntimeError("Google returned CAPTCHA / unusual traffic page.")
body_text = (await page.locator("body").inner_text(timeout=5000)).lower()
block_texts = [
"our systems have detected unusual traffic",
"unusual traffic from your computer network",
"detected suspicious traffic",
"captcha",
]
if any(text in body_text for text in block_texts):
raise RuntimeError("Google returned CAPTCHA / unusual traffic page.")
async def open_google_maps(page):
maps_url = (
"https://www.google.com/maps/search/"
f"{quote_plus(keyword)}"
f"?hl={GOOGLE_LANGUAGE}"
f"&gl={GOOGLE_COUNTRY}"
)
await page.goto(maps_url, wait_until="domcontentloaded", timeout=60000)
await page.wait_for_timeout(random.randint(2500, 4500))
await accept_google_cookies(page)
await check_google_block(page)
async def scroll_results_list(page):
feed = page.locator('[role="feed"]').first
try:
await feed.wait_for(state="visible", timeout=15000)
except PlaywrightTimeoutError:
return
previous_count = 0
stable_rounds = 0
for _ in range(12):
cards = page.locator('a[href*="/maps/place/"]')
current_count = await cards.count()
if current_count >= RESULTS_LIMIT:
return
if current_count == previous_count:
stable_rounds += 1
else:
stable_rounds = 0
if stable_rounds >= 3:
return
previous_count = current_count
await feed.evaluate("(element) => element.scrollBy(0, element.scrollHeight)")
await page.wait_for_timeout(random.randint(1200, 2200))
async def get_place_links(page):
return await page.evaluate(
"""
() => {
const links = [...document.querySelectorAll('a[href*="/maps/place/"]')]
.map((link) => link.href)
.filter(Boolean);
return [...new Set(links)];
}
"""
)
async def get_text(page, selector, timeout=2500):
try:
element = page.locator(selector).first
if await element.is_visible(timeout=timeout):
return " ".join((await element.inner_text()).split())
except Exception:
return ""
return ""
async def extract_place_data(page):
name = await get_text(page, "h1.DUwDvf, h1")
address = await get_text(page, '[data-item-id="address"]')
website = ""
phone = ""
if not address:
address = await page.evaluate(
"""
() => {
const item = document.querySelector('[aria-label^="Address:"]');
return item ? item.getAttribute('aria-label').replace(/^Address:\\s*/i, '').trim() : '';
}
"""
)
website = await page.evaluate(
"""
() => {
const selectors = [
'a[data-item-id="authority"]',
'a[aria-label^="Website:"]',
'a[href^="http"]:not([href*="google."])'
];
for (const selector of selectors) {
const element = document.querySelector(selector);
if (!element) continue;
const href = element.href || '';
if (href && !href.includes('/maps/')) return href;
}
return '';
}
"""
)
phone = await page.evaluate(
"""
() => {
const byItemId = document.querySelector('[data-item-id^="phone:"]');
if (byItemId) return (byItemId.innerText || '').replace(/\\s+/g, ' ').trim();
const byAria = document.querySelector('[aria-label^="Phone:"]');
if (byAria) {
return byAria.getAttribute('aria-label').replace(/^Phone:\\s*/i, '').trim();
}
return '';
}
"""
)
rating = await page.evaluate(
"""
() => {
const rating = document.querySelector('[role="img"][aria-label*="stars"]');
return rating ? rating.getAttribute('aria-label') : '';
}
"""
)
return {
"query": keyword,
"name": name,
"address": address,
"phone": phone,
"website": website,
"rating": rating,
"google_maps_url": page.url,
}
async def scrape_google_maps_once():
proxy_server = f"http://{PROXY_HOSTNAME}:{PROXY_PORT}"
async with async_playwright() as playwright:
browser = await playwright.chromium.launch(
headless=HEADLESS,
proxy={
"server": proxy_server,
"username": PROXY_LOGIN,
"password": PROXY_PASSWORD,
},
args=[
"--disable-blink-features=AutomationControlled",
"--disable-dev-shm-usage",
"--no-first-run",
],
)
context = await browser.new_context(
viewport={
"width": random.choice([1280, 1366, 1440]),
"height": random.choice([720, 768, 900]),
},
locale=f"{GOOGLE_LANGUAGE}-{GOOGLE_COUNTRY}",
timezone_id="America/New_York",
color_scheme="light",
user_agent=(
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/126.0.0.0 Safari/537.36"
),
)
await context.add_init_script(
"""
Object.defineProperty(navigator, 'webdriver', { get: () => undefined });
Object.defineProperty(navigator, 'languages', { get: () => ['en-US', 'en'] });
"""
)
await context.route("**/*", block_slow_resources)
page = await context.new_page()
try:
await apply_stealth_if_available(page)
await open_google_maps(page)
await scroll_results_list(page)
place_links = await get_place_links(page)
place_links = place_links[:RESULTS_LIMIT]
results = []
seen = set()
if not place_links:
print("No result list detected. Trying to extract the currently opened place.")
data = await extract_place_data(page)
if data["name"] or data["address"]:
return [data]
for index, place_url in enumerate(place_links, start=1):
print(f"Opening place {index}/{len(place_links)}")
await page.goto(place_url, wait_until="domcontentloaded", timeout=60000)
await page.wait_for_timeout(random.randint(2500, 4500))
await check_google_block(page)
data = await extract_place_data(page)
unique_key = data["name"] or data["google_maps_url"]
if unique_key in seen:
continue
if data["name"] or data["address"]:
results.append(data)
seen.add(unique_key)
return results
finally:
await browser.close()
async def main():
print(f"Google Maps query: {keyword}")
print("Searching Google Maps through DataImpulse proxy...\n")
results = []
for attempt in range(1, MAX_ATTEMPTS + 1):
print(f"Attempt {attempt}/{MAX_ATTEMPTS}")
try:
results = await scrape_google_maps_once()
except Exception as error:
print(f"Attempt failed: {error}")
if attempt < MAX_ATTEMPTS:
wait_time = RETRY_DELAY_SECONDS + random.randint(1, 7)
print(f"Retrying with a fresh browser context in {wait_time}s...\n")
await asyncio.sleep(wait_time)
continue
print("\nFinished without crashing, but Google Maps did not return usable data.")
print("Try DataImpulse country targeting like login__cr.us, lower volume, or run again later.")
return
if results:
break
if attempt < MAX_ATTEMPTS:
wait_time = RETRY_DELAY_SECONDS + random.randint(1, 7)
print(f"No places found. Retrying in {wait_time}s...\n")
await asyncio.sleep(wait_time)
else:
print("No places found after all attempts.")
if not results:
print("Finished successfully, but no Google Maps places were found.")
return
print(f"Success. Extracted {len(results)} Google Maps places.\n")
for index, item in enumerate(results, start=1):
print(f"#{index}")
print(f"Query: {item['query']}")
print(f"Name: {item['name']}")
print(f"Address: {item['address']}")
print(f"Phone: {item['phone']}")
print(f"Website: {item['website']}")
print(f"Rating: {item['rating']}")
print(f"Google Maps URL: {item['google_maps_url']}")
print("-" * 80)
if __name__ == "__main__":
asyncio.run(main())
یہ نتیجہ ہے جو ہمیں اس کوڈ کو استعمال کرنے کے بعد ملا:
استعمال کرنے کے لیے چیک لسٹ
بس اس ڈویلپر کے موافق بصری چیک لسٹ پر ایک نظر ڈالیں۔ ہماری ٹیم آپ کو سکریپنگ کے عمل کے ساتھ آگے بڑھنے سے پہلے ہر باکس کو چیک کرنے کی ترغیب دیتی ہے۔
اکثر پوچھے گئے سوالات
کیا Google اسکریپنگ کی اجازت دیتا ہے؟
Google خودکار اسکریپنگ کی اجازت نہیں دیتا، لیکن ضوابط کے مطابق ڈیٹا تک رسائی کے لیے سرکاری APIs فراہم کرتا ہے۔ عمومی طور پر، عوامی طور پر دستیاب ڈیٹا کی اسکریپنگ قانونی ہے۔
Google SERP اور Google Maps سے کون سا ڈیٹا نکالا جا سکتا ہے؟
صارفین Python کے ساتھ Playwright اور DataImpulse کی قابلِ اعتماد پراکسیز استعمال کرتے ہوئے Google SERP سے عنوانات، URLs، اشتہارات اور SERP خصوصیات نکال سکتے ہیں۔ Google Maps سے عام طور پر کاروبار کے نام، پتے، درجہ بندیاں، صارفین کے جائزے، فون نمبرز اور جغرافیائی محلِ وقوع کا ڈیٹا حاصل کیا جاتا ہے۔
Google Maps سے ڈیٹا کیسے نکالیں؟
Google Maps سے ڈیٹا جمع کرنے کے لیے، Playwright کے ساتھ Python، VS Code جیسا کوڈ ایڈیٹر، اور پراکسیز انسٹال کرنا یقینی بنائیں۔ اسکریپنگ کے مراحل یہ ہیں: 1. سیشن شروع کریں۔ 2. Google Maps کے نتائج لوڈ کریں۔ 3. کاروباری ڈیٹا نکالیں۔ 4. بلاکس کو سنبھالیں۔ آپ تعلیمی مقاصد کے لیے ہماری DataImpulse گائیڈ کا کوڈ بھی استعمال کر سکتے ہیں۔
Google کی اسکریپنگ کے لیے کون سی پراکسیز بہترین ہیں؟
DataImpulse کی رہائشی اور موبائل پراکسیز عام طور پر اسکریپنگ کے لیے استعمال ہوتی ہیں کیونکہ وہ حقیقی ISPs یا موبائل IPs استعمال کرتی ہیں۔ ان کا سراغ لگانا اور انہیں بلاک کرنا زیادہ مشکل ہوتا ہے۔ ڈیٹا سینٹر پراکسیز تیز اور کم قیمت ہوتی ہیں، لیکن جب آپ کو پوشیدگی درکار ہو تو یہ بہترین انتخاب نہیں ہیں۔
نتیجہ
گوگل سرچ اور گوگل میپس کو سکریپ کرنے سے کاروبار اور ڈویلپرز کے لیے وسیع مواقع کھلتے ہیں۔ اگر آپ کو تلاش کے نتائج کی نگرانی کرنے، حریفوں کا تجزیہ کرنے یا مقامی ڈیٹا اکٹھا کرنے کی ضرورت ہے، تو آپ کو یہ جاننا ہوگا کہ بغیر کسی بلاک چیلنجز کے ڈیٹا کو کیسے اسکریپ کرنا ہے۔ مستحکم اور موثر ڈیٹا اکٹھا کرنے کے لیے ضروری ہے کہ ٹولز کا صحیح سیٹ استعمال کیا جائے، جس میں شامل ہیں۔ اعلیٰ معیار کی پراکسی، IP گردش اور حقیقی صارفین کے رویے کی تقلید کے لیے میکانزم۔ کاموں کے پیمانے پر منحصر ہے، زیادہ سے زیادہ انتخاب رہائشی یا ہو سکتا ہے موبائل پراکسیز، جو گمنامی کی اعلی سطح فراہم کرتی ہیں۔ اور بلاک ہونے کا کم خطرہ۔
منتخب کردہ نقطہ نظر سے قطع نظر، یہ Google سروسز کے استعمال کی شرائط پر غور کرنے اور ڈیٹا اکٹھا کرنے کے ذمہ دار طریقوں پر عمل کرنے کے قابل ہے۔
*یہ ٹیوٹوریل خالصتاً تعلیمی مقاصد کے لیے ہے اور تکنیکی صلاحیتوں کے مظاہرے کے طور پر کام کرتا ہے۔ یہ جاننا ضروری ہے کہ ایمیزون سے ڈیٹا اسکریپ کرنا استعمال کی شرائط اور قانونی حیثیت سے متعلق خدشات کو جنم دیتا ہے۔ غیر مجاز سکریپنگ سنگین نتائج کا باعث بن سکتی ہے، بشمول قانونی کارروائیاں اور اکاؤنٹ کی معطلی۔ ہمیشہ احتیاط کے ساتھ آگے بڑھیں اور اخلاقی ہدایات پر عمل کریں۔
آپ Python کے ساتھ گوگل سرچ کے نتائج کو کیسے اسکریپ کرتے ہیں؟
Python کے ساتھ Google تلاش کے نتائج اسکریپ کرنے کے لیے، google.com/search پر ایک HTTP درخواست بھیجیں اور hl اور gl پیرامیٹرز کے ساتھ، اسے رہائشی پراکسی کے ذریعے روٹ کریں، پھر آرگینک لنکس کو HTML سے پارس کریں جو واپس آتا ہے۔ ذیل میں ہلکا پھلکا راستہ ایک مکمل براؤزر کے بجائے درخواستوں کی لائبریری کا استعمال کرتا ہے، جو تیز اور سستا ہوتا ہے جب آپ کو صرف عنوانات، URLs اور اسنیپٹس کی ضرورت ہوتی ہے۔
Google کے ہر اسکریپر کو ایک قابل دہرائے جانے والے پیٹرن کے ارد گرد تشکیل دیں جسے ہم Fetch-Verify-Recover (FVR) لوپ کہتے ہیں: SERP کو ایک تازہ رہائشی IP کے ذریعے حاصل کریں، تصدیق کریں کہ جواب میں حقیقی نتائج ہیں نہ کہ بلاک، پھر بیک آف کے ساتھ بیک آف کے ساتھ ایک نئے IP پر گھما کر بازیافت کریں۔ اس حصے کا باقی حصہ اس لوپ کو ایک وقت میں ایک پرت بناتا ہے۔
ایک ملک کے لیے ہدف کی درخواست کے ساتھ شروع کریں۔ ملک کو نشانہ بنانا شامل ہے۔ رہائشی پراکسی DataImpulse سے؛ آپ پراکسی یوزر نیم میں __cr.
import requests
# DataImpulse residential gateway. Country targeting is included; select
# an exit country by appending __cr. to your username. Get real
# credentials at https://app.dataimpulse.com/sign-up
USER = "YOUR_LOGIN__cr.us" # route exits through United States IPs
PASS = "YOUR_PASSWORD"
PROXY = f"http://{USER}:{PASS}@gw.dataimpulse.com:823"
proxies = {"http": PROXY, "https": PROXY}
params = {
"q": "best running shoes",
"hl": "en", # interface language
"gl": "us", # country of the search
"num": "20", # results per page (Google may cap this)
}
headers = {
"User-Agent": ("Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/125.0 Safari/537.36"),
"Accept-Language": "en-US,en;q=0.9",
}
r = requests.get("https://www.google.com/search",
params=params, headers=headers,
proxies=proxies, timeout=30)
print(r.status_code, len(r.text))
gl ویلیو اور __cr ملک کو مطابقت پذیر رکھیں تاکہ زبان، کرنسی، اور مقامی رینکنگ Google کے ریٹرنز IP مقام سے مماثل ہوں۔ ریاستہائے متحدہ کا ایک IP gl=de کا مطالبہ کرنے سے غیر مطابقت پذیر، جھنڈے میں آسان نتائج برآمد ہوتے ہیں۔
آپ گوگل کے HTML سے نامیاتی نتائج کی تجزیہ کیسے کرتے ہیں؟
HTML کو BeautifulSoup میں لوڈ کرکے، ہر نتیجے کے کنٹینر کو منتخب کرکے، پھر h3 ٹائٹل اور اس کے اندر پہلا آؤٹ باؤنڈ لنک پڑھ کر نامیاتی نتائج کو پارس کریں۔ گوگل ایک بڑی ایچ ٹی ایم ایل دستاویز واپس کرتا ہے، اس لیے نکالنا غیر ملکی چیزوں کے بجائے نظم و ضبط کے ساتھ DOM کا انتخاب ہے۔
from bs4 import BeautifulSoup
def parse_organic(html):
soup = BeautifulSoup(html, "html.parser")
results = []
# WARNING: Google rotates these class names and DOM structure often.
# Treat every selector here as volatile and re-check it against a
# fresh saved response whenever extraction suddenly returns 0 rows.
for block in soup.select("div.g, div.MjjYud"):
link = block.select_one("a[href^='http']")
title = block.select_one("h3")
if not link or not title:
continue
results.append({
"title": title.get_text(strip=True),
"url": link["href"],
})
return results
data = parse_organic(r.text)
for i, row in enumerate(data, 1):
print(i, row["title"], row["url"])
ہر سلیکٹر کو غیر مستحکم سمجھیں۔ گوگل اپنے CSS کلاس کے ناموں اور کنٹینر کے ڈھانچے کو اکثر گھماتا ہے، بعض اوقات ایک ہفتے کے اندر، اس لیے ایک سکریپر جس نے کل 100 قطاریں واپس کی تھیں آج خاموشی سے صفر واپس کر سکتا ہے۔ ایک ہیلتھ چیک بنائیں جو HTTP 200 کے جواب کے خلاف جب پارس خالی فہرست واپس کرتا ہے تو انتباہ کرتا ہے، اور ایک معروف SERP کی ایک محفوظ شدہ کاپی اپنے پاس رکھیں تاکہ آپ سلیکٹرز کو تیزی سے دوبارہ حاصل کر سکیں۔ گہری تجزیہ کرنے کی حکمت عملی کے لیے ہماری گائیڈ دیکھیں متحرک ویب صفحات کو سکریپ کرنا.
آپ گوگل سرچ کے نتائج کے ذریعے صفحہ بندی کیسے کرتے ہیں؟
شروع کے پیرامیٹر کے ساتھ گوگل کے نتائج کے ذریعے صفحہ بندی کریں، جو نتائج کو دس کے مراحل میں آف سیٹ کرتا ہے۔ start=0 پہلا صفحہ ہے، start=10 دوسرا، اور اسی طرح؛ اس وقت تک لوپ کریں جب تک کہ کوئی صفحہ قابل تجزیہ نتائج نہیں دیتا۔
def fetch_page(query, start, proxies, headers):
params = {"q": query, "hl": "en", "gl": "us", "start": start}
return requests.get("https://www.google.com/search",
params=params, headers=headers,
proxies=proxies, timeout=30)
all_results = []
for page in range(0, 5): # first five pages
start = page * 10 # 0, 10, 20, 30, 40
resp = fetch_page("best running shoes", start, proxies, headers)
rows = parse_organic(resp.text)
if not rows:
break # no more results, or a block
all_results.extend(rows)
print("collected", len(all_results), "results")
ایک IP سے بیس صفحات کو سخت لوپ میں نہ ماریں۔ ہر صفحہ ایک علیحدہ درخواست ہے جو آپ کے بلاک کے خطرے کو بڑھاتا ہے، اس لیے کالز کو تیز کریں، ان کے درمیان گڑبڑ شامل کریں، اور پراکسی پول کو گھومنے دیں۔ عملی طور پر پہلے تین سے پانچ صفحات میں درجہ بندی کا ڈیٹا ہوتا ہے جس کی سب سے زیادہ SEO نگرانی اور مسابقتی تحقیق کی ضرورت ہوتی ہے۔
آپ Google CAPTCHAs، رضامندی والے صفحات، اور 429 کی غلطیوں کو کیسے ہینڈل کرتے ہیں؟
بلاک کا پتہ لگا کر کیپچا، رضامندی والے صفحات، اور 429 جوابات کو ہینڈل کریں، پھر دوبارہ کوشش کرنے سے پہلے ایک تازہ رہائشی IP پر ایکسپونیشنل بیک آف کے ساتھ گھمائیں۔ Google 429 اسٹیٹس، /sorry/ پاتھ پر ری ڈائریکٹ، “غیر معمولی ٹریفک” پیغام، یا EU کی رضامندی انٹرسٹیشل کے ذریعے پریشانی کا اشارہ کرتا ہے۔
import time, random
def is_blocked(resp):
# Google signals a block with a 429, a /sorry/ redirect, an
# "unusual traffic" body, or the EU consent interstitial.
if resp.status_code == 429:
return True
if "/sorry/" in resp.url:
return True
text = resp.text.lower()
return "unusual traffic" in text or "before you continue" in text
def fetch_with_recovery(query, start, headers, max_tries=4):
for attempt in range(max_tries):
# A fresh session lets DataImpulse hand out a new rotating IP.
session = requests.Session()
session.proxies = {"http": PROXY, "https": PROXY}
# Pre-accept the EU consent cookie so /search returns results
# instead of the consent wall.
session.cookies.set("CONSENT", "YES+", domain=".google.com")
resp = session.get("https://www.google.com/search",
params={"q": query, "hl": "en",
"gl": "us", "start": start},
headers=headers, timeout=30)
if not is_blocked(resp):
return resp
# Exponential backoff with jitter before the next rotation.
time.sleep((2 ** attempt) + random.random())
raise RuntimeError("blocked after retries; slow down or widen IP pool")
CONSENT کوکی کو پہلے سے ترتیب دینے سے یورپی رضامندی کی دیوار صاف ہو جاتی ہے جو بصورت دیگر نتائج کی جگہ لے لیتی ہے۔ ہر کوشش پر ایک تازہ سیشن کھولنے سے DataImpulse ایک نیا گھومنے والا IP دے دیتا ہے، اور jitter کے ساتھ ایکسپونینشل بیک آف آپ کو ایک ہی شرح کی حد کو دو بار ٹرپ کرنے سے روکتا ہے۔ یہ بازیافت کی پرت وہ ہے جو ایک اسکریپر کو الگ کرتی ہے جو حجم میں زندہ رہتا ہے جو پہلے بلاک پر مر جاتا ہے۔ ایک وسیع تر پلے بک کے لیے، پڑھیں بلاک کیے بغیر سکریپ کرنا.
آپ کو خام ایچ ٹی ایم ایل کے بجائے ہیڈ لیس براؤزر کب استعمال کرنا چاہیے؟
ہیڈ لیس براؤزر تک صرف اس وقت پہنچیں جب خام HTML کافی نہ ہو، مثال کے طور پر جب کسی لے آؤٹ کا کچھ حصہ JavaScript کے ذریعے پیش کیا جاتا ہے، جب آپ کو صفحہ کے ساتھ تعامل کرنے کی ضرورت ہوتی ہے، یا جب آپ کلاسک SERP کے بجائے Google Maps کو سکریپ کر رہے ہوتے ہیں۔ ایک براؤزر سی پی یو اور میموری پر سادہ درخواست سے کہیں زیادہ بھاری ہوتا ہے، اس لیے اسے ٹارگٹڈ فال بیک کے طور پر استعمال کریں، ڈیفالٹ نہیں۔
from playwright.sync_api import sync_playwright
def fetch_rendered(query):
with sync_playwright() as p:
# The same DataImpulse credentials plug into Playwright's proxy.
browser = p.chromium.launch(proxy={
"server": "http://gw.dataimpulse.com:823",
"username": "YOUR_LOGIN__cr.us",
"password": "YOUR_PASSWORD",
})
page = browser.new_page()
page.goto(f"https://www.google.com/search?q={query}&hl=en&gl=us")
page.wait_for_selector("div#search", timeout=15000)
html = page.content()
browser.close()
return html
وہی DataImpulse اسناد براہ راست Playwright کے پراکسی آپشن میں لگ جاتی ہیں، لہذا آپ حقیقی رینڈرنگ انجن حاصل کرتے ہوئے کنٹری ٹارگٹنگ اور گردش کو برقرار رکھتے ہیں۔ ٹریڈ آف تھرو پٹ ہے: درخواستوں پر مبنی سکریپر سینکڑوں SERPs کو کھینچ سکتا ہے جب ایک براؤزر چند درجن ہینڈل کرتا ہے۔
Raw HTML بمقابلہ SERP API بمقابلہ ہیڈ لیس براؤزر: آپ کو کس کا انتخاب کرنا چاہئے؟
خام HTML، ایک SERP API، اور حجم، بجٹ، اور آپ کتنی دیکھ بھال کو جذب کر سکتے ہیں کی بنیاد پر بغیر ہیڈ لیس براؤزر کے درمیان انتخاب کریں۔ رہائشی پراکسیز کے ساتھ را ایچ ٹی ایم ایل سب سے کم قیمت پر سب سے زیادہ کنٹرول فراہم کرتا ہے، بغیر ہیڈ لیس براؤزر جاوا اسکرپٹ ہیوی پیجز پر اعتبار کے لیے تھرو پٹ ٹریڈ کرتا ہے، اور فریق ثالث SERP API فی سوال فیس اور کم کنٹرول کے بدلے مینٹیننس کو ہٹاتا ہے۔
| طریقہ | کے لیے بہترین | لاگت اور کوشش | جاوا اسکرپٹ کو ہینڈل کرتا ہے۔ |
|---|---|---|---|
| خام HTML (درخواستوں کے علاوہ رہائشی پراکسی) | اعلی والیوم ٹائٹل، URL، اور اسنیپٹ نکالنا | کم قیمت، آپ سلیکٹرز کو برقرار رکھتے ہیں۔ | نہیں |
| بغیر ہیڈ براؤزر (Playwright پلس پراکسی) | جے ایس کی طرف سے پیش کردہ لے آؤٹ، نقشے، صفحہ کا تعامل | اعلی سی پی یو اور میموری، آپ سلیکٹرز کو برقرار رکھتے ہیں۔ | جی ہاں |
| فریق ثالث SERP API | وہ ٹیمیں جو صفر سکریپنگ مینٹیننس چاہتی ہیں۔ | فی استفسار ادا کریں، کم از کم کنٹرول | فراہم کنندہ کی طرف سے سنبھالا |
زیادہ تر ٹیمیں خام HTML اور رہائشی پراکسیز کے ساتھ شروع ہوتی ہیں، پھر ان صفحات کے چھوٹے حصے کے لیے بغیر ہیڈ لیس فال بیک شامل کرتی ہیں جن کو حقیقی طور پر رینڈرنگ کی ضرورت ہوتی ہے۔
کیا Google تلاش کے نتائج کو سکریپ کرنا قانونی ہے، اور کیا DataImpulse ایک SERP API ہے؟
رینک ٹریکنگ اور تحقیق کے لیے عوامی طور پر دکھائی دینے والے تلاش کے نتائج اسکریپ کرنا بڑے پیمانے پر کیا جاتا ہے، لیکن گوگل کی سروس کی شرائط خودکار رسائی کی حوصلہ شکنی کرتی ہیں، اس لیے صرف عوامی ڈیٹا کو اسکریپ کریں، روبوٹس کی ہدایات اور شرح کی حدود کا احترام کریں، ذاتی ڈیٹا سے گریز کریں، اور سرکاری API کو ترجیح دیں جہاں کوئی موجود ہو۔ کے لیے ہماری گائیڈ اخلاقی ویب سکریپنگ ذمہ دار جمع کرنے کے بنیادی اصولوں کا احاطہ کرتا ہے۔
DataImpulse پراکسی پرت ہے، نظم شدہ SERP API نہیں۔ یہ 90M+ اخلاقی طور پر حاصل کردہ رہائشی IPs کو 195 ممالک میں گھومنے اور چسپاں سیشنز، 99.51% کامیابی کی شرح، اور 1 ڈالر فی GB سے ادائیگی کے طور پر قیمتوں کے ساتھ فراہم کرتا ہے، لیکن آپ پھر بھی اوپر دکھائے گئے بازیافت اور تجزیہ کوڈ کو لکھتے اور برقرار رکھتے ہیں۔ یہ تقسیم SERP اور رینک ٹریکنگ کے مطابق ہے، جہاں آپ بالکل اس پر مکمل کنٹرول چاہتے ہیں کہ آپ کن فیلڈز کو نکالتے ہیں اور آپ ہر کلیدی لفظ کو کتنی بار پول کرتے ہیں۔ اگر آپ آئی پیز اور پارسرز کو بالکل بھی منظم نہیں کرنا چاہتے ہیں، تو ایک میزبان SERP API متبادل ہے، اوپر والے جدول میں ٹریڈ آف کے ساتھ۔
Google تلاش کے نتائج اسکریپ کرنے کے لیے، اپنے استفسار کے ساتھ google.com/search پر ایک درخواست بھیجیں اور رہائشی پراکسی کے ذریعے روٹ کیے گئے hl اور gl پیرامیٹرز، پھر واپس کیے گئے HTML سے نامیاتی عنوانات اور لنکس کو پارس کریں۔ گوگل فعال طور پر خودکار ٹریفک کو روکتا ہے، اس لیے گھومنے والی رہائشی پراکسی، انسان نما ہیڈر، کنسنٹ کوکی ہینڈلنگ، اور ایکسپونینشل بیک آف کی ضرورت ہے۔ DataImpulse پراکسی پرت فراہم کرتا ہے، پارسر کو نہیں۔





