Python और ... के साथ Amazon Best Sellers को Scrape करने के 4 तरीकों का मेरा परीक्षण

पिछले वीकेंड मैंने कॉफी का पूरा एक पॉट खत्म कर दिया, क्योंकि मैं Amazon के Best Sellers पेज को चार अलग-अलग तरीकों से scrape कर रहा था। दो तरीके बढ़िया चले, एक में मेरा IP बैन होने ही वाला था, और एक में सिर्फ दो क्लिक लगे। जो कुछ भी मैंने सीखा, सब यहाँ है।

Amazon एक बहुत बड़ा marketplace है — , , और एक Best Sellers Rank (BSR) सिस्टम जो हर घंटे अपडेट होता है। अगर आप FBA product research, competitive pricing analysis, या सिर्फ competitors से पहले trends पकड़ना चाहते हैं, तो Best Seller data सोने जैसा कीमती है।

लेकिन उस data को Amazon से निकालकर spreadsheet में लाना? यहीं चीजें दिलचस्प हो जाती हैं। मैंने requests + BeautifulSoup, Selenium, एक scraping API, और (हमारा अपना no-code AI web scraper) आज़माया, ताकि पता चल सके कि असल में कौन-सा तरीका काम करता है — और कौन-सा आपको CAPTCHA पेज पर अटका छोड़ देगा।

Amazon Best Sellers क्या हैं (और आपको इनकी परवाह क्यों करनी चाहिए)?

Amazon Best Sellers Rank (BSR) Amazon का real-time leaderboard है, जो हर category के भीतर products को उनकी बिक्री मात्रा के आधार पर रैंक करता है। इसे popularity contest की तरह समझिए, जो हाल की और पुरानी दोनों sales data के आधार पर हर घंटे अपडेट होता है। Amazon इसे खुद इस तरह परिभाषित करता है:

"The Amazon Best Sellers calculation is based on Amazon sales and is updated hourly to reflect recent and historical sales of every item sold on Amazon." —

Best Sellers पेज हर category में top 100 products दिखाता है, जो दो pages में 50-50 के रूप में बंटा होता है। Page 1 पर ranks #1–50 होते हैं, और Page 2 पर #51–100। Amazon ने यह पुष्टि की है कि page views और customer reviews BSR को प्रभावित नहीं करते — यह पूरी तरह sales-driven है।

इस data की ज़रूरत किसे पड़ती है? E-commerce sellers को, जो FBA के लिए products खोज रहे होते हैं; sales teams को, जो competitive intelligence बना रहे होते हैं; operations teams को, जो pricing trends पर नज़र रखते हैं; और market researchers को, जो category growth track करते हैं। मेरे अनुभव में, जो भी Amazon पर बेच रहा है या उससे competition कर रहा है, उसे अंततः यह data spreadsheet में चाहिए ही होता है।

Python के साथ Amazon Best Sellers को Scrape क्यों करें?

Manual product research समय की बर्बादी है। एक के अनुसार employees हफ्ते में 9.3 घंटे सिर्फ जानकारी ढूँढने और इकट्ठा करने में खर्च करते हैं। E-commerce teams के लिए इसका मतलब है Amazon pages पर क्लिक करते रहना, product names और prices copy करना, और फिर उन्हें spreadsheets में paste करना — और अगले हफ्ते यही सब दोबारा करना।

यहाँ एक quick look है उन use cases पर, जिनकी वजह से Best Sellers scraping वाकई काम का है:

ROI असली है: में 2,700 commerce professionals पाए गए कि AI tools e-commerce professionals को औसतन बचाते हैं। और automated price tracking इस्तेमाल करने वाले sellers Buy Box को अपने पास रखते हैं, जबकि manual trackers के लिए यह 42% है — यानी price changes पर तेज़ प्रतिक्रिया की वजह से 37% sales increase।

Python से Amazon Best Sellers scrape करने के 4 तरीके: एक त्वरित तुलना

Step-by-step tutorials में जाने से पहले, यहाँ वह side-by-side comparison है जो काश testing शुरू करने से पहले मेरे पास होता। यह table आपको अपनी situation के हिसाब से सही method चुनने में मदद करेगा:

अगर आप Python scraping की fundamentals सीखना चाहते हैं, तो Method 1 या 2 से शुरू करें। अगर आपको production-scale reliability चाहिए, तो Method 3 लें। अगर आप बिना code लिखे सिर्फ दो क्लिक में result चाहते हैं, तो सीधे Method 4 पर जाएँ।

शुरू करने से पहले

• Difficulty: Beginner से Intermediate (method पर निर्भर)
• Time Required: Thunderbit के लिए ~15 मिनट, Python methods के लिए ~45 मिनट
• What You'll Need: Python 3.8+ (Methods 1–3 के लिए), Chrome browser, (Method 4 के लिए), और target Amazon Best Sellers category URL

Method 1: requests + BeautifulSoup से Amazon Best Sellers scrape करें

यह हल्का, beginner-friendly तरीका है — browser automation नहीं, सिर्फ HTTP requests और HTML parsing। और इसने मुझे Amazon की anti-scraping defenses के बारे में सबसे ज़्यादा सिखाया।

Step 1: अपना Environment सेट करें

ज़रूरी packages install करें:

1pip install requests beautifulsoup4 pandas

फिर imports सेट करें:

1import requests
2from bs4 import BeautifulSoup
3import pandas as pd
4import random
5import time

Step 2: Realistic Headers के साथ Request भेजें

Amazon उन requests को block कर देता है जो bot जैसी लगती हैं। सबसे basic defense है एक User-Agent header, जो real browser जैसा दिखे। यहाँ current, realistic User-Agent strings का pool है (source: , March 2026):

1USER_AGENTS = [
2    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
3    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:149.0) Gecko/20100101 Firefox/149.0",
5    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15.7; rv:149.0) Gecko/20100101 Firefox/149.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 15_7_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8headers = {"User-Agent": random.choice(USER_AGENTS)}
9url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
10response = requests.get(url, headers=headers)
11print(response.status_code)  # Should be 200

अगर 200 status code दिखे, तो आप अंदर हैं। अगर 503 दिखे या CAPTCHA page पर redirect हो जाएँ, तो Amazon ने आपकी request को flag कर दिया है।

Step 3: BeautifulSoup से Product Data Parse करें

अपने browser के DevTools में Amazon page HTML inspect करें (right-click → Inspect)। Product containers में gridItemRoot ID होती है। इसके अंदर product name, price, rating, और URL मिलते हैं।

1soup = BeautifulSoup(response.text, "html.parser")
2products = []
3for item in soup.find_all("div", id="gridItemRoot"):
4    title_tag = item.find("div", class_="_cDEzb_p13n-sc-css-line-clamp-3_g3dy1")
5    price_tag = item.find("span", class_="_cDEzb_p13n-sc-price_3mJ9Z")
6    link_tag = item.find("a", class_="a-link-normal")
7    title = title_tag.get_text(strip=True) if title_tag else "N/A"
8    price = price_tag.get_text(strip=True) if price_tag else "N/A"
9    url = "https://www.amazon.com" + link_tag["href"] if link_tag else "N/A"
10    products.append({"Title": title, "Price": price, "URL": url})

Warning: _cDEzb_ से शुरू होने वाले class names CSS module hashes होते हैं, जिन्हें Amazon समय-समय पर दोबारा generate करता रहता है। gridItemRoot ID और a-link-normal class ज़्यादा stable हैं, लेकिन scraper चलाने से पहले हमेशा DevTools में selectors verify करें।

Step 4: CSV में Export करें

1df = pd.DataFrame(products)
2df.to_csv("amazon_best_sellers.csv", index=False)
3print(f"Scraped {len(products)} products")

क्या उम्मीद करें — और कहाँ गड़बड़ होती है

मेरे test में यह method लगभग 30 products ही लौटा पाया, 50 नहीं। यह code की bug नहीं है — यह Amazon की lazy loading है। Initial page load पर लगभग 30 products ही render होते हैं; बाकी scroll करने के बाद आते हैं, और इसके लिए JavaScript execution चाहिए, जो requests नहीं कर सकता।

अन्य limitations:

• Proxy rotation के बिना IP bans जल्दी हो जाते हैं (लगभग 15 rapid requests के बाद मुझे block कर दिया गया)
• Amazon जब page layout बदलता है, CSS selectors टूट जाते हैं — और वे यह regular basis पर करते हैं
• Out-of-the-box pagination handling नहीं है

Python scraping सीखने के लिए यह तरीका बढ़िया है। Production use के लिए यह नाज़ुक है।

Method 2: Selenium से Amazon Best Sellers scrape करें

Selenium lazy-loading समस्या को real browser चलाकर हल करता है — setup थोड़ा भारी है, लेकिन यह हर page पर सभी 50 products पकड़ लेता है।

Step 1: Selenium Install करें

1pip install selenium pandas

अच्छी खबर: Selenium 4.6+ के बाद आपको webdriver-manager की ज़रूरत नहीं रहती। Selenium Manager driver downloads को अपने-आप संभालता है।

1from selenium import webdriver
2from selenium.webdriver.chrome.options import Options
3from selenium.webdriver.common.by import By
4from selenium.webdriver.common.keys import Keys
5import time
6import pandas as pd
7options = Options()
8options.add_argument("--headless=new")
9options.add_argument("--window-size=1920,1080")
10options.add_argument("--disable-blink-features=AutomationControlled")
11driver = webdriver.Chrome(options=options)

--headless=new flag (Chrome 109+ में introduced) headed Chrome जैसी ही rendering pipeline इस्तेमाल करता है, जिससे Amazon के लिए इसे detect करना मुश्किल हो जाता है।

Step 2: Lazy Loading के बाद तक Scroll करें

यही वह step है जो Selenium को setup overhead के लायक बनाता है। Amazon Best Sellers शुरुआत में लगभग 30 products ही लोड करता है — बाकी scroll करने पर आते हैं।

1def scroll_page(driver, scrolls=5, delay=2):
2    for _ in range(scrolls):
3        driver.find_element(By.TAG_NAME, "body").send_keys(Keys.PAGE_DOWN)
4        time.sleep(delay)
5driver.get("https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/")
6time.sleep(3)
7scroll_page(driver)

Scrolling के बाद DOM में सभी 50 products render हो जाने चाहिए। मुझे 2-second delay के साथ 5 page-down scrolls पर्याप्त लगे, लेकिन आपकी connection speed के हिसाब से इसे adjust करना पड़ सकता है।

Step 3: Product Data Extract करें

1items = driver.find_elements(By.ID, "gridItemRoot")
2products = []
3for item in items:
4    try:
5        title = item.find_element(By.CSS_SELECTOR, "div._cDEzb_p13n-sc-css-line-clamp-3_g3dy1").text
6    except:
7        title = "N/A"
8    try:
9        price = item.find_element(By.CSS_SELECTOR, "span._cDEzb_p13n-sc-price_3mJ9Z").text
10    except:
11        price = "N/A"
12    try:
13        url = item.find_element(By.CSS_SELECTOR, "a.a-link-normal").get_attribute("href")
14    except:
15        url = "N/A"
16    products.append({"Title": title, "Price": price, "URL": url})

हर extraction को try/except में रखना ज़रूरी है — कुछ products out of stock हो सकते हैं या कुछ fields missing हो सकती हैं, और आप नहीं चाहेंगे कि एक खराब element पूरी scrape process को crash कर दे।

Step 4: Pagination संभालें

Amazon 100 Best Sellers को दो pages में अलग-अलग URL structures के साथ बाँटता है:

1urls = [
2    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/",
3    "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/ref=zg_bs_pg_2_electronics?_encoding=UTF8&pg=2"
4]
5all_products = []
6for url in urls:
7    driver.get(url)
8    time.sleep(3)
9    scroll_page(driver)
10    # ... extract products as above ...
11    all_products.extend(products)
12driver.quit()

क्या उम्मीद करें

मेरे test में Selenium ने हर page पर सभी 50 products capture किए — requests + BS4 पर स्पष्ट जीत। downside यह है कि इसमें लगभग 45 seconds प्रति page लगे (scroll delays सहित), और बिना proxy rotation के इसे कई बार चलाने पर फिर भी flag कर दिया गया। Selenium में anti-detection flags के बावजूद Amazon की bot detection इसे पकड़ सकती है — serious scale के लिए अतिरिक्त उपाय चाहिए (नीचे Anti-Ban Playbook देखें)।

अन्य समस्याएँ:

• WebDriver version mismatches कभी-कभी फिर भी हो जाते हैं, हालांकि Selenium Manager ने इसे बहुत कम कर दिया है
• Amazon अपना DOM बदले तो CSS selectors को अपडेट करना पड़ता है
• Memory usage ज़्यादा है — हर browser instance 200–400MB RAM खा जाता है

Method 3: Scraping API से Amazon Best Sellers scrape करें

Scraping APIs का तरीका है: "कठिन काम किसी और से करवाओ"। Scrape.do, Oxylabs, और ScrapingBee जैसी services proxy rotation, JavaScript rendering, और anti-bot measures संभालती हैं — आपको सिर्फ URL भेजना होता है और HTML या JSON वापस मिल जाता है।

यह कैसे काम करता है

आप अपना target URL API endpoint को भेजते हैं। API अपने infrastructure पर real browser से page render करती है, proxies rotate करती है, CAPTCHAs संभालती है, और साफ HTML वापस देती है। फिर आप उस HTML को usual तरीके से BeautifulSoup से parse करते हैं।

Step 1: API के ज़रिए Request भेजें

यहाँ Scrape.do का example है (pricing $29/month से शुरू होती है, 150,000 credits के लिए; 1 credit = 1 request, rendering हो या नहीं):

1import requests
2from bs4 import BeautifulSoup
3api_token = "YOUR_API_TOKEN"
4target_url = "https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/"
5api_url = f"https://api.scrape.do?token={api_token}&url={target_url}&render=true&geoCode=us"
6response = requests.get(api_url)
7soup = BeautifulSoup(response.text, "html.parser")

इसके बाद parsing Method 1 जैसी ही है — वही selectors, वही extraction logic।

Pricing Reality Check

यहाँ major APIs Amazon requests के लिए प्रति 1,000 requests कितना charge करती हैं, उनका best available rate दिया है:

Pros और Cons

Pros: High reliability ( Amazon पर top providers के लिए), driver maintenance नहीं, anti-bot automatically handle होता है, scale भी अच्छा है।

Cons: प्रति request भुगतान करना पड़ता है (scale पर खर्च बढ़ जाता है), फिर भी parsing code आपको लिखना पड़ता है, और CSS selector changes के लिए फिर भी संवेदनशील है। 100,000 pages/month के लिए total cost comparison काफी dramatic है: in-house build लगभग — यानी 71% savings।

Breakeven point आमतौर पर 500K–1M requests/month के बीच होता है। उससे नीचे API से होने वाली time savings, cost से कहीं ज़्यादा होती हैं।

Method 4: Thunderbit से Amazon Best Sellers scrape करें (बिना Python के)

पूरा खुलासा: मैं Thunderbit में काम करता हूँ, इसलिए इस section को उस context के साथ पढ़ें। फिर भी, मैंने सच में चारों methods back-to-back test किए, और data तक पहुँचने की speed में फर्क बहुत साफ था।

एक AI web scraper है, जो Chrome extension के रूप में चलता है। मूल idea यह है: CSS selectors या Python code लिखने के बजाय AI पेज को पढ़ता है और तय करता है कि कौन-सा data निकालना है। Amazon Best Sellers के लिए खास तौर पर Thunderbit में pre-built templates हैं, जो एक click में काम करते हैं।

Step 1: Thunderbit Chrome Extension Install करें

पर जाएँ और "Add to Chrome" पर क्लिक करें। एक free account बनाइए — free tier में इसे test करने के लिए enough credits मिलते हैं।

Step 2: Amazon Best Sellers Page पर जाएँ

Chrome में Amazon Best Sellers की कोई भी category page खोलें। उदाहरण के लिए: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

Step 3: "AI Suggest Fields" पर क्लिक करें

Thunderbit sidebar खोलें और "AI Suggest Fields" पर क्लिक करें। AI page structure का विश्लेषण करके columns सुझाता है: Product Name, Price, Rating, Image URL, Vendor, Product URL, और Rank। मेरे test में इसने लगभग 3 seconds में सभी relevant fields सही पहचान लिए।

आप columns का नाम बदल सकते हैं, हटा सकते हैं, या नए जोड़ सकते हैं। हर field के लिए custom AI prompts भी जोड़ सकते हैं — उदाहरण के लिए, "categorize as Electronics/Apparel/Home" ताकि हर product में category tag जुड़ जाए।

Step 4: "Scrape" पर क्लिक करें

"Scrape" button दबाएँ। Thunderbit page से सभी product data के साथ एक structured table भर देता है। Cloud mode में यह एक साथ up to 50 pages parallel में process कर सकता है, lazy loading और pagination अपने-आप handle करते हुए।

Step 5: Free में Export करें

"Export" पर क्लिक करें और अपनी destination चुनें: Excel, Google Sheets, Airtable, या Notion। हर plan पर exports free हैं — कोई hidden charges नहीं।

पूरी process में मुझे page खोलने से लेकर complete spreadsheet तक पहुँचने में लगभग 90 seconds लगे। तुलना करें: Method 1 में लगभग 20 minutes लगे (lazy loading issue debug करने सहित), Method 2 में लगभग 35 minutes (Selenium setup सहित), और Method 3 में लगभग 15 minutes (API account setup सहित)।

Thunderbit Amazon को बेहतर कैसे संभालता है

क्योंकि AI हर बार पेज को fresh पढ़ता है, यह layout changes के साथ अपने-आप adapt कर लेता है — CSS selectors maintain करने की ज़रूरत नहीं। यह scraping forums की सबसे आम शिकायत को सीधे address करता है: "A basic web scraper won't suffice, you need to add so many 'catches' for element changes." जब Amazon अपना DOM बदलता है (जो नियमित रूप से होता है), आपको कुछ update नहीं करना पड़ता।

Cloud scraping mode proxy rotation, rendering, और anti-bot measures को transparently संभालता है। जो users एक ऐसा solution चाहते हैं जो बस काम करे, उनके लिए यह पूरा anti-ban headache खत्म कर देता है।

Anti-Ban Playbook: Amazon द्वारा Block होने से कैसे बचें

Amazon की bot detection काफी aggressive है। Testing के दौरान मेरा IP temporarily block हुआ, और forum users भी यही बताते हैं: "errors everywhere, amazon even started redirecting me to the homepage." अगर आप Python route (Methods 1–3) चुन रहे हैं, तो यह section बेहद महत्वपूर्ण है।

यहाँ एक layered strategy है, basic से advanced तक:

1. User-Agent Strings Rotate करें

हर बार वही User-Agent भेजना red flag है। Method 1 के code example में दिए गए 5+ strings के pool का इस्तेमाल करें, और हर request पर randomly एक चुनें:

1headers = {"User-Agent": random.choice(USER_AGENTS)}

2. Requests के बीच Random Delays जोड़ें

Fixed delays आसानी से detect हो जाते हैं (pattern बन जाता है)। Random delays ज़्यादा सुरक्षित हैं:

1time.sleep(random.uniform(2, 5))

मुझे लगा कि requests के बीच 2–5 seconds रखने से छोटे batches (50 requests से कम) में मैं radar के नीचे रहा। बड़े runs के लिए इसे 3–7 seconds तक बढ़ा दें।

3. Proxy Rotation इस्तेमाल करें

यही सबसे बड़ा factor है। दिखाते हैं कि residential proxies Amazon पर औसतन ~94% success देती हैं, जबकि datacenter proxies ~59% — यानी 35 percentage point का अंतर। Amazon की detection stack में TLS fingerprinting, behavioral analysis, और per-IP rate limiting शामिल है, इसलिए standard datacenter IPs कुछ ही सेकंड में flag हो जाते हैं।

Residential proxies महँगी होती हैं ($2–$12 per GB, provider पर निर्भर), लेकिन बहुत ज़्यादा reliable भी। Code example:

1proxies = {
2    "http": "http://user:pass@residential-proxy.example.com:8080",
3    "https": "http://user:pass@residential-proxy.example.com:8080"
4}
5response = requests.get(url, headers=headers, proxies=proxies)

4. अपना Browser Fingerprint मज़बूत करें (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# driver init के बाद navigator.webdriver flag हटाएँ
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. Sessions और Cookies मैनेज करें

Requests के बीच cookies persist करने से आपका scraper real user session जैसा लगता है:

1session = requests.Session()
2# Realistic cookies पाने के लिए पहले homepage visit करें
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# फिर अपना target page scrape करें
6response = session.get(target_url, headers=headers)

6. परेशानी बिल्कुल न लें, तो यह छोड़ दें

जो users इनमें से कुछ भी manage नहीं करना चाहते, उनके लिए Thunderbit का cloud scraping proxy rotation, rendering, और anti-bot measures transparently संभालता है। Scraping APIs भी इन concerns में से अधिकतर out of the box handle कर देती हैं। मेरे अनुभव में anti-ban issues debug करने में जितना समय जाता है, कई बार actual scraping code लिखने से भी ज़्यादा — इसलिए "बस काम करे" वाला approach असली ROI देता है।

Subpage Enrichment: ज़्यादा rich data के लिए Product Detail Pages scrape करना

Best Sellers listing page सिर्फ basic info दिखाता है — title, price, rating, rank। लेकिन FBA research के लिए असली value individual product detail pages में होती है। अगर आप सिर्फ listing scrape करते हैं, तो आप यह सब miss कर रहे होते हैं:

वह "Date First Available" field खास तौर पर valuable है — यह बताता है कि product कब से market में है, जो competition analysis का key signal है। और sellers की संख्या तथा Buy Box owner जानना आपको यह assess करने में मदद करता है कि कोई product niche enter करने लायक है या नहीं (अगर Amazon खुद >30% Buy Box share रखता है, तो competition करना बेहद मुश्किल है)।

Python Approach: Product URLs पर Loop करें

Listing page से product URLs इकट्ठा करने के बाद, हर एक पर delay के साथ loop करें:

1for product in products:
2    time.sleep(random.uniform(3, 6))
3    detail_response = session.get(product["URL"], headers={"User-Agent": random.choice(USER_AGENTS)})
4    detail_soup = BeautifulSoup(detail_response.text, "html.parser")
5    # Brand निकालें
6    brand_tag = detail_soup.find("a", id="bylineInfo")
7    product["Brand"] = brand_tag.get_text(strip=True) if brand_tag else "N/A"
8    # Page source या URL से ASIN निकालें
9    # Product details table से Date First Available निकालें
10    # ... अतिरिक्त fields ...

ध्यान रहे: 100 individual product pages hit करने से ban risk काफी बढ़ जाता है। Proxy rotation और लंबे delays के लिए budget रखें।

Thunderbit Approach: One-Click Subpage Scraping

Listing page को table में scrape करने के बाद Thunderbit में "Scrape Subpages" पर क्लिक करें। AI हर product URL पर जाकर table को brand, ASIN, specifications, features जैसी अतिरिक्त columns से अपने-आप enrich कर देता है। कोई extra code, selectors, या setup नहीं। यह खास तौर पर उन e-commerce teams के लिए उपयोगी है जिन्हें sourcing decisions के लिए पूरा picture चाहिए, लेकिन detail-page parser लिखना और maintain करना नहीं चाहते।

Recurring Scrapes Automate करना: समय के साथ Best Sellers को Monitor करें

एक बार का scrape useful है, लेकिन ongoing monitoring वह जगह है जहाँ असली competitive advantage मिलता है। कौन से products ऊपर-नीचे हो रहे हैं, trends जल्दी पकड़ना, और हफ्तों या महीनों में price shifts track करना — यही casual research और data-driven decision-making के बीच का फर्क है।

Python Approach: Cron के साथ Scheduling

Linux/Mac पर आप अपने Python script को cron से schedule कर सकते हैं। रोज़ सुबह 8 बजे scrape के लिए crontab entry:

10 8 * * * /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

हर सोमवार सुबह 9 बजे के weekly scrape के लिए:

10 9 * * 1 /usr/bin/python3 /home/user/amazon_scraper.py >> /home/user/logs/scrape.log 2>&1

Windows पर यही काम करने के लिए Task Scheduler इस्तेमाल करें। Laptop चालू रखे बिना हमेशा-on scheduling के लिए इसे VPS या AWS Lambda पर deploy कर सकते हैं — लेकिन इससे infrastructure complexity बढ़ जाती है।

Failed runs पकड़ने के लिए logging और error notifications जोड़ें। इससे बुरा कुछ नहीं कि दो हफ्ते बाद पता चले आपका scraper silently टूट गया था।

Thunderbit Approach: Scheduled Scraper को आसान भाषा में

Thunderbit का Scheduled Scraper आपको interval natural language में बताने देता है — "every Monday at 9am" या "every day at 8am" लिखिए, और AI schedule समझ लेता है। Scrapes Thunderbit के cloud servers पर चलते हैं (browser या computer चालू रखने की ज़रूरत नहीं), और data अपने-आप Google Sheets या Airtable में export हो जाता है। इससे बिना server management के live monitoring dashboard बन जाता है — operations teams के लिए ideal, जिन्हें DevOps overhead के बिना लगातार visibility चाहिए।

Amazon Scrape करते समय Legal और Ethical बातें

मैं lawyer नहीं हूँ, और यह legal advice नहीं है। लेकिन scraping tutorial में legal landscape को ignore करना गैर-जिम्मेदाराना होगा — forum users भी ToS concerns उठाते हैं, और इसकी वजह भी सही है।

Amazon's robots.txt: 2026 तक Amazon के robots.txt में 80+ specific Disallow paths हैं, लेकिन /gp/bestsellers/ standard user agents के लिए explicitly blocked नहीं है। हालांकि, 35+ AI-specific user agents (ClaudeBot, GPTBot, Scrapy, आदि) को blanket Disallow: / मिलता है। किसी specific disallow का न होना यह नहीं दर्शाता कि Amazon scraping को endorse करता है।

Amazon's Terms of Service: Amazon की (May 2025 में updated) स्पष्ट रूप से लिखती हैं कि बिना लिखित अनुमति के Amazon Website के किसी भी हिस्से को access, acquire, copy, या monitor करने के लिए किसी automated process या technology का उपयोग निषिद्ध है। यह सिर्फ theory नहीं है — Amazon ने November 2025 में unauthorized automated access को लेकर और preliminary injunction जीत ली।

hiQ v. LinkedIn precedent: (Ninth Circuit, 2022) में अदालत ने माना कि publicly available data scraping संभवतः Computer Fraud and Abuse Act का उल्लंघन नहीं करता। लेकिन hiQ अंततः settle हुआ और scraping बंद करने पर सहमत हुआ — CFAA पर जीत, contract breach claims से सुरक्षा नहीं देती।

Practical guidelines:

• सिर्फ publicly available data scrape करें (prices, BSR, product titles — PII नहीं)
• Rate limits का सम्मान करें और servers पर overload न डालें
• Data का उपयोग legitimate competitive intelligence के लिए करें
• Scale पर scraping से पहले अपने legal counsel से सलाह लें
• ध्यान रखें कि में अब comprehensive privacy legislation है

Thunderbit का cloud scraping standard browser-like request patterns का उपयोग करता है, लेकिन compliance हमेशा अपने legal counsel के साथ verify करें।

आपको कौन-सा Method चुनना चाहिए? एक त्वरित निर्णय गाइड

संक्षिप्त version:

• "मैं Python सीख रहा हूँ और weekend project चाहता हूँ." → Method 1 (requests + BeautifulSoup)। इसमें HTTP requests, HTML parsing, और Amazon की anti-bot defenses के बारे में बहुत कुछ सीखेंगे।
• "मुझे JavaScript-heavy pages या logged-in sessions scrape करनी हैं." → Method 2 (Selenium)। यह भारी है, लेकिन dynamic content संभाल लेता है।
• "मैं scale पर production scrapes चला रहा हूँ." → Method 3 (Scraping API)। proxies और rendering किसी और से मैनेज कराएँ। 500K requests/month से नीचे APIs के पक्ष में है।
• "मैं developer नहीं हूँ और 2 मिनट में data चाहिए." → Method 4 ()। कोई code नहीं, कोई selectors नहीं, कोई maintenance नहीं।
• "मुझे server management के बिना ongoing monitoring चाहिए." → Thunderbit Scheduled Scraper। सेट करें और भूल जाएँ।

निष्कर्ष और मुख्य बातें

एक weekend की testing के बाद जो सबसे ज़्यादा साफ़ हुआ, वह यह है:

requests + BeautifulSoup सीखने के लिए बढ़िया है, लेकिन lazy-loading limitation (50 में से सिर्फ ~30 products) और fragile CSS selectors इसे production use के लिए अव्यावहारिक बनाते हैं।

Selenium lazy-loading समस्या हल करता है और हर page पर सभी 50 products पकड़ लेता है, लेकिन यह slow है, बहुत memory खाता है, और फिर भी Amazon की bot defenses से detect हो सकता है।

Scraping APIs production-scale scraping के लिए सबसे भरोसेमंद विकल्प हैं — Amazon पर — लेकिन खर्च बढ़ता जाता है और parsing code फिर भी आपको लिखना पड़ता है।

Thunderbit ने time-to-data के मामले में बहुत आगे रहकर जीत हासिल की। AI layout changes, lazy loading, pagination, और anti-bot measures को बिना किसी configuration के संभाल लेता है। Non-technical users या उन teams के लिए जिन्हें DevOps overhead के बिना recurring data चाहिए, यह सबसे practical option है।

सबसे बड़ी सीख? Amazon की anti-bot defenses और frequent layout changes का मतलब है कि long run में maintenance-free solutions सबसे ज़्यादा समय बचाते हैं। Broken selectors और rotating proxies debug करने में जो हर घंटा जाता है, वह actual analysis से छिन जाता है।

No-code approach आज़माना चाहते हैं? आपको कुछ Best Sellers categories scrape करने के लिए पर्याप्त credits देता है, ताकि आप खुद result देख सकें। Python route पसंद है? ऊपर दिए गए code examples आपको शुरू करने में मदद करेंगे। किसी भी हालत में, Amazon Best Seller data browser tab पर घूरने के बजाय आपके spreadsheet में होगा।

Web scraping approaches के बारे में और जानने के लिए हमारे guides देखें: , , और । आप पर step-by-step walkthroughs भी देख सकते हैं।

और जानें