איך אני מגרד ביקורות מאמזון עם Python (גם מעבר לקיר ההתחברות)

הסקרייפר שלי לביקורות מאמזון עבד מצוין במשך שישה שבועות — ואז בוקר אחד הוא החזיר 200 OK ודף ריק לגמרי. בלי שגיאה, בלי CAPTCHA, רק HTML ריק במקום מאות ביקורות שהיו שם קודם.

אם זה נשמע מוכר, אתם לא לבד. בסוף 2025 אמזון התחילה לחסום את דפי הביקורות המלאים מאחורי קיר התחברות, ומספר עצום של סקריפטים ב־Python נשברו בן לילה. בחודשים האחרונים עבדתי ב- על הבעיה משני הכיוונים — גם בניית ה־AI scraper שלנו וגם תחזוקת צינור הביקורות הפרטי שלי ב־Python — אז החלטתי לכתוב את המדריך שהייתי רוצה שיהיה לי כשהסקריפט שלי הפסיק לעבוד. הפוסט הזה מכסה את הגישה שעובדת: אימות מבוסס קובצי Cookie, סלקטורים יציבים ששורדים את הטשטוש של ה־CSS באמזון, דרכים לעקוף את מגבלת 10 הדפים, התמודדות עם מנגנוני אנטי־בוט, ובונוס של ניתוח סנטימנט שהופך טקסט גולמי של ביקורות לתובנות עסקיות אמיתיות. ואם תגיעו באמצע ותחשבו, "אני מעדיף לא לתחזק את כל הקוד הזה," אראה לכם איך עושה את אותה עבודה בכשתי דקות, בלי Python בכלל.

מה זה גירוד ביקורות מאמזון ולמה זה חשוב?

גירוד ביקורות מאמזון הוא תהליך של חילוץ אוטומטי של נתוני ביקורות לקוחות — דירוג כוכבים, טקסט הביקורת, שמות המחברים, תאריכים, תגיות של רכישה מאומתת — מדפי מוצרים של אמזון. מכיוון שאמזון (ולא החזירה אותו מאז), Web Scraping הוא הנתיב האוטומטי היחיד לנתונים האלה.

המספרים מגבים את זה. , ו-. הצגת רק 5 ביקורות בעמוד מוצר יכולה . חברות שמנתחות באופן שיטתי את סנטימנט הביקורות רואות . זה לא מדע נתונים מופשט — זה מודיעין תחרותי, אותות לשיפור מוצר, ושפה שיווקית, הכול כתוב בטקסט גלוי על השרתים של אמזון.

למה לגרד ביקורות מאמזון עם Python

Python נשארת השפה המובילה לעבודה הזו. היא , והאקוסיסטם שלה — requests, BeautifulSoup, pandas, Scrapy — הופך Web Scraping לנגיש גם לאנשים שאינם מפתחים במשרה מלאה.

צוותים שונים משתמשים בנתונים האלה בדרכים שונות:

מותג כלי מטבח אחד , ניסח מחדש את המוצר, והחזיר לעצמו את המקום הראשון ברשימת ה־Best Seller בתוך 60 יום. חברת צמידי כושר , איתרה בעיית אלרגיה ללטקס, השיקה גרסה היפואלרגנית, והפחיתה החזרות ב־40%. זה בדיוק סוג ה־ROI שהופך את ההשקעה ההנדסית לכדאית.

קיר ההתחברות: למה הסקרייפר שלכם לביקורות אמזון הפסיק לעבוד

ב־14 בנובמבר 2024, . השינוי אושר גם ב- וגם ב-. אם תיכנסו ל־/product-reviews/{ASIN}/ בחלון אינקוגניטו, תועברו לדף התחברות במקום לנתוני הביקורות.

התסמינים עדינים: הסקריפט שלכם מקבל תשובת 200 OK, אבל גוף ה־HTML מכיל טופס התחברות (name="email", id="ap_password") במקום ביקורות. בלי קוד שגיאה. בלי CAPTCHA. פשוט... כלום שימושי.

אמזון עשתה את זה מסיבות של אנטי־בוט וציות אזורי. האכיפה לא עקבית — לפעמים חלון דפדפן חדש טוען כמה ביקורות לפני שהקיר נכנס לפעולה, במיוחד בעמוד הראשון — אבל לכל סקרייפר שרץ בקנה מידה, כדאי להניח שהקיר תמיד פעיל.

דומייני אמזון שונים לפי מדינה (.de, .co.uk, .co.jp) אוכפים את הקיר בנפרד. כפי שניסח זאת משתמש בפורום: "צריך התחברות נפרדת לכל מדינה." קובצי ה־Cookie של .com לא יעבדו ב־.co.uk.

ביקורות מוצגות מול ביקורות מלאות: למה עדיין אפשר לגשת בלי התחברות

דפי מוצר של אמזון (/dp/{ASIN}/) עדיין מציגים בערך בלי אימות. אלה ביקורות שנבחרו ידנית על ידי האלגוריתם של אמזון, והן שימושיות לבדיקה מהירה של סנטימנט, אבל אי אפשר למיין אותן, לסנן אותן או לדפדף בהן.

דפי הביקורות המלאים (/product-reviews/{ASIN}/) — עם מיון לפי חדש, סינון לפי דירוג כוכבים, ודפדוף בין מאות ביקורות — דורשים התחברות.

אם אתם צריכים רק כמה ביקורות לבדיקה מהירה, גרדו את דף המוצר. אם אתם צריכים מאות או אלפים, תצטרכו לטפל באימות.

מה צריך לפני שמתחילים: הגדרת Python והספריות

לפני שנכתוב קוד, הנה ההגדרה:

• רמת קושי: בינונית (נוחות עם Python, היכרות בסיסית עם HTML)
• זמן נדרש: כ־45 דקות לצינור המלא; כ־10 דקות לגרידה בסיסית
• מה צריך: Python 3.8+, דפדפן Chrome, חשבון Amazon תקף

התקינו את הספריות המרכזיות:

1pip install requests beautifulsoup4 lxml pandas textblob

אופציונלי (לניתוח סנטימנט מתקדם):

1pip install transformers torch

מה זה ASIN? זהו מזהה המוצר בן 10 התווים של אמזון. תמצאו אותו בכל כתובת מוצר — למשל, ב־amazon.com/dp/B0BCNKKZ91, ה־ASIN הוא B0BCNKKZ91. זה המפתח שתכניסו לכתובת הביקורות.

שלב 1: לעבור את קיר ההתחברות עם אימות מבוסס Cookie

הגישה הכי אמינה היא להתחבר לאמזון בדפדפן, להעתיק את קובצי ה־Cookie של הסשן, ולהזריק אותם ל־requests.Session() של Python. כך נמנעים מ־CAPTCHA ו־SMS 2FA שמכשילים אוטומציה של התחברות עם Selenium.

צריך את שבעת ה־cookies האלה:

איך מחלצים Cookies מ־Chrome DevTools

1. התחברו ל־amazon.com ב־Chrome
2. פתחו DevTools (F12 או קליק ימני → Inspect)
3. עברו ל־Application → Storage → Cookies → https://www.amazon.com
4. מצאו כל שם cookie בטבלה והעתיקו את הערך שלו
5. עצבו אותם כמחרוזת מופרדת בנקודה־פסיק עבור Python

כך מגדירים את הסשן:

1import requests
2session = requests.Session()
3# הדביקו כאן את ערכי ה-cookie שלכם
4cookies = {
5    "session-id": "YOUR_SESSION_ID",
6    "session-id-time": "YOUR_SESSION_ID_TIME",
7    "session-token": "YOUR_SESSION_TOKEN",
8    "ubid-main": "YOUR_UBID_MAIN",
9    "at-main": "YOUR_AT_MAIN",
10    "sess-at-main": "YOUR_SESS_AT_MAIN",
11    "x-main": "YOUR_X_MAIN",
12}
13headers = {
14    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
15    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
16    "Accept-Language": "en-US,en;q=0.5",
17}
18session.cookies.update(cookies)
19session.headers.update(headers)

חשוב: השתמשו באותו אובייקט session בכל הבקשות. זה שומר על עקביות ה־cookies ומדמה סשן דפדפן אמיתי. קובצי Cookie בדרך כלל מחזיקים ימים עד שבועות תחת עומס scraping, אבל אם מתחילים שוב לקבל הפניות לדף התחברות, רעננו אותם מהדפדפן.

לשווקים שאינם .com, שמות ה־cookies משתנים מעט — למשל amazon.de משתמש ב־at-acbde במקום at-main, amazon.co.uk משתמש ב־at-acbuk, וכן הלאה. כל marketplace צריך סשן עצמאי משלו.

שלב 2: לבנות את הבקשה ולנתח את HTML הביקורות עם BeautifulSoup

כתובת הביקורות של אמזון נראית כך:

1https://www.amazon.com/product-reviews/{ASIN}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1

הפונקציה המרכזית:

1from bs4 import BeautifulSoup
2import time, random
3def get_soup(session, url):
4    time.sleep(random.uniform(2, 5))  # השהיה מנומסת
5    response = session.get(url, timeout=15)
6    # זיהוי קיר התחברות
7    if "ap_email" in response.text or "Amazon Sign-In" in response.text:
8        raise Exception("זוהה קיר התחברות — רעננו את ה-cookies שלכם")
9    if response.status_code != 200:
10        raise Exception(f"HTTP {response.status_code}")
11    return BeautifulSoup(response.text, "lxml")

טריק קטן שעוזר: לפני שניגשים לעמוד הביקורות, בקרו קודם בדף המוצר. זה יוצר דפוס גלישה טבעי יותר בסשן שלכם.

1# ביקור בדף המוצר קודם (מדמה גלישה אמיתית)
2product_url = f"https://www.amazon.com/dp/{asin}"
3session.get(product_url, timeout=15)
4time.sleep(random.uniform(1, 3))
5# ואז מעבר לדף הביקורות
6reviews_url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber=1"
7soup = get_soup(session, reviews_url)

שלב 3: להשתמש בסלקטורים יציבים כדי לחלץ נתוני ביקורות (להפסיק להסתמך על מחלקות CSS)

כאן רוב המדריכים מ־2022–2023 נופלים. אמזון מטשטשת שמות מחלקות CSS — הם משתנים מעת לעת, וכפי שמפתח מתוסכל ניסח זאת בשרשור בפורום: "לאף אחד מהם לא היה אפילו דפוס אחד בשמות המחלקות של תגיות ה־span."

הפתרון: אמזון משתמשת במאפייני data-hook על רכיבי הביקורות, והם יציבים להפליא. אלה מזהים סמנטיים שעליהם הקוד של ממשק אמזון עצמו נשען, ולכן לא עושים להם רנדומיזציה.

קוד החילוץ עם סלקטורים של data-hook:

1import re
2def extract_reviews(soup):
3    reviews = []
4    review_divs = soup.select('[data-hook="review"]')
5    for div in review_divs:
6        # דירוג כוכבים
7        rating_el = div.select_one('[data-hook="review-star-rating"]')
8        rating = None
9        if rating_el:
10            rating_text = rating_el.get_text(strip=True)
11            match = re.search(r'(\d\.?\d?)', rating_text)
12            if match:
13                rating = float(match.group(1))
14        # כותרת
15        title_el = div.select_one('[data-hook="review-title"]')
16        title = title_el.get_text(strip=True) if title_el else ""
17        # גוף הביקורת
18        body_el = div.select_one('[data-hook="review-body"]')
19        body = body_el.get_text(strip=True) if body_el else ""
20        # מחבר
21        author_el = div.select_one('span.a-profile-name')
22        author = author_el.get_text(strip=True) if author_el else ""
23        # תאריך ומדינה
24        date_el = div.select_one('[data-hook="review-date"]')
25        date_text = date_el.get_text(strip=True) if date_el else ""
26        # פורמט: "Reviewed in the United States on January 15, 2025"
27        country_match = re.search(r'Reviewed in (.+?) on', date_text)
28        date_match = re.search(r'on (.+)$', date_text)
29        country = country_match.group(1) if country_match else ""
30        date = date_match.group(1) if date_match else ""
31        # רכישה מאומתת
32        verified_el = div.select_one('[data-hook="avp-badge"]')
33        verified = bool(verified_el)
34        reviews.append({
35            "author": author,
36            "rating": rating,
37            "title": title,
38            "content": body,
39            "date": date,
40            "country": country,
41            "verified": verified,
42        })
43    return reviews

אני מריץ את קבוצת הסלקטורים הזו מול כמה ASINים כבר חודשים, ומאפייני data-hook לא השתנו אפילו פעם אחת. לעומת זאת, מחלקות ה־CSS השתנו לפחות פעמיים באותה תקופה.

שלב 4: לטפל בפגינציה ובמגבלת 10 הדפים של אמזון

אמזון מגבילה את הפרמטר pageNumber ל־10 דפים של 10 ביקורות כל אחד — תקרה קשיחה של כ־100 ביקורות לכל שילוב פילטרים. כפתור "Next page" פשוט נעלם אחרי דף 10.

לולאת פגינציה בסיסית:

1all_reviews = []
2for page in range(1, 11):
3    url = f"https://www.amazon.com/product-reviews/{asin}/ref=cm_cr_arp_d_viewopt_srt?sortBy=recent&pageNumber={page}"
4    soup = get_soup(session, url)
5    page_reviews = extract_reviews(soup)
6    if not page_reviews:
7        break  # אין עוד ביקורות בעמוד הזה
8    all_reviews.extend(page_reviews)
9    print(f"Page {page}: {len(page_reviews)} reviews")

איך לקבל יותר מ־10 דפי ביקורות מאמזון

הפתרון הוא חלוקת ביקורות לפי פילטרים. כל שילוב של filterByStar ו־sortBy מקבל חלון עצמאי משלו של 10 דפים.

ערכי פילטר כוכבים: one_star, two_star, three_star, four_star, five_star
ערכי מיון: recent, helpful (ברירת מחדל)

על ידי שילוב של 5 פילטרי כוכבים × 2 סדרי מיון, אפשר להגיע עד 100 דפים, כלומר 1,000 ביקורות למוצר — ובמוצרים עם התפלגות כוכבים לא אחידה, לרוב תגיעו קרוב מאוד לכל מערך הביקורות.

1star_filters = ["one_star", "two_star", "three_star", "four_star", "five_star"]
2sort_orders = ["recent", "helpful"]
3all_reviews = []
4seen_titles = set()  # מניעת כפילויות בסיסית
5for star in star_filters:
6    for sort in sort_orders:
7        for page in range(1, 11):
8            url = (
9                f"https://www.amazon.com/product-reviews/{asin}"
10                f"?filterByStar={star}&sortBy={sort}&pageNumber={page}"
11            )
12            soup = get_soup(session, url)
13            page_reviews = extract_reviews(soup)
14            if not page_reviews:
15                break
16            for review in page_reviews:
17                # הסרת כפילויות לפי צירוף כותרת + מחבר
18                key = (review["title"], review["author"])
19                if key not in seen_titles:
20                    seen_titles.add(key)
21                    all_reviews.append(review)
22            print(f"[{star}/{sort}] Page {page}: {len(page_reviews)} reviews")
23print(f"Total unique reviews: {len(all_reviews)}")

יהיו חפיפות בין ה-buckets, ולכן הסרת כפילויות היא חיונית. אני משתמש בצירוף של כותרת הביקורת + שם המחבר כמפתח מהיר — לא מושלם, אבל הוא תופס את רוב הכפילויות.

שלב 5: להתחמק ממנגנוני אנטי־בוט (סיבוב, הגבלה, ניסיונות חוזרים)

אמזון משתמשת ב־AWS WAF Bot Control, והוא הפך אגרסיבי משמעותית. אמצעים חד־שכבתיים (רק החלפת User-Agent, רק הוספת השהיות) כבר לא מספיקים.

עטיפת retry מוכנה לפרודקשן:

1import time, random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/147.0.0.0 Safari/537.36",
4    "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",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; 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    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
8]
9def scrape_with_retries(session, url, max_retries=3):
10    for attempt in range(max_retries):
11        try:
12            session.headers["User-Agent"] = random.choice(USER_AGENTS)
13            time.sleep(random.uniform(2, 5))
14            response = session.get(url, timeout=15)
15            # זיהוי חסימות
16            if "validateCaptcha" in response.url or "Robot Check" in response.text:
17                wait = (2 ** attempt) * 5
18                print(f"זוהה CAPTCHA. ממתין {wait} שניות...")
19                time.sleep(wait)
20                continue
21            if response.status_code in (429, 503):
22                wait = (2 ** attempt) * 2
23                print(f"הוגבלה התנועה ({response.status_code}). ממתין {wait} שניות...")
24                time.sleep(wait)
25                continue
26            if "ap_email" in response.text:
27                raise Exception("קיר התחברות — ה-cookies פגו")
28            return BeautifulSoup(response.text, "lxml")
29        except Exception as e:
30            if attempt == max_retries - 1:
31                raise
32            print(f"ניסיון {attempt + 1} נכשל: {e}")
33    return None

הערה על פרוקסים: אמזון (AWS, GCP, Azure, DigitalOcean) ברמת הרשת. אם אתם מגרדים יותר מכמה מאות עמודים, פרוקסי residential הם כמעט חובה — צפו להוצאה של 50–200 דולר בחודש ומעלה, תלוי בנפח. לפרויקטים קטנים יותר (מתחת ל־100 בקשות ביום), הגבלה זהירה מה־IP הביתי שלכם עובדת לרוב מצוין.

אמזון גם בודקת טביעות TLS. ל־requests הסטנדרטי של Python יש . לסקרייפרים בפרודקשן, כדאי לשקול curl_cffi, שמתחזה לסטאק TLS אמיתי של דפדפן. לגרידה ברמת מדריך (כמה מאות עמודים), requests עם כותרות טובות בדרך כלל עושה את העבודה.

שלב 6: לייצא את ביקורות אמזון שגרדתם ל־CSV או Excel

אחרי שאספתם את הביקורות, פשוט להפוך אותן לפורמט שימושי עם pandas:

1import pandas as pd
2df = pd.DataFrame(all_reviews)
3df.to_csv("amazon_reviews.csv", index=False)
4print(f"Exported {len(df)} reviews to amazon_reviews.csv")

פלט לדוגמה:

לייצוא ל־Excel: df.to_excel("amazon_reviews.xlsx", index=False) (דורש openpyxl).

ל־Google Sheets, הספרייה gspread עובדת אבל דורשת — יצירת פרויקט, הפעלת שני APIs, יצירת credentials של service account, שיתוף הגיליון. אם זה נשמע כמו יותר הגדרה מאשר הגרידה עצמה, אתם לא טועים. (זה אחד הרגעים שבהם כלי כמו שמייצא ל־Google Sheets בלחיצה אחת מתחיל להיראות מאוד מפתה.)

בונוס: להוסיף ניתוח סנטימנט לביקורות שגרדתם ב־5 שורות Python

רוב המדריכים על scraping עוצרים בייצוא ל־CSV. אבל דירוג סנטימנט הוא מה שהופך נתונים גולמיים להחלטות עסקיות.

הבסיס המהיר ביותר משתמש ב־TextBlob:

1from textblob import TextBlob
2df["sentiment"] = df["content"].apply(lambda x: TextBlob(str(x)).sentiment.polarity)

זה נותן לכל ביקורת ציון פולריות מ־-1.0 (שלילי מאוד) עד +1.0 (חיובי מאוד). פלט לדוגמה:

השורות המעניינות הן חוסר ההתאמה — ביקורת של 3 כוכבים עם טקסט חיובי, או ביקורת של 5 כוכבים עם שפה שלילית. הפערים האלה לרוב חושפים דעות לקוחות מעודנות שדירוג כוכבים לבדו מפספס.

לדיוק ברמת פרודקשן, ההמלצה היא Hugging Face Transformers. , ו- בהשוואה לכלים לקסיקליים. המודל nlptown/bert-base-multilingual-uncased-sentiment אפילו מנבא ישירות דירוג של 1–5 כוכבים:

1from transformers import pipeline
2clf = pipeline("sentiment-analysis",
3               model="nlptown/bert-base-multilingual-uncased-sentiment")
4df["predicted_stars"] = df["content"].apply(
5    lambda x: int(clf(str(x)[:512])[0]["label"][0])
6)

ביקורות אמזון נוטות להתפלגות — קפיצה גדולה ב־5 כוכבים, קפיצה קטנה יותר ב־1 כוכב, ושקע באמצע. זה אומר שהממוצע של דירוג הכוכבים הוא לעיתים קרובות פרוקסי חלש לאיכות האמיתית של המוצר. עדיף לבודד את אשכול ה־1 כוכב ולכרות ממנו נושאים חוזרים — שם בדרך כלל מסתתר פגם יחיד שאפשר לתקן.

הפשרה הכנה: Python DIY מול APIs בתשלום מול Thunderbit

ניהלתי סקרייפרים ב־Python לאמזון, ואני אהיה כנה: הם נשברים. סלקטורים משתנים, cookies פגים, אמזון משיקה שכבת זיהוי בוטים חדשה, ופתאום שבת בבוקר שלכם הופכת לניפוי באגים במקום לניתוח נתונים. משתמשים בפורומים מדווחים על אותה תסכול — סקריפטים DIY ש"עבדו בחודש שעבר" עכשיו דורשים תיקונים בלי סוף.

כך נראית ההשוואה בין שלוש הגישות המרכזיות:

Python נותנת לכם שליטה מלאה והיא באמת הדרך הטובה ביותר להבין איך Web Scraping עובד מתחת למכסה המנוע. אבל אם הצורך שלכם הוא "אני צריך נתוני ביקורות של מתחרים בגיליון עד יום שישי" ולא "אני רוצה לבנות צינור נתונים בייצור", ייתכן שהנטל של תחזוקת סקרייפר מותאם אישית פשוט לא שווה את זה.

מטפל באימות, בסלקטורים, בפגינציה ובייצוא בלחיצות — נסו את וראו אם זה מתאים לזרימת העבודה שלכם. ככל שאמזון ממשיכה להדק את אמצעי האנטי־בוט, כלים מבוססי AI שמסתגלים בזמן אמת יהפכו פחות ל"nice to have" ויותר לצורך הכרחי.

אפשר גם לעבור על לקבלת walkthroughs וידאו של תהליכי scraping.

שאלות נפוצות

1. אפשר לגרד ביקורות מאמזון בלי להתחבר?

כן, אבל רק כ־8 "ביקורות מובילות" שמוצגות בדף פרטי המוצר (/dp/{ASIN}/). דפי הביקורות המלאים, עם מיון, סינון ודפדוף, דורשים אימות החל מסוף 2024. ברוב מקרי השימוש העסקיים תצטרכו לטפל בקיר ההתחברות.

2. האם זה חוקי לגרד ביקורות מאמזון?

תנאי השימוש של אמזון אוסרים scraping אוטומטי. עם זאת, פסיקות עדכניות בארה״ב (Meta v. Bright Data, 2024; hiQ v. LinkedIn) תומכות בגירוד של נתונים הנגישים לציבור. גירוד מאחורי התחברות כרוך בסיכון משפטי גבוה יותר, כי הסכמתם לתנאי השימוש של אמזון בעת יצירת החשבון. כדאי להיוועץ בעו״ד לשימוש מסחרי.

3. כמה ביקורות מאמזון אפשר לגרד לכל מוצר?

אמזון מגבילה את דפי הביקורות ל־10 לכל שילוב של מיון ופילטר כוכבים. בשימוש בכל 5 פילטרי הכוכבים × 2 סדרי מיון, אפשר להגיע עד 100 דפים (בערך 1,000 ביקורות) לכל מוצר. עם פילטרי מילות מפתח, התקרה התאורטית גבוהה בהרבה, אם כי עם הרבה כפילויות.

4. מהי ספריית Python הכי טובה לגרידת ביקורות מאמזון?

requests + BeautifulSoup לניתוח HTML סטטי הוא השילוב הנפוץ והאמין ביותר. Selenium שימושי כשצריך רינדור JavaScript. לחלופה ללא קוד שמטפלת אוטומטית בקיר ההתחברות ובפגינציה, נסו את .

5. איך נמנעים מחסימה כשמגרדים מאמזון?

החליפו מחרוזות User-Agent מתוך מאגר של 10+ מחרוזות אמיתיות של דפדפנים, הוסיפו השהיות אקראיות של 2–5 שניות בין בקשות, יישמו backoff אקספוננציאלי על שגיאות 503/429, השתמשו בפרוקסי residential בקנה מידה (IP של דטה־סנטר נחסמים מראש), ושמרו על cookies עקביים בין הבקשות. לגישה בלי תחזוקה, Thunderbit מטפל במנגנוני האנטי־בוט אוטומטית דרך סשן הדפדפן שלכם.

למידע נוסף