Loading Light/Dark Toggle
वापस ब्लॉग पर

Google SERP API पेजिनेशन: start के साथ परिणाम एकत्र करें

Alex Johnson
Alex Johnson

Senior Web Scraping Engineer

12-Nov-2026

सारांश:

  • Google वेब‑सर्च pagination start offsets का उपयोग करती है। एक ही query और locale को फिक्स रखें और क्रमशः 0, 10, 20 आदि offsets के लिए अनुरोध करें।
  • दस पेज होने का मतलब सौ organic रिकॉर्ड नहीं होता। एक worked coffee कलेक्शन ने दस पेजों में कुल 95 रिकॉर्ड लौटाए।
  • Deduplication के लिए स्पष्ट परिभाषा ज़रूरी है। उन 95 रिकॉर्ड्स में 85 अलग‑अलग लौटी हुई link strings थीं, न कि 85 सत्यापित यूनिक destination पेज।
  • Bounded loop के लिए stop reason को रिकॉर्ड करना ज़रूरी है। खाली arrays, दोहराए गए पेज, errors, और page limit अलग‑अलग outcomes हैं।

भूमिका: पहली पेज से आगे तक डेटा इकट्ठा करें

Google SERP API pagination आपस में संबंधित अवलोकनों की एक श्रृंखला है। हर request उसी search के एक और offset के लिए पूछती है, और हर response को अपना अलग context चाहिए।

यह ट्यूटोरियल Scrapeless Google Search API का उपयोग करके अधिकतम दस वेब‑सर्च पेजों के लिए अनुरोध करता है। यह हर response को संरक्षित रखता है, हर रखे गए रिकॉर्ड के साथ उसका offset जोड़ता है, और raw rows को deduplicated link strings से अलग पहचानता है। यह उदाहरण गहरे topic discovery और search coverage के निरीक्षण के लिए उपयोगी है। यह शीर्ष सौ रैंकिंग का पूर्ण dataset स्थापित नहीं करता।

Google Search endpoint controls वेब‑सर्च offsets को परिभाषित करते हैं, जबकि actor request pattern आस‑पास की API call की व्याख्या करता है। कलेक्शन के दौरान search mode को फिक्स रखें।

start से Request कैसे बदलती है

start पैरामीटर वेब‑सर्च request के लिए result offset चुनता है। सामान्य page sequence 0, 10, 20 आदि होती है।

Offset एक request control है, यह यह गिनती नहीं है कि पिछली response में कितने organic रिकॉर्ड आए। अगर किसी पेज पर नौ organic रिकॉर्ड लौटते हैं, तो भी इस उदाहरण में अगली request उसी तरह अगला configured offset उपयोग करती है। len(organic_results) से आगे बढ़ने पर response count को pagination contract के साथ मिला दिया जाएगा।

q, gl, hl और किसी भी explicit filters को अपरिवर्तित रखें। अगर आप run के बीच में ही country बदल देते हैं, तो संयुक्त array अब एक ही search configuration का वर्णन नहीं करेगी। इस गलती को पता लगाने लायक बनाए रखने के लिए हर पेज के साथ पूरा input object संग्रहीत करें।

उदाहरण num और tbm को छोड़ देता है। यह वेब‑सर्च pagination का उदाहरण है; अन्य modes को अलग से जाँचना होगा। Modes के बीच offsets ट्रांसफर करने के बजाय वर्तमान parameter definitions देखें।

असमान Page Sizes के साथ दस‑पेज का उदाहरण

q=coffee, gl=us और hl=en के लिए एक कलेक्शन में सभी दस अनुरोधित offsets पर organic रिकॉर्ड लौटे। इस sample में हर request HTTP 200 के साथ पूरी हुई।

start Returned Organic Records
0 9
10 9
20 9
30 9
40 10
50 10
60 10
70 9
80 10
90 10
Total 95

लौटी हुई link strings की exact equality से 85 अलग‑अलग मान मिले। यह गणना redirects को follow नहीं करती, canonical tags की तुलना नहीं करती, और न ही content identity स्थापित करती है। दो अलग links एक ही पेज पर ले जा सकते हैं; दो अलग पेज एक domain साझा कर सकते हैं। न hostname grouping और न ही raw string comparison unique destination coverage सिद्ध करते हैं।

यह उदाहरण स्थापित करता है कि configured offsets ने एक कलेक्शन में डेटा लौटाया। यह इस बात की गारंटी नहीं है कि हर query दस nonempty पेज दिखाती है। मल्टी‑request कलेक्शन चलने के दौरान search results बदल सकते हैं।

Bounded Pagination Collector बनाएं

Collector अधिकतम दस search submissions करता है, हर पूरी हुई response को सेव करता है, और तब जल्दी रुक जाता है जब उसे खाली organic array या एक समान result page दिखता है। यह error को error के रूप में रिकॉर्ड करता है और पहले से इकट्ठा किए गए डेटा को सुरक्षित रखता है।

आवश्यकताएँ हैं: Python, Requests, और environment में सेट किया हुआ SCRAPELESS_API_KEY। Requests को python -m pip install requests से इंस्टॉल करें, प्रोग्राम को paginate_google.py के रूप में सेव करें, और python paginate_google.py चलाएँ। आउटपुट pagination-runs के अंदर एक नए डायरेक्टरी में जाएगा।
The request helper पूर्ण और अपूर्ण दोनों प्रकार के कार्यों को संभालता है। यह प्रत्येक खोज को एक बार सबमिट करता है और आवश्यकता होने पर मौजूदा कार्य के परिणाम एंडपॉइंट का उपयोग करता है। लंबित‑कार्य वर्कफ़्लो उस भेद को परिभाषित करता है; कोड की सीमाएँ स्थानीय नीति विकल्प हैं।

python Copy
import json
import os
import time
from pathlib import Path
from urllib.parse import quote

import requests

BASE = "https://api.scrapeless.com/api/v1/scraper"


def google_search(query):
    headers = {"x-api-token": os.environ["SCRAPELESS_API_KEY"]}
    response = requests.post(
        BASE + "/request", headers=headers,
        json={"actor": "scraper.google.search", "input": query},
        timeout=(10, 60), allow_redirects=False,
    )
    task_id = None
    for poll in range(11):
        response.raise_for_status()
        if response.status_code not in (200, 201):
            raise RuntimeError(f"Unexpected HTTP status: {response.status_code}")
        data = response.json()
        if not isinstance(data, dict):
            raise ValueError("Expected a JSON object")
        if response.status_code == 200:
            return data
        if task_id is None:
            task_id = data.get("taskId")
        if not isinstance(task_id, str) or not task_id:
            raise ValueError("Pending response has no taskId")
        if poll == 10:
            raise TimeoutError(f"Task still pending; retain taskId={task_id}")
        time.sleep(2)
        response = requests.get(
            BASE + "/result/" + quote(task_id, safe=""),
            headers=headers, timeout=(10, 30), allow_redirects=False,
        )


def organic_rows(data):
    rows = data.get("organic_results")
    if not isinstance(rows, list):
        raise ValueError("organic_results is missing or is not an array")
    if not all(isinstance(row, dict) for row in rows):
        raise ValueError("organic_results contains a non-object item")
    return rows


if __name__ == "__main__":
    from datetime import datetime, timezone
    run_dir = Path("pagination-runs") / datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
    run_dir.mkdir(parents=True)
    seen_links = set()
    seen_pages = set()
    collected = []
    summary = []
    stop_reason = "page_limit"
    try:
        for start in range(0, 100, 10):
            query = {"q": "coffee", "gl": "us", "hl": "en", "start": start}
            data = google_search(query)
            (run_dir / f"page-{start}.json").write_text(
                json.dumps({"input": query, "response": data}, ensure_ascii=False, indent=2),
                encoding="utf-8",
            )
            rows = organic_rows(data)
            signature = json.dumps(rows, sort_keys=True, ensure_ascii=False)
            repeat = bool(rows) and signature in seen_pages
            seen_pages.add(signature)
            new_count = 0
            for index, row in enumerate(rows, start=1):
                link = row.get("link")
                usable_link = isinstance(link, str) and bool(link.strip())
                if usable_link and link in seen_links:
                    continue
                if usable_link:
                    seen_links.add(link)
                collected.append({"start": start, "array_index": index, "result": row})
                new_count += 1
            summary.append({"start": start, "returned": len(rows), "kept": new_count})
            if not rows:
                stop_reason = "empty_organic_array"
                break
            if repeat:
                stop_reason = "identical_result_page"
                break
    except (requests.RequestException, ValueError, RuntimeError, TimeoutError) as exc:
        stop_reason = "error:" + type(exc).__name__
        raise
    finally:
        (run_dir / "collected.json").write_text(json.dumps(collected, ensure_ascii=False, indent=2), encoding="utf-8")
        report = {"pages": summary, "stop_reason": stop_reason, "kept_rows": len(collected)}
        (run_dir / "summary.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
        print(json.dumps(report))

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

Scrapeless के साथ स्क्रैपिंग शुरू करें

Scrapeless के साथ अपने वेब स्क्रैपिंग और ऑटोमेशन वर्कफ़्लो को पावर‑अप करें!
आज ही साइन अप करें और पाएं $5 का फ्री क्रेडिट — कोई क्रेडिट कार्ड आवश्यक नहीं।

अभी अपना फ्री क्रेडिट Scrapeless Dashboard में क्लेम करें।

संयमित डेडुप्लिकेशन नियम चुनें

कलेक्टर नॉन‑एम्प्टी रिटर्न की गई लिंक स्ट्रिंग्स को बिल्कुल मिलान करके डेडुप्लिकेट करता है और जिन पंक्तियों में लिंक नहीं हैं उन्हें बनाए रखता है। यह नीति ऑडिट करना आसान है क्योंकि यह URL कॉम्पोनेंट्स को फिर से नहीं लिखती।

URI सामान्यीकरण मॉडल यह समझाता है कि URL की तुलना के लिए स्पष्ट नियम क्यों आवश्यक हैं। क्वेरी स्ट्रिंग्स को आँख बंद करके हटाना, पाथ के केस को बदलना, या स्लैश वेरिएंट्स को समेटना सार्थक भेद मिटा सकता है। शामिल टार्गेट वेबसाइटों को वैलिडेट करने के बाद ही मज़बूत सामान्यीकरण जोड़ें।

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

दोहराए‑पेज सुरक्षा‑उपाय सीरियलाइज़्ड परिणाम रिकॉर्ड्स की तुलना करता है। यह बिल्कुल दोहराए गए डाटा का पता लगाता है; यह यह दावा नहीं करता कि वह हर लगभग‑डुप्लीकेट SERP की पहचान करता है। एक सीमित पेज सीमा अभी भी आवश्यक है क्योंकि छोटे‑छोटे फ़ील्ड परिवर्तन दो देखने में समान प्रतिक्रियाओं को अलग तरह से तुलना करवा सकते हैं।

खाली पेज और आंशिक रन की व्याख्या करें

इस कलेक्टर में खाली ऑर्गेनिक ऐरे एक स्टॉप कंडीशन है, यह इस बात का प्रमाण नहीं कि Google के पास विषय के बारे में और इंडेक्स किए गए पेज नहीं हैं। गुम ऐरे और ख़राब रिकॉर्ड अब भी वैलिडेशन फ़ेल्योर माने जाते हैं।

Stop Reason कलेक्टर ने क्या देखा सुरक्षित व्याख्या
page_limit कॉन्फ़िगर किया गया पेज बजट पूरा हो गया कलेक्शन अपने कॉन्फ़िगर किए गए बजट तक पूरी है
empty_organic_array एक पूर्ण प्रतिक्रिया में ऑर्गेनिक रिकॉर्ड शून्य थे यह रन उस ऑफ़सेट पर रुक गया
identical_result_page ऑर्गेनिक रिकॉर्ड्स बिल्कुल दोहराए गए आगे की कलेक्शन को सुरक्षा‑उपाय ने रोक दिया
error:... कोई रिक्वेस्ट या पार्सिंग स्टेप फ़ेल हुआ डेटासेट आंशिक है

सामान्य HTTP स्टेटस सेमांटिक्स ट्रांसपोर्ट परिणामों में भेद करने में मदद करते हैं, जबकि आपकी एप्लिकेशन को अब भी कलेक्शन की पूर्णता दर्ज करनी होती है। पहला सफल पेज किसी बाद के असफल पेज को सफल नहीं बना देता।

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

निष्कर्ष: गहराई और कवरेज की अलग‑अलग रिपोर्ट करें

किसी पेजिनेशन रिपोर्ट में अनुरोधित ऑफ़सेट, पूर्ण पेज, कच्ची पंक्तियाँ और डेडुप्लिकेशन नियम दिखाना चाहिए। ये माप अलग‑अलग प्रश्नों के उत्तर देते हैं और इन्हें कोड और गद्य दोनों में अलग‑अलग ही रहना चाहिए।

गहन कलेक्शन के बजट बनाते समय सेवा विवरण और मौजूदा मूल्य‑निर्धारण के लिए Google Search API उत्पाद पेज का उपयोग करें। दस‑पेज बजट एक कलेक्शन सेटिंग है, न कि सौ अंतिम URLs का वादा।

अपना सर्च डेटा वर्कफ़्लो बनाएं

हमारे समुदाय में सर्च डेटा के साथ काम कर रहे डेवलपर्स से जुड़ें: Discord · Telegram.

एक Scrapeless अकाउंट बनाएँ और बड़ी कलेक्शन को शेड्यूल करने से पहले इस ट्यूटोरियल को एक छोटे क्वेरी सेट पर लागू करें।

FAQ

प्र: क्या start को लौटाई गई पंक्तियों की संख्या के अनुसार बढ़ना चाहिए?
नहीं। वेब-सर्च ऑफ़सेट अनुक्रम का ही पालन करें। नौ ऑर्गेनिक रिकॉर्ड वाले पेज से अगला कॉन्फ़िगर किया गया ऑफ़सेट नहीं बदलता।

प्रश्न: क्या दस-पेज कलेक्शन हमेशा सौ परिणाम लौटाता है?

नहीं। तैयार किया गया कलेक्शन 95 ऑर्गेनिक रिकॉर्ड लौटा पाया। पेज आकार और उपलब्धता को हर रिस्पॉन्स से मापा जाना चाहिए।

प्रश्न: क्या 85 अलग लिंक स्ट्रिंग्स 85 यूनिक वेबपेज के बराबर हैं?

नहीं। सिर्फ़ एक जैसी स्ट्रिंग हटाने से रीडायरेक्ट, कैनॉनिकल पहचान, या पेज कंटेंट की जाँच नहीं हो जाती।

प्रश्न: क्या HTTP एरर को एक खाली पेज के रूप में स्टोर करना चाहिए?

नहीं। असफलता को अलग से स्टोर करें और रन को आंशिक के रूप में चिह्नित करें। एक खाली completed ऐरे का मतलब अलग होता है।

प्रश्न: क्या pagination.next को सीधे Google से फ़ेच करना ज़रूरी है?

नहीं। यह क्लाइंट अनुरोधों को Scrapeless एंडपॉइंट पर ही रखता है और कॉन्फ़िगर किए गए start मान को सप्लाई करता है। यह Google नेविगेशन URLs को सीधे फ़ेच नहीं करता।

प्रश्न: क्या कलेक्टर AI एजेंट के बिना चल सकता है?

हाँ। यह एक स्टैंडअलोन Python प्रोग्राम है जिसमें सीमित, क्रमिक पेज लूप होता है।

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

सबसे लोकप्रिय लेख

सूची