फेसबुक विज्ञापन पुस्तकालय को स्क्रैपलेस स्क्रैपिंग ब्राउज़र के साथ कैसे स्क्रैप करें

TL;DR:

• फेसबुक विज्ञापन पुस्तकालय एक सार्वजनिक सतह है - इसे देखने के लिए किसी लॉगिन की आवश्यकता नहीं है। कोई भी facebook.com/ads/library खोल सकता है, एक विज्ञापनदाता या कीवर्ड खोज सकता है, और एक पृष्ठ द्वारा चलाए जा रहे सभी सक्रिय औरinactive विज्ञापनों को पढ़ सकता है, जिसमें विज्ञापनदाता का नाम, विज्ञापन की सामग्री और प्रत्येक विज्ञापन के चलने की तारीखें शामिल हैं।
• यह पृष्ठ पूरी तरह से क्लाइंट-साइड पर तैयार किया गया है, इसलिए केवल HTTP के जरिए एक खाली खोल मिलता है। विज्ञापन कार्ड को प्रारंभिक प्रतिक्रिया के बाद JavaScript द्वारा पेंट किया जाता है, और परिणाम ग्रिड एक एंटी-बॉट चेक के पीछे बैठता है, इसलिए एक सामान्य requests.get पर कोई विज्ञापन नहीं दिखाई देता।
• स्क्रैपलेस स्क्रैपिंग ब्राउजर पृष्ठ को क्लाउड-साइड पर तैयार करता है और पेंटेड DOM लौटाता है। यूएस आवासीय निकासी और गर्म सत्र के साथ Chrome DevTools प्रोटोकॉल के माध्यम से जुड़ने पर पूर्ण रूप से तैयार किया गया परिणाम ग्रिड मिलता है, जिसे किसी भी स्थिर पृष्ठ की तरह पार्स किया जा सकता है।
• हर विज्ञापन को स्थिर लाइब्रेरी आईडी: टेक्स्ट एंकर से खोजें, ना कि एक हैशेड CSS क्लास से। हर विज्ञापन कार्ड पर लाइब्रेरी आईडी: <digits> लेबल होता है; उस एंकर से अपने एकल-कार्ड कंटेनर तक चढ़ने से उस React क्लास-नाम चर्न से बचे रहते हैं जो नाजुक चयनकर्ताओं को तोड़ता है।
• एक कीवर्ड खोज ने पहली बार में 27 विज्ञापन कार्ड लौटाए और ग्रिड को छह बार स्क्रॉल करने के बाद 104। यहां पृष्ठांकन अनंत स्क्रॉल है: ग्रिड और कार्ड जोड़ता है जब आप स्क्रॉल करते हैं, इसलिए आप प्रत्येक स्क्रॉल के बाद DOM को पढ़ते हैं जब तक गिनती बढ़ना बंद नहीं होती।
• शुरू करने के लिए मुफ्त। नए स्क्रैपलेस खातों में मुफ्त स्क्रैपिंग ब्राउजर रनटाइम शामिल है - app.scrapeless.com पर साइन अप करें।

परिचय: किसी भी ब्रांड द्वारा चलाए जा रहे सार्वजनिक विज्ञापनों को पढ़ें

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

फ्रिक्शन रेंडरिंग में है, एक्सेस में नहीं। सार्वजनिक विज्ञापनों को देखने के लिए किसी अकाउंट की आवश्यकता नहीं है, लेकिन पृष्ठ अपने पूरे परिणाम ग्रिड को ब्राउज़र में पहले उत्तर के बाद बनाता है, और ग्रिड एक स्वचालित-traffic सुरक्षा द्वारा गेटेड है, जिसे एक सामान्य HTTP क्लाइंट तुरंत ट्रिप करता है। URL को requests के साथ डाउनलोड करें और विज्ञापन कार्ड बस आपको वापस मिलने वाले बाइट्स में नहीं होते - उन्हें बाद में JavaScript द्वारा पेंट किया जाता है जो कभी नहीं चलती। जो मार्कअप प्रदर्शित होता है वो घूमते, हैश किए हुए React क्लास नामों पर निर्भर करता है, इसलिए जो चयनकर्ता एक क्लास स्ट्रिंग से चिपका है वह अगले फ्रंट-एंड डिप्लॉय पर टूट जाता है।

यह गाइड Python में Scrapeless Scraping Browser पर आधारित है, जो एक क्लाउड ब्राउज़र है जो यूएस आवासीय निकासी से पृष्ठ को तैयार करता है और पूरा DOM लौटाता है। पैटर्न वही है: रेंडर → डिस्कवर → एक्सट्रेक्ट → पेजिनेट लूप जो किसी भी स्क्रैपर को संचालित करता है, एक मोड़ के साथ: डिस्कवरी स्थायी लाइब्रेरी आईडी: टेक्स्ट पर एंकर करती है जो प्रत्येक कार्ड प्रिंट करता है, इसलिए पार्स क्लास-नाम चर्न को सहन करता है। स्थैतिक बनाम गतिशील रेंडरिंग विभाजन, JavaScript में, Cheerio और Puppeteer वॉकथ्रू में कवर किया गया है।

आप इसके साथ क्या कर सकते हैं

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

क्यों स्क्रैपलेस स्क्रैपिंग ब्राउज़र

स्क्रैपलेस स्क्रैपिंग ब्राउज़र एक कस्टमाइज़ेबल, एंटी-डिटेक्शन क्लाउड ब्राउज़र है जिसे वेब क्रॉलर्स और एआई एजेंटों के लिए डिज़ाइन किया गया है। विशेष रूप से विज्ञापन पुस्तकालय के लिए, इसमें शामिल है:

• क्लाउड-साइड जावास्क्रिप्ट रेंडरिंग। परिणाम ग्रिड प्रारंभिक प्रतिक्रिया के बाद पेंट किया जाता है; क्लाउड ब्राउज़र पृष्ठ को चलाता है और एक DOM लौटाता है जिसमें पहले से ही विज्ञापन कार्ड होते हैं, इसलिए BeautifulSoup इसे स्थिर HTML की तरह पार्स करता है।
• 195+ देशों में आवासीय प्रॉक्सी। विज्ञापन पुस्तकालय अपने सामग्री को दर्शक देश के अनुसार भिन्न करता है, इसलिए यूएस आवासीय निकासी से पिन करने पर वही विज्ञापन लौटता है जो एक यूएस विज़िटर देखेगा।
• एंटी-डिटेक्शन फिंगरप्रिंटिंग। पृष्ठ अपने ग्रिड को एक बॉट चेक के पीछे गेट करता है; क्लाउड ब्राउज़र एक स्थिर, मानव-सदृश ब्राउज़र सतह प्रस्तुत करता है ताकि ग्रिड चुनौती के बजाय दिखे।
• पूरे सिस्टम के लिए एक API कुंजी। Python SDK एक browser_ws_endpoint उत्पन्न करता है जिसे आप Playwright के माध्यम से CDP के साथ जोड़ते हैं, और वही कुंजी रनटाइम को कवर करती है।

अपना API कुंजी मुफ्त योजना पर app.scrapeless.com पर प्राप्त करें।

पूर्वापेक्षाएँ

• Python 3.10 या नई
• scrapeless SDK, playwright, और beautifulsoup4
• एक Scrapeless खाता और API कुंजी — पर साइन अप करें app.scrapeless.com
• टर्मिनल के साथ मूलभूत परिचितता

स्थापना

SDK, प्रोटोकॉल क्लाइंट, और HTML पार्सर स्थापित करें:

pip install scrapeless playwright beautifulsoup4
playwright install chromium

playwright install chromium एक बार स्थानीय प्रोटोकॉल क्लाइंट डाउनलोड करता है; वास्तविक रेंडरिंग अभी भी Scrapeless क्लाउड में चलती है। scrapeless SDK ब्राउज़र सत्र उत्पन्न करता है और beautifulsoup4 लौटाए गए DOM को पार्स करता है। कुछ चलाने से पहले अपनी कुंजी को निर्यात करें: export SCRAPELESS_API_KEY=your_api_token_here.

चरण 1 — विज्ञापन पुस्तकालय पृष्ठ को रेंडर करें और पुष्टि करें कि विज्ञापन मौजूद हैं

स्क्रैप एक स्वच्छ रेंडर के साथ शुरू होता है। विज्ञापन पुस्तकालय URL खोज को क्वेरी पैरामीटर में ले जाता है — कीवर्ड के लिए q , दर्शक भौगोलिक क्षेत्र के लिए country , और फ़िल्टर के लिए active_status और ad_type। क्लाउड ब्राउज़र से जुड़ें, पहले सार्वजनिक फेसबुक घरेलू पृष्ठ पर सत्र को गरम करें ताकि अनुरोध एक स्थापित ब्राउज़र सतह को ले जाए, फिर खोज URL लोड करें और एकल फ़ील्ड चयनकर्ता लिखे बिना विज्ञापन कार्ड की गिनती करें।

import re
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser
from playwright.sync_api import sync_playwright

URL = ("https://www.facebook.com/ads/library/"
       "?active_status=all&ad_type=all&country=US&q=nike")
LIB = re.compile(r"Library ID:\s*\d+")

client = Scrapeless()  # पर्यावरण से SCRAPELESS_API_KEY पढ़ता है
session = client.browser.create(ICreateBrowser(proxy_country="US", session_ttl=240))

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(session.browser_ws_endpoint)
    ctx = browser.contexts[0] if browser.contexts else browser.new_context()
    page = ctx.pages[0] if ctx.pages else ctx.new_page()
    page.goto("https://www.facebook.com/", wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_timeout(3_000)  # पहले सार्वजनिक घरेलू पृष्ठ पर सत्र को गरम करता है
    page.goto(URL, wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_timeout(8_000)  # परिणाम ग्रिड को क्लाइंट-साइड रेंडर करने देता है
    html = page.content()
    browser.close()

print("html bytes:", len(html), "| पहले रेंडर पर विज्ञापन कार्ड:", len(LIB.findall(html)))

यह एक पंक्ति प्रिंट करता है जैसे html bytes: 1796025 | पहले रेंडर पर विज्ञापन कार्ड: 27 — लगभग 1.8 MB का रेंडर किया हुआ HTML जिसमें पहले पेंट पर 27 विज्ञापन कार्ड हैं (बाइट गिनती विभिन्न क्रिएटिव लोड होने के कारण चलती रहती है)। पृष्ठ का शीर्षक Ad Library है, और फेसबुक URL को अपने स्वयं के डिफ़ॉल्ट जोड़ने के लिए फिर से लिखता है (search_type=keyword_unordered, media_type=all, एक sort_data ब्लॉक)। wait_until="domcontentloaded" के साथ एक स्थिर सेट करना जानबूझकर है: विज्ञापन पुस्तकालय विश्लेषण और व्यक्तिगत अनुरोधों का प्रवाह करता है जो कभी भी निष्क्रिय नहीं होते, इसलिए नेटवर्क निष्क्रिय पर इंतजार करना समय सीमा तक रुकेगा। पहले घरेलू पृष्ठ पर गरम करना ग्रिड को एंटी-बॉट चुनौती के बजाय रेंडर करने के लिए प्राप्त करता है।

चरण 2 — एक स्थिर अनुक्रमणिका से प्रत्येक विज्ञापन का पता लगाएं, फिर इसके फ़ील्ड निकालें

परिणाम ग्रिड के React वर्ग नाम हैश किए गए हैं और तैनाती के बीच घूमते हैं, इसलिए एक चयनकर्ता जैसे div.x1lliihq एक दायित्व है। दीर्घकालिक संकेत वह टेक्स्ट है जो हर कार्ड प्रिंट करता है: Library ID: <digits>। उस लेबल पर एंकर खोजें, सबसे बड़े पूर्वज पर चढ़ें जो अभी भी ठीक एक पुस्तकालय ID को लपेटता है — वह कंटेनर एक विज्ञापन कार्ड है — फिर इसके अंदर पाठ और लिंक से फ़ील्ड पढ़ें।

from bs4 import BeautifulSoup

soup = BeautifulSoup(html, "html.parser")  # चरण 1 से html

def single_card(node):
    # सबसे बड़ा पूर्वज जिसका उपवृक्ष अभी भी ठीक एक "Library ID:" रखता है।
    best, n = node.parent, node.parent
    while n is not None and len(LIB.findall(n.get_text(" ", strip=True))) == 1:
        best, n = n, n.parent
    return best

def fields(card):
    txt = card.get_text("\n", strip=True)
    lib = re.search(r"Library ID:\s*(\d+)", txt)
    status = "Active" if re.search(r"\bActive\b", txt) else (
        "Inactive" if "Inactive" in txt else None)
    started = re.search(r"Started running on ([A-Z][a-z]+ \d{1,2}, \d{4})", txt)
    ran = re.search(r"([A-Z][a-z]+ \d{1,2}, \d{4}) - ([A-Z][a-z]+ \d{1,2}, \d{4})", txt)
    advertiser = None
    for a in card.find_all("a", href=True):
        if re.match(r"https://www\.facebook\.com/[^/?#]+/?$", a["href"]) and a.get_text(strip=True):

Here is the translation of the provided English text into Hindi:

advertiser = a.get_text(strip=True)
            break
    return {
        "library_id": lib.group(1) if lib else None,
        "advertiser": advertiser,
        "status": status,
        "started_running": started.group(1) if started else None,
        "active_range": list(ran.groups()) if ran else None,
    }

seen, cards = set(), []
for node in soup.find_all(string=LIB):
    card = single_card(node)
    if id(card) not in seen:
        seen.add(id(card))
        cards.append(card)

records = [fields(c) for c in cards]
print("विज्ञापन रिकॉर्ड निकाले गए:", len(records))
for r in records[:4]:
    print(r)

यह 27 रिकॉर्ड निकालता है। पहले कुछ वास्तविक विज्ञापनदाताओं और तारीखों के रूप में प्रिंट होते हैं — {'library_id': '1869276447125570', 'advertiser': 'Nike', 'status': 'Active', 'started_running': 'Mar 17, 2026', 'active_range': None}। दो तारीखों के रूपों का ध्यान रखें: एक सक्रिय विज्ञापन Started running on <date> प्रिंट करता है, जबकि एक निष्क्रिय विज्ञापन इसके बजाय <start> - <end> रन रेंज प्रिंट करता है, इसलिए पार्सर दोनों को पढ़ता है और दूसरे फ़ील्ड को None छोड़ देता है। विज्ञापनदाता पहले लिंक से आता है जो एक सामान्य पृष्ठ URL (facebook.com/<page>/) की ओर इंगित करता है, जो कार्ड में पृष्ठ नाम प्रकट होने का सबसे स्थिर स्थान है।

मुफ्त योजना पर अपना एपीआई कुंजी प्राप्त करें: app.scrapeless.com

कदम 3 — परिणाम ग्रिड को स्क्रॉल करके अधिक विज्ञापन लोड करें

विज्ञापन पुस्तकालय पृष्ठ संख्याओं के साथ पृष्ठांकन नहीं करता है — यह स्क्रॉल करने पर अधिक कार्ड जोड़ता है। विश्वसनीय पैटर्न ग्रिड को स्क्रॉल करना है, नए कार्ड को रेंडर होने की प्रतीक्षा करना है, DOM को फिर से पढ़ना है, और तब तक दोहराना है जब तक कार्ड की संख्या बढ़ना बंद न हो जाए। प्रत्येक स्क्रॉल के बाद Library ID: घटनाएँ गिनने से आपको पता चलता है कि उस खोज के लिए ग्रिड कब समाप्त हो जाता है।

session = client.browser.create(ICreateBrowser(proxy_country="US", session_ttl=240))

with sync_playwright() as p:
    browser = p.chromium.connect_over_cdp(session.browser_ws_endpoint)
    ctx = browser.contexts[0] if browser.contexts else browser.new_context()
    page = ctx.pages[0] if ctx.pages else ctx.new_page()
    page.goto("https://www.facebook.com/", wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_timeout(3_000)
    page.goto(URL, wait_until="domcontentloaded", timeout=60_000)
    page.wait_for_timeout(8_000)

    def card_count():
        return len(LIB.findall(page.content()))

    counts = [card_count()]
    for _ in range(6):  # ग्रिड स्क्रॉल करने पर और अधिक कार्ड लोड करता है
        page.mouse.wheel(0, 6_000)
        page.wait_for_timeout(2_500)
        counts.append(card_count())
    browser.close()

print("प्रत्येक स्क्रॉल के बाद कार्ड की संख्या:", counts)

यह प्रिंट करता है प्रत्येक स्क्रॉल के बाद कार्ड की संख्या: [27, 37, 47, 66, 75, 85, 104] — ग्रिड पहले रेंडर पर 27 कार्ड से बढ़कर छह स्क्रॉल के बाद 104 हो गया। जब दो लगातार गिनतियाँ मिलती हैं, तो ग्रिड उस प्रश्न के लिए लोड करना बंद कर चुका है और आप स्क्रॉल करना बंद कर सकते हैं। स्क्रॉल चरण को मध्यम रखें और नए कार्ड के पेंट होने के लिए लंबे समय तक स्थिर रहें, या आप ग्रिड के साथ जुड़ने से पहले गिनती पढ़ लेते हैं।

कदम 4 — संरचित आउटपुट लिखें

कदम 2 से records सूची पहले से ही संगत कुंजियों के साथ शब्दकोशों की एक सूची है, इसलिए इसे CSV या JSON में लिखना कुछ रेखाएँ हैं। स्कीमा को पहले से तय करें — प्रत्येक पंक्ति पर वही कुंजियाँ — इसलिए एक अनुपस्थित फ़ील्ड None बन जाती है, कभी भी क्रैश नहीं होता।

import csv
import json

# रिकॉर्ड चरण 2 में निर्मित डिक्ट की सूची है (चरण 3 में अंतिम स्क्रॉल के बाद पार्स को फिर से चलाएं, 
# सभी लोड किए गए कार्ड को कैप्चर करने के लिए)।
fieldnames = ["library_id", "advertiser", "status", "started_running", "active_range"]
with open("facebook_ads.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fieldnames)
    writer.writeheader()
    for row in records:
        writer.writerow({**row, "active_range": json.dumps(row["active_range"])})

with open("facebook_ads.json", "w", encoding="utf-8") as f:
    json.dump(records, f, ensure_ascii=False, indent=2)

print("लिखी गईं", len(records), "पंक्तियाँ facebook_ads.csv और facebook_ads.json में")

यह पूरा लूप है: बादल ब्राउज़र में ग्रिड को रेंडर करें, Library ID: एंकर से प्रत्येक कार्ड को खोजें, विज्ञापनदाता और तारीखों को निकालें, अधिक लोड करने के लिए स्क्रॉल करें, और संग्रहीत करें। URL में q और country पैरामीटर को स्वैप करें ताकि इसे किसी भी विज्ञापनदाता, कुंजीशब्द, या क्षेत्र की ओर इंगित किया जा सके जो विज्ञापन पुस्तकालय सेवा करता है।

विज्ञापन डेटा का जिम्मेदारी से प्रबंधन

विज्ञापन पुस्तकालय एक सार्वजनिक पारदर्शिता सतह है, और इसमें विज्ञापन ब्रांडों द्वारा प्रकाशित होते हैं जिन्हें कोई भी देख सकता है — लेकिन रिकॉर्ड फिर भी पहचान योग्य विज्ञापनदाताओं से जुड़े होते हैं, इसलिए इन्हें सावधानीपूर्वक इकट्ठा करें:

• सार्वजनिक सतह पर बने रहें। इस मार्गदर्शिका में सब कुछ वही गुमनाम, बिना लॉगिन वाला परिणाम ग्रिड पढ़ता है जो कोई भी आगंतुक देखता है। गेटेड दृश्य तक पहुँचने के लिए प्रमाणित न हों या कुछ भी न खींचें जो सार्वजनिक पृष्ठ नहीं दिखाता है।

- **विज्ञापन और विज्ञापनदाता डेटा इकट्ठा करें, व्यक्तिगत डेटा नहीं।** यहाँ उपयोगी क्षेत्र विज्ञापनदाता पृष्ठ, रचनात्मकता, और चलने की तिथियाँ हैं। टिप्पणी करने वालों के नाम, प्रतिक्रियाएं, या विज्ञापन से जुड़ी कोई भी व्यक्तिगत जानकारी प्राप्त करने से बचें।
- **न्यूनतम रखें और उद्देश्य पर टिकें।** अपने विश्लेषण की आवश्यकता वाली क्षेत्र को खींचें और इससे ज्यादा नहीं, और इन्हें केवल तब तक बनाए रखें जब तक उपयोग का मामला आवश्यक हो।
- **प्लेटफ़ॉर्म की शर्तों और दर सीमाओं का सम्मान करें।** मेटा की सेवा की शर्तों और <a href="https://datatracker.ietf.org/doc/html/rfc9309" rel="nofollow"><strong>रोबोट्स बहिष्कार प्रोटोकॉल</strong></a> का सम्मान करें, और अनुरोध की मात्रा को सभ्य रखें; निकासी को पिन करें और समवर्तीता को सीमित करें बजाय इसके कि ग्रिड को तोड़ें।

वाणिज्यिक या अनुपालन-संवेदनशील कार्य के लिए, लागू प्लेटफ़ॉर्म की शर्तों की समीक्षा करें और नियमित पाइपलाइन बनाने से पहले कानूनी सलाह लें।

---

## आपको क्या वापस मिलेगा

पार्स के बाद, प्रत्येक विज्ञापन कार्ड एक सपाट रिकॉर्ड में घटित होता है जिसमें एक स्थायी स्कीमा होती है:

```json
[
  {
    "library_id": "1869276447125570",
    "advertiser": "Nike",
    "status": "Active",
    "started_running": "Mar 17, 2026",
    "active_range": null
  },
  {
    "library_id": "308819044896583",
    "advertiser": "Nike",
    "status": "Inactive",
    "started_running": null,
    "active_range": ["Aug 15, 2023", "Jul 24, 2025"]
  }
]
// स्कीमा उस सभी को ठीक से दर्शाता है जो चरण 2 पार्स उत्पन्न करता है। क्षेत्र के मान प्रदर्शनीय नमूने हैं।

व्यवहार में कुछ चीजों की अपेक्षा करें:

• कार्ड की गिनती रन के बीच बदलती है। वही प्रश्न थोड़े अलग संख्या में कार्ड लौटा सकता है इस पर निर्भर करते हुए कि कौन से विज्ञापन लाइव हैं और ग्रिड ने कितनी दूर लोड किया है; गिनती को एक स्नैपशॉट के रूप में लें, एक निश्चित कुल के रूप में नहीं।
• दो दिन की आकृतियाँ, एक स्कीमा। सक्रिय विज्ञापनों में एकल चलना शुरू किया की तारीख होती है; निष्क्रिय विज्ञापनों में एक रन रेंज होती है। पार्सर जो भी मौजूद होता है उसे भरता है और दूसरे को None छोड़ देता है।
• पाठ पर केंद्रित करें, विचलन पर फिर से जांच करें। पुस्तकालय आईडी: लेबल हैश किए गए रिएक्ट क्लासेज़ की तुलना में कहीं अधिक स्थायी है, लेकिन मेटा समय-समय पर कार्ड लेआउट बदलता है — जब मार्कअप बदलता है तो खोज और क्षेत्र के पैटर्न की फिर से जांच करें।
• अपनी निकासी पिन करें। proxy_country="US" वापस किए गए विज्ञापनों को एक अमेरिकी दर्शक के साथ संगत रखता है; उस क्षेत्र को अंतिम बनाएं जिसकी आपको आवश्यकता है, क्योंकि विज्ञापन पुस्तकालय विभिन्न देशों के लिए परिणामों में भिन्नता करता है।

निष्कर्ष: अपने विज्ञापन पुस्तकालय निकासी पाइपलाइन का पैमाना बढ़ाएँ

फेसबुक विज्ञापन पुस्तकालय को पढ़ना चार कदमों में घटित होता है: परिणाम ग्रिड को एक क्लाउड ब्राउज़र में रेंडर करें, स्थिर पुस्तकालय आईडी: एंकर से प्रत्येक विज्ञापन की खोज करें, विज्ञापनदाता और चलने की तिथियों को निकालें, और जब तक गिनती स्थिर न हो जाए तब तक और लोड करने के लिए स्क्रॉल करते रहें। एक भाग सादा HTTP, सही HTTP अर्थशास्त्र के साथ, नहीं कर सकता — ग्राहक-पक्ष ग्रिड को एंटी-बॉट जांच के पीछे चलाना — Scrapeless Scraping Browser की ओर सही ढंग से बढ़ता है, जो पृष्ठ को रेंडर करता है और आपके पार्सर को पहले से समझ में आने वाला DOM लौटाता है।

यहाँ से, इसे हर उत्पादन स्क्रैपर की तरह पैमाना बढ़ाएँ: सबसे स्थायी हुक पर एंकर सेलेक्टर रखें और लेआउट बदलने पर उन्हें फिर से जांचें, लक्षित दर्शकों से मेल खाने के लिए अमेरिकी निकासी को पिन करें, अनुपस्थित क्षेत्रों को नल करने के रूप में मानें, और प्रति होस्ट समवर्तीता को सभ्य रखें। जावास्क्रिप्ट में समान रेंडर विभाजन के लिए, Cheerio और Puppeteer गाइड स्टेटिक बनाम डायनेमिक निर्णय को Node.js में बताता है, और SDK और CLI सतह docs.scrapeless.com पर दर्ज की गई है। जब आप इसे मात्रा में चलाने के लिए तैयार हों, तो प्राइसिंग पृष्ठ पर रनटाइम विकल्पों की तुलना करें।

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

हमारे समुदाय में शामिल हों ताकि एक फ्री योजना का दावा कर सकें और विज्ञापन-बुद्धिमता पाइपलाइनों का निर्माण करने वाले डेवलपर्स के साथ जुड़ सकें: Discord · Telegram।

app.scrapeless.com पर साइन अप करें मुफ्त स्क्रैपिंग ब्राउज़र रनटाइम के लिए और उपरोक्त पैटर्न को विज्ञापनदाताओं, कीवर्ड और क्षेत्रों में अनुकूलित करें जिनकी आपको विज्ञापन पुस्तकालय अनुसंधान की आवश्यकता है।

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

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

प्रश्न: क्या मुझे विज्ञापन पुस्तकालय पढ़ने के लिए लॉग इन करने की आवश्यकता है?
नहीं। विज्ञापन पुस्तकालय में सार्वजनिक विज्ञापन अज्ञात विचारकों के लिए प्रदर्शित होते हैं, और यह मार्गदर्शिका उसी बिना लॉगिन सतह को पढ़ती है। उस सार्वजनिक पृष्ठ को दिखाने के लिए देखने के लिए प्रमाणीकरण न करें जो नहीं दिखाता है।

प्रश्न: क्या मुझे प्रॉक्सी की आवश्यकता है?
हाँ। विज्ञापन पुस्तकालय अपने परिणामों को दर्शक के देश के अनुसार भिन्न करता है और बॉट जांच के पीछे ग्रिड को गेट करता है, इसलिए आवासीय प्रॉक्सी के माध्यम से रूट करें और proxy_country के साथ देश को पिन करें ताकि पृष्ठ उन विज्ञापनों को लौटाए जो एक स्थानीय दर्शक देखेगा। स्क्रैपिंग ब्राउज़र सत्र में वह इग्रेस शामिल है।

प्रश्न: पृष्ठ विज्ञापनों के बजाय चुनौती या एक खाली ग्रिड दिखाता है - मैं साफ़ रेंडर कैसे प्राप्त करूँ?
यह अनुरोध पर एंटी-बॉट जांच है। अमेरिकी आवासीय इग्रेस को पिन करके स्क्रैपलेस स्क्रैपिंग ब्राउज़र के माध्यम से रेंडर करें, और 'facebook.com' को पहले उसी सत्र में लोड करके सत्र को गर्म करें, इससे अनुरोध उस समय स्थापित, मानव-समान ब्राउज़र सतह लेकर आता है जब ग्रिड लोड होता है।

प्रश्न: मेरे चयनकर्ताओं ने लेआउट परिवर्तन के बाद काम करना बंद कर दिया - अब क्या?
विज्ञापन पुस्तकालय के रिएक्ट वर्ग नाम हैश किए जाते हैं और घूमते हैं, इसलिए कभी भी उन्हें पिन न करें। प्रत्येक कार्ड पर मुद्रित Library ID: पाठ पर एंकर खोज को प्राथमिकता दें और टेक्स्ट पैटर्न और निर्वस्त्र पृष्ठ लिंक से फ़ील्ड पढ़ें। जब मेटा कार्ड लेआउट बदलता है, तो वर्ग स्ट्रिंग्स का पीछा करने के बजाय उन टेक्स्ट पैटर्नों की फिर से जांच करें।

प्रश्न: मैं विज्ञापनों की पहली स्क्रीन से अधिक कैसे पृष्ठ प्राप्त कर सकता हूँ?
ग्रिड अनंत स्क्रॉल का उपयोग करता है, पृष्ठ नंबर नहीं। पृष्ठ को स्क्रॉल करें, नए कार्ड के लिए प्रतीक्षा करें, DOM को फिर से पढ़ें, और तब तक दोहराएं जब तक Library ID: की गिनती बढ़ने बंद न हो जाए - एक बार में यह छह स्क्रॉल के दौरान 27 कार्ड से 104 तक पहुंच गया।

प्रश्न: मैं कितनी खोजों को समानांतर में चला सकता हूँ?
संविधान को मध्यम रखें - प्रति होस्ट लगभग तीन सत्र एक उचित सीमा है - ताकि आप सौम्य अनुरोध दरों के भीतर रह सकें। क्लाउड-ब्राउज़र सत्र HTTP अनुरोधों से भारी होते हैं, इसलिए उन्हें एक स्थैतिक फ़ेच की तुलना में अधिक कसकर सीमित करें।

प्रश्न: क्या मैं बिना एआई एजेंट के ऐसा कर सकता हूँ?
हाँ। ऊपर दिया गया पायथन और SDK प्रवाह अपने आप में अंत से अंत तक चलता है। एक एजेंट एक सुविधा परत है; रेंडर → खोजें → निकालें → स्क्रॉल लूप सीधे कोड है जिसे आप सीधे शेड्यूल कर सकते हैं।