בדקתי 4 דרכים לגרד את Amazon Best Sellers עם Python ו־...

בסוף השבוע האחרון שרפתי סיר קפה שלם בניסיון לגרד את דף ה־Best Sellers של Amazon בארבע דרכים שונות. שתיים עבדו מצוין, אחת כמעט גרמה לחסימת ה־IP שלי, ואחת דרשה פשוט שתי לחיצות. הנה כל מה שלמדתי.

Amazon היא מפלצת של שוק מקוון — , , ומערכת Best Sellers Rank (BSR) שמתעדכנת בכל שעה. אם אתם עושים מחקר מוצרים ל־FBA, ניתוח תמחור תחרותי, או פשוט מנסים לזהות מגמות לפני המתחרים, נתוני Best Seller הם זהב טהור.

אבל להוציא את הנתונים האלה מ־Amazon ולהכניס אותם לגיליון נתונים? כאן העניינים נעשים מעניינים. בדקתי requests + BeautifulSoup, Selenium, API לגרידה, ו־ (ה־AI web scraper שלנו ללא קוד) כדי לראות איזו גישה באמת מספקת תוצאות — ואילו גישות ישאירו אתכם מול עמוד CAPTCHA.

מה זה Amazon Best Sellers ולמה זה חשוב לכם?

Amazon Best Sellers Rank (BSR) הוא טבלת הדירוג בזמן אמת של Amazon, שמדרגת מוצרים לפי נפח מכירות בכל קטגוריה. אפשר לחשוב על זה כעל תחרות פופולריות שמתעדכנת מדי שעה, על סמך נתוני מכירות עדכניים והיסטוריים גם יחד. 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 מציג את 100 המוצרים המובילים בכל קטגוריה, מחולקים לשני עמודים של 50 פריטים כל אחד. עמוד 1 כולל את הדירוגים #1–50, ועמוד 2 את #51–100. Amazon אישרה שמספר צפיות וסקירות לקוחות אינם משפיעים על BSR — זה מבוסס אך ורק על מכירות.

למי הנתונים האלה חשובים? מוכרי e-commerce שמחפשים מוצרים ל־FBA, צוותי מכירות שבונים מודיעין תחרותי, צוותי תפעול שעוקבים אחרי מגמות תמחור, וחוקרי שוק שמנטרים צמיחה בקטגוריות. מניסיוני, כל מי שמוכר ב־Amazon או מתחרה בו, בסוף צריך את הנתונים האלה בגיליון נתונים.

למה לגרד את Amazon Best Sellers עם Python?

מחקר מוצרים ידני הוא בור זמן. מחקר של מצא שעובדים מבזבזים 9.3 שעות בשבוע רק על חיפוש ואיסוף מידע. עבור צוותי e-commerce, זה מתורגם לשעות של לחיצה בין דפי Amazon, העתקת שמות מוצרים ומחירים, והדבקה לתוך גיליונות — רק כדי לחזור על כל התהליך בשבוע הבא.

הנה מבט מהיר על מקרי השימוש שהופכים גרידת Best Sellers לכדאית:

ה־ROI אמיתי: סקר של בקרב 2,700 אנשי מסחר מצא שכלי AI חוסכים לאנשי e-commerce בממוצע . ומוכרים שמשתמשים במעקב מחירים אוטומטי מחזיקים ב־Buy Box לעומת 42% בלבד אצל מעקב ידני — עלייה של 37% במכירות הודות לתגובה מהירה יותר לשינויי מחיר.

4 דרכים לגרד את Amazon Best Sellers עם Python: השוואה מהירה

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

אם אתם רוצים ללמוד את יסודות הגרידה עם Python, התחילו בשיטה 1 או 2. אם אתם צריכים אמינות ברמת production, לכו על שיטה 3. אם אתם רוצים תוצאות בשתי לחיצות בלי לכתוב קוד, קפצו ישר לשיטה 4.

לפני שמתחילים

• רמת קושי: מתחילים עד בינוניים (תלוי בשיטה)
• זמן נדרש: כ־15 דקות ל־Thunderbit, כ־45 דקות לשיטות Python
• מה צריך: Python 3.8+ (לשיטות 1–3), דפדפן Chrome, (לשיטה 4), וכתובת URL של קטגוריית Amazon Best Sellers היעד

שיטה 1: גרידת Amazon Best Sellers עם requests + BeautifulSoup

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

שלב 1: הגדרת הסביבה

התקינו את החבילות הנדרשות:

1pip install requests beautifulsoup4 pandas

ואז הגדירו את הייבוא:

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

שלב 2: שליחת בקשה עם headers מציאותיים

Amazon חוסמת בקשות שנראות כמו בוטים. ההגנה הבסיסית ביותר היא כותרת User-Agent שמדמה דפדפן אמיתי. הנה קטע קוד עם מאגר של מחרוזות User-Agent עדכניות וריאליסטיות (מבוסס על , מרץ 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)  # אמור להיות 200

אם קיבלתם קוד 200, אתם בפנים. אם אתם רואים 503 או מופנים לעמוד CAPTCHA, Amazon סימנה את הבקשה שלכם.

שלב 3: ניתוח נתוני המוצרים עם BeautifulSoup

בדקו את ה־HTML של עמוד Amazon בעזרת DevTools בדפדפן (קליק ימני → Inspect). מכולות המוצרים משתמשות ב־ID gridItemRoot. בתוך כל מכולה תמצאו את שם המוצר, המחיר, הדירוג והקישור.

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})

אזהרה: מחלקות ה־CSS שמתחילות ב־_cDEzb_ הן hashes של CSS module ש־Amazon מייצרת מחדש מעת לעת. ה־ID gridItemRoot והמחלקה a-link-normal יציבים יותר, אבל תמיד כדאי לאמת את הסלקטורים בעזרת DevTools לפני שמריצים את הסקרייפר.

שלב 4: ייצוא ל־CSV

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

למה לצפות — ומה משתבש

בבדיקה שלי, השיטה הזו החזירה בערך 30 מוצרים במקום 50. זו לא תקלה בקוד — זו טעינה מדורגת של Amazon. רק כ־30 מוצרים נטענים בהתחלה; השאר מופיעים אחרי גלילה, מה שדורש ביצוע JavaScript ש־requests לא יודע להתמודד איתו.

מגבלות נוספות:

• חסימות IP קורות מהר בלי rotation של פרוקסי (אני נחסמתי אחרי בערך 15 בקשות ברצף מהיר)
• סלקטורי CSS נשברים כש־Amazon מעדכנת את פריסת העמוד — וזה קורה לה לא מעט
• אין טיפול מובנה בעימוד

ללימוד גרידה עם Python זו שיטה מצוינת. לשימוש ב־production, היא שברירית.

שיטה 2: גרידת Amazon Best Sellers עם Selenium

Selenium פותר את בעיית הטעינה המדורגת בכך שהוא מריץ דפדפן אמיתי — כבד יותר להגדרה, אבל הוא לוכד את כל 50 המוצרים בכל עמוד.

שלב 1: התקנת Selenium

1pip install selenium pandas

הבשורה הטובה: החל מ־Selenium 4.6+, כבר לא צריך את webdriver-manager. Selenium Manager מטפל בהורדת הדרייבר אוטומטית.

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 (שהוצג ב־Chrome 109+) משתמש באותו מנגנון רינדור כמו Chrome רגיל, ולכן קשה יותר ל־Amazon לזהות אותו.

שלב 2: גלילה מעבר לטעינה מדורגת

זה השלב שהופך את Selenium לשווה את המאמץ. Amazon Best Sellers טוען בתחילה רק כ־30 מוצרים — השאר מופיעים אחרי גלילה.

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)

אחרי הגלילה, כל 50 המוצרים צריכים להופיע ב־DOM. גיליתי ש־5 גלילות Page Down עם השהיה של 2 שניות מספיקות, אבל ייתכן שתצטרכו להתאים לפי מהירות החיבור.

שלב 3: חילוץ נתוני המוצרים

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})

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

שלב 4: טיפול בעימוד

Amazon מחלקת 100 Best Sellers לשני עמודים עם מבני URL שונים:

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    # ... חילוץ המוצרים כמו למעלה ...
11    all_products.extend(products)
12driver.quit()

למה לצפות

בבדיקה שלי, Selenium תפס את כל 50 המוצרים בכל עמוד — ניצחון ברור לעומת requests + BS4. החיסרון: זה לקח בערך 45 שניות לעמוד (כולל זמני הגלילה), ועדיין קיבלתי סימון אחרי שהרצתי את זה יותר מדי פעמים בלי rotation של פרוקסי. גם עם דגלי anti-detection, Selenium עדיין ניתן לזיהוי על ידי מנגנוני הבוט של Amazon — להיקף רציני תצטרכו אמצעים נוספים (ראו את Anti-Ban Playbook בהמשך).

נקודות כאב נוספות:

• עדיין קורים מדי פעם חוסר התאמות בגרסאות WebDriver, אף ש־Selenium Manager צמצם זאת מאוד
• סלקטורי CSS צריכים עדכון בכל פעם ש־Amazon משנה את ה־DOM
• השימוש בזיכרון גבוה — כל מופע דפדפן צורך 200–400MB RAM

שיטה 3: גרידת Amazon Best Sellers עם Scraping API

Scraping APIs הם הגישה של "תנו למישהו אחר לטפל בחלקים הקשים". שירותים כמו Scrape.do, Oxylabs ו־ScrapingBee מנהלים rotation של פרוקסי, רינדור JavaScript ואמצעי אנטי־בוט — אתם רק שולחים URL ומקבלים HTML או JSON.

איך זה עובד

שולחים את ה־URL היעד לנקודת הקצה של ה־API. ה־API מרנדר את הדף באמצעות דפדפן אמיתי על התשתית שלהם, מסובב פרוקסי, מטפל ב־CAPTCHA ומחזיר HTML נקי. ואז מנתחים את ה־HTML שהתקבל עם BeautifulSoup כמו תמיד.

שלב 1: שליחת בקשה דרך ה־API

הנה דוגמה עם Scrape.do (המחיר מתחיל ב־$29 לחודש עבור 150,000 credits, כש־1 credit = בקשה אחת ללא קשר לרינדור):

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")

מכאן והלאה, הניתוח זהה לשיטה 1 — אותם סלקטורים, אותו לוגיקת חילוץ.

בדיקת עלויות

הנה מה ש־APIים מובילים גובים לכל 1,000 בקשות ל־Amazon, לפי התעריף הטוב ביותר הזמין:

יתרונות וחסרונות

יתרונות: אמינות גבוהה ( ב־Amazon אצל הספקים המובילים), בלי תחזוקת דרייברים, מטפל באנטי־בוט אוטומטית, וסקייל טוב.

חסרונות: תשלום לכל בקשה (העלויות מצטברות בהיקפים גדולים), עדיין צריך לכתוב קוד ניתוח, ועדיין פגיע לשינויי סלקטורים ב־CSS. עבור 100,000 עמודים בחודש, השוואת העלויות הכוללת דרמטית: בנייה פנימית עולה בערך — חיסכון של 71%.

נקודת האיזון בדרך כלל היא 500K–1M בקשות בחודש. מתחת לזה, החיסכון בזמן של API עולה בהרבה על העלות.

שיטה 4: גרידת Amazon Best Sellers עם Thunderbit (בלי Python)

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

הוא AI web scraper שפועל כתוסף Chrome. הרעיון המרכזי: במקום לכתוב סלקטורי CSS או קוד Python, ה־AI קורא את הדף ומבין אילו נתונים לחלץ. עבור Amazon Best Sellers, ל־Thunderbit יש תבניות מובנות שעובדות בלחיצה אחת.

שלב 1: התקנת Thunderbit Chrome Extension

עברו אל ולחצו על "Add to Chrome." הירשמו לחשבון חינמי — החבילה החינמית נותנת מספיק credits כדי לבדוק את זה.

שלב 2: מעבר לעמוד Amazon Best Sellers

פתחו כל עמוד קטגוריה של Amazon Best Sellers ב־Chrome. לדוגמה: https://www.amazon.com/Best-Sellers-Electronics/zgbs/electronics/

שלב 3: לחיצה על "AI Suggest Fields"

פתחו את הסיידבר של Thunderbit ולחצו על "AI Suggest Fields." ה־AI מנתח את מבנה העמוד ומציע עמודות: Product Name, Price, Rating, Image URL, Vendor, Product URL, ו־Rank. בבדיקה שלי הוא זיהה נכון את כל השדות הרלוונטיים בתוך כ־3 שניות.

אפשר לשנות שמות, להסיר או להוסיף עמודות. אפשר אפילו להוסיף prompts מותאמים אישית לכל שדה — למשל, "categorize as Electronics/Apparel/Home" כדי להוסיף תגית קטגוריה לכל מוצר.

שלב 4: לחיצה על "Scrape"

לחצו על כפתור "Scrape". Thunderbit ממלא טבלה מובנית עם כל נתוני המוצרים מהדף. במצב cloud, הוא מעבד עד 50 עמודים בבת אחת במקביל, ומטפל בטעינה מדורגת ובעימוד אוטומטית.

שלב 5: ייצוא בחינם

לחצו על "Export" ובחרו יעד: Excel, Google Sheets, Airtable או Notion. כל הייצוא בחינם בכל התוכניות — בלי עלויות נסתרות.

כל התהליך לקח לי בערך 90 שניות מהרגע שפתחתי את הדף ועד שקיבלתי גיליון מלא. להשוואה, שיטה 1 לקחה כ־20 דקות (כולל ניפוי תקלות סביב טעינה מדורגת), שיטה 2 לקחה כ־35 דקות (כולל הגדרת Selenium), ושיטה 3 לקחה כ־15 דקות (כולל הקמת חשבון API).

למה Thunderbit עובד טוב עם Amazon

כיוון שה־AI קורא את הדף מחדש בכל פעם, הוא מסתגל לשינויי פריסה באופן אוטומטי — בלי סלקטורי CSS לתחזק. זה פותר ישירות את התלונה הנפוצה ביותר בפורומי גרידה: "A basic web scraper won't suffice, you need to add so many 'catches' for element changes." כשה־DOM של Amazon משתנה (וזה קורה לה לא מעט), אתם לא צריכים לעדכן כלום.

מצב Cloud Scraping מטפל ב־proxy rotation, רינדור ואמצעי אנטי־בוט בצורה שקופה. עבור משתמשים שרוצים פתרון של "פשוט עובד", זה מסיר את כל כאב הראש של חסימות.

תוכנית אנטי־חסימה: איך להימנע מחסימה על ידי Amazon

מנגנוני הזיהוי של Amazon אגרסיביים. קיבלתי חסימה זמנית ל־IP שלי במהלך הבדיקה, וגם משתמשים בפורומים מדווחים על אותו הדבר: "errors everywhere, amazon even started redirecting me to the homepage." אם אתם הולכים על המסלול של Python (שיטות 1–3), הסעיף הזה קריטי.

הנה אסטרטגיה רב־שכבתית, מסודרת מהבסיסי למתקדם:

1. החלפת מחרוזות User-Agent

שליחת אותו User-Agent שוב ושוב היא דגל אדום. השתמשו במאגר של 5+ מחרוזות מהדוגמה בשיטה 1, ובחרו אחת באקראי לכל בקשה:

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

2. הוספת השהיות אקראיות בין בקשות

השהיות קבועות קלות לזיהוי (תבניות). אקראיות בטוחות יותר:

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

מצאתי שהשהיה של 2–5 שניות בין בקשות שומרת מתחת לרדאר באצוות קטנות (פחות מ־50 בקשות). לריצות גדולות יותר, העלו ל־3–7 שניות.

3. שימוש ב־Proxy Rotation

זה החלק הגדול. מראים שפרוקסי Residential מגיעים בממוצע לכ־94% הצלחה ב־Amazon לעומת כ־59% לפרוקסי Datacenter — פער של 35 נקודות אחוז. שכבת הזיהוי של Amazon כוללת TLS fingerprinting, ניתוח התנהגות, והגבלת קצב לפי IP, כך שכתובות Datacenter רגילות מסומנות בתוך שניות.

פרוקסי Residential יקרים יותר ($2–$12 ל־GB, תלוי בספק), אבל הרבה יותר אמינים. לדוגמה:

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. חיזוק טביעת האצבע של הדפדפן (Selenium)

1options.add_argument('--disable-blink-features=AutomationControlled')
2options.add_experimental_option("excludeSwitches", ["enable-automation"])
3options.add_experimental_option('useAutomationExtension', False)
4# אחרי אתחול הדרייבר, הסירו את דגל navigator.webdriver
5driver.execute_cdp_cmd('Page.addScriptToEvaluateOnNewDocument', {
6    'source': "Object.defineProperty(navigator, 'webdriver', {get: () => undefined})"
7})

5. ניהול סשנים וקובצי Cookie

שמירת cookies בין בקשות גורמת לסקרייפר להיראות יותר כמו סשן של משתמש אמיתי:

1session = requests.Session()
2# בקרו קודם בדף הבית כדי לקבל cookies ריאליסטיים
3session.get("https://www.amazon.com", headers=headers)
4time.sleep(2)
5# ואז גרדו את דף היעד
6response = session.get(target_url, headers=headers)

6. מתי לוותר על כאב הראש לגמרי

למשתמשים שלא רוצים לנהל אף אחד מהדברים האלה, ה־cloud scraping של Thunderbit מטפל ב־proxy rotation, רינדור ואמצעי אנטי־בוט בצורה שקופה. גם Scraping APIs מטפלים ברוב הנושאים האלה כברירת מחדל. מניסיוני, הזמן שמבזבזים על ניפוי תקלות של anti-ban לעיתים עולה על הזמן של כתיבת קוד הגרידה עצמו — ולכן הגישה של "פשוט עובד" בהחלט משתלמת.

העשרת תתי־עמודים: גרידת עמודי מוצר לקבלת נתונים עשירים יותר

עמוד ה־Best Sellers מציג רק מידע בסיסי — כותרת, מחיר, דירוג, Rank. אבל הערך האמיתי למחקר FBA נמצא בעמודי המוצר עצמם. הנה מה מפספסים אם מגרדים רק את עמוד הרשימה:

השדה "Date First Available" הוא בעל ערך מיוחד — הוא אומר כמה זמן המוצר כבר בשוק, וזהו אות חשוב לניתוח תחרות. וגם מספר המוכרים ובעל ה־Buy Box עוזרים להעריך אם נישה שווה כניסה (אם Amazon עצמה מחזיקה ביותר מ־30% מנתח ה־Buy Box, התחרות קשה במיוחד).

גישת Python: מעבר על כתובות המוצרים בלולאה

אחרי איסוף כתובות המוצרים מדף הרשימה, עברו על כל אחת עם השהיה:

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    # חילוץ המותג
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    # חילוץ ASIN מתוך קוד המקור או מה־URL
9    # חילוץ Date First Available מטבלת פרטי המוצר
10    # ... שדות נוספים ...

אזהרה הוגנת: פגיעה ב־100 עמודי מוצר בודדים מגדילה משמעותית את סיכון החסימה. תכננו מראש שימוש ב־proxy rotation ובהשהיות ארוכות יותר.

גישת Thunderbit: גרידת תתי־עמודים בלחיצה אחת

אחרי שמגרדים את עמוד הרשימה לטבלה, לוחצים ב־Thunderbit על "Scrape Subpages". ה־AI מבקר בכל כתובת מוצר ומעשיר את הטבלה בעמודות נוספות — מותג, ASIN, מפרטים, תכונות — אוטומטית. בלי קוד נוסף, בלי סלקטורים, בלי הגדרות. זה שימושי במיוחד לצוותי e-commerce שצריכים תמונה מלאה לצורכי החלטות sourcing, אבל לא רוצים לכתוב ולתחזק parser לעמודי פרטים.

אוטומציה של גרידות חוזרות: מעקב אחר Best Sellers לאורך זמן

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

גישת Python: תזמון עם Cron

ב־Linux/Mac אפשר לתזמן את סקריפט ה־Python עם cron. הנה רשומת crontab לגרידה יומית ב־8 בבוקר:

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

לגרידה שבועית בימי שני ב־9 בבוקר:

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

ב־Windows אפשר להשתמש ב־Task Scheduler כדי להשיג את אותו דבר. לתזמון תמידי בלי להשאיר את המחשב הנייד דולק, אפשר לפרוס ל־VPS או AWS Lambda — אבל זה מוסיף מורכבות תשתיתית.

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

גישת Thunderbit: Scheduled Scraper בשפה פשוטה

ה־Scheduled Scraper של Thunderbit מאפשר לכם לתאר את המרווח בשפה טבעית — הקלידו "every Monday at 9am" או "every day at 8am" וה־AI מפרש את התזמון. הגרידות רצות על שרתי ה־cloud של Thunderbit (לא צריך דפדפן או מחשב פעיל), והנתונים נשלחים אוטומטית ל־Google Sheets או Airtable. כך מקבלים דשבורד ניטור חי בלי ניהול שרתים — אידיאלי לצוותי תפעול שרוצים נראות מתמשכת בלי overhead של DevOps.

שיקולים משפטיים ואתיים בעת גרידה מ־Amazon

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

robots.txt של Amazon: נכון ל־2026, הקובץ robots.txt של Amazon כולל יותר מ־80 נתיבי Disallow ספציפיים, אבל /gp/bestsellers/ אינו חסום במפורש עבור user agents רגילים. עם זאת, יותר מ־35 user agents של AI (ClaudeBot, GPTBot, Scrapy וכו') מקבלים חסימה גורפת Disallow: /. היעדר חסימה ספציפית לא אומר ש־Amazon מאשרת גרידה.

תנאי השימוש של Amazon: של Amazon (עודכנו במאי 2025) אוסרים במפורש "using any automated process or technology to access, acquire, copy, or monitor any part of the Amazon Website" בלי הרשאה בכתב. זה לא תיאורטי — Amazon בנובמבר 2025 על גישה אוטומטית לא מורשית וזכתה בצו מניעה זמני.

התקדים של hiQ נגד LinkedIn: ב־ (המעגל התשיעי, 2022), בית המשפט קבע שגרידת נתונים ציבוריים ככל הנראה אינה מפרה את חוק ה־CFAA. אבל hiQ בסופו של דבר הגיעה לפשרה והסכימה להפסיק לגרד — ניצחון על CFAA לא מגן מתביעות על הפרת חוזה.

הנחיות מעשיות:

• גרדו רק נתונים ציבוריים זמינים (מחירים, BSR, כותרות מוצרים — לא מידע אישי)
• כבדו rate limits ואל תעמיסו על השרתים
• השתמשו בנתונים למודיעין תחרותי לגיטימי
• התייעצו עם ייעוץ משפטי משלכם לפני גרידה בהיקף גדול
• קחו בחשבון שיותר מ־ כבר מחזיקות בחקיקת פרטיות מקיפה

ה־cloud scraping של Thunderbit משתמש בדפוסי בקשה סטנדרטיים דומים לדפדפן, אבל תמיד כדאי לוודא עמידה בדרישות מול הייעוץ המשפטי שלכם.

איזו שיטה כדאי לבחור? מדריך החלטה קצר

בקיצור:

• "אני לומד Python ורוצה פרויקט לסוף שבוע." → שיטה 1 (requests + BeautifulSoup). תלמדו המון על בקשות HTTP, ניתוח HTML וההגנות של Amazon מפני בוטים.
• "אני צריך לגרד דפים כבדים ב־JavaScript או סשנים עם התחברות." → שיטה 2 (Selenium). היא כבדה יותר אבל מתמודדת עם תוכן דינמי.
• "אני מריץ גרידות ב־production ובסקייל." → שיטה 3 (Scraping API). תנו למישהו אחר לנהל פרוקסי ורינדור. נוטה לטובת APIs מתחת ל־500K בקשות בחודש.
• "אני לא מפתח ואני רוצה נתונים בתוך 2 דקות." → שיטה 4 (). בלי קוד, בלי סלקטורים, בלי תחזוקה.
• "אני צריך ניטור מתמשך בלי ניהול שרתים." → Thunderbit Scheduled Scraper. הגדירו ושכחו.

מסקנה ותובנות מרכזיות

אחרי סוף שבוע של בדיקות, הנה מה שבאמת נשאר:

requests + BeautifulSoup מצוין ללמידה, אבל המגבלה של טעינה מדורגת (רק כ־30 מתוך 50 מוצרים) והסלקטורים השבריריים הופכים אותו ללא מעשי ל־production.

Selenium פותר את בעיית הטעינה המדורגת וקולט את כל 50 המוצרים בכל עמוד, אבל הוא איטי, זולל זיכרון, ועדיין ניתן לזיהוי על ידי מנגנוני ההגנה של Amazon.

Scraping APIs מציעים את האמינות הטובה ביותר לגרידה ברמת production — ב־Amazon — אבל העלויות מצטברות ועדיין צריך לכתוב קוד ניתוח.

Thunderbit סיפק את הזמן המהיר ביותר עד לנתונים בפער גדול. ה־AI מטפל בשינויי פריסה, טעינה מדורגת, עימוד ואמצעי אנטי־בוט בלי שום הגדרות. עבור משתמשים לא־טכניים או צוותים שצריכים נתונים חוזרים בלי overhead של DevOps, זו האופציה הפרקטית ביותר.

הלקח הגדול ביותר? מנגנוני האנטי־בוט של Amazon ושינויי הפריסה התכופים שלה הופכים פתרונות ללא תחזוקה לחוסכי הזמן הגדולים ביותר בטווח הארוך. כל שעה שאתם מבזבזים על ניפוי סלקטורים שבורים וסיבוב פרוקסי היא שעה שלא תוקדש לניתוח אמיתי.

רוצים לנסות את הגישה ללא קוד? נותנת לכם מספיק credits כדי לגרד כמה קטגוריות Best Sellers ולראות את התוצאות בעצמכם. מעדיפים את מסלול ה־Python? דוגמאות הקוד שלמעלה אמורות להתחיל אתכם. כך או כך, יהיו לכם נתוני Amazon Best Seller בגיליון נתונים במקום להסתכל על לשונית דפדפן.

לעוד על גישות לגרידת אתרים, בדקו את המדריכים שלנו על , , ו־. אפשר גם לצפות בהדרכות צעד־אחר־צעד ב־.

למידע נוסף