למדו איך לגרד מוצרי Amazon עם Python

אם כבר ניסיתם מדריך ל- scrape amazon products with python רק כדי להיתקל בקיר של CAPTCHAs, שגיאות 503 או תוצאות ריקות לגמרי — ברוכים הבאים למועדון. רוב המדריכים לגרידת Amazon ב‑Python שמסתובבים ברשת נכתבו ב‑2022 או 2023, והם משתמשים ב‑selectors ובטכניקות ש‑Amazon כבר תיקנה מזמן.

במשך שנים בניתי ב‑Thunderbit כלי חילוץ נתונים, ויש דבר אחד שאני יכול לומר לכם מהשטח: Amazon הוא אחד האתרים הקשים ביותר לגרידה אמינה. הפלטפורמה משנה את מבנה ה‑HTML שלה כל הזמן, מפעילה הגנה נגד בוטים בשש שכבות, ואפילו מציגה פריסות עמוד שונות למשתמשים שונים באמצעות בדיקות A/B. במדריך הזה אראה לכם איך לבנות Python Amazon scraper שבאמת עובד ב‑2025 — עם CSS selectors מאומתים, אסטרטגיית anti-blocking בשכבות, והנחיות לתזמון ולייצוא שרוב המדריכים פשוט מדלגים עליהן. ולמי שרוצה את הנתונים בלי להסתבך עם Python, אראה גם איך יכול לעשות את אותו הדבר בכשתי לחיצות.

מהי גרידת מוצרי Amazon?

גרידת מוצרי Amazon היא תהליך של חילוץ אוטומטי של נתונים זמינים לציבור — שמות מוצרים, מחירים, דירוגים, מספר ביקורות, תמונות, זמינות ועוד — מדפי המוצרים ותוצאות החיפוש של Amazon. במקום להעתיק ידנית מידע ממאות רישומים, scraper נכנס לכל עמוד, קורא את ה‑HTML, ושולף את הנתונים שהגדרתם לפורמט מובנה כמו CSV, Excel או מסד נתונים.

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

למה לגרד מוצרי Amazon עם Python?

Amazon מארחת בערך ביותר מ‑30 קטגוריות, עם כ‑. מוכרי צד שלישי מהווים כיום 69% מסך ה‑GMV. לעקוב ידנית אפילו אחרי חלק קטן מהקטלוג הזה זה בלתי אפשרי. הנה הסיבות שבגללן צוותים מגרדים נתונים מ‑Amazon:

היקף שינויי המחירים ב‑Amazon לבדו הופך אוטומציה לחיונית: Amazon משנה מחירים , כשמחירו של מוצר ממוצע מתעדכן בערך כל 10 דקות. לעומת זאת, מתחרים כמו Best Buy ו‑Walmart משנים מחירים רק כ‑50,000 פעמים בחודש. אף צוות אנושי לא יכול לעמוד בקצב הזה.

Python נותן לכם שליטה מלאה על תהליך הגרידה — אתם מחליטים מה לחלץ, איך לטפל בשגיאות ואיפה לשמור את הנתונים. אבל זה גם אומר שאתם אחראים על התחזוקה, ההתגוננות מפני חסימות, וההתמודדות עם השינויים התכופים ב‑HTML של Amazon.

מה אפשר לגרד מ‑Amazon ומה לא

מדפי מוצרים ציבוריים אפשר בדרך כלל לחלץ:

• כותרת המוצר (שם, מותג)
• מחיר (נוכחי, מקורי, מחיר מבצע)
• דירוג (ממוצע כוכבים)
• מספר ביקורות
• תמונות מוצר (כתובת התמונה הראשית)
• זמינות / מצב מלאי
• ASIN (מספר הזיהוי התקני של Amazon)
• תיאור מוצר ונקודות עיקריות
• מידע על המוכר
• וריאציות מוצר (מידה, צבע וכו')

מה שכדאי להימנע ממנו:

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

ה‑ של Amazon חוסם יותר מ‑50 בוטים מזוהים (כולל GPTBot, Scrapy ו‑ClaudeBot) ואוסר על נתיבים כמו חשבונות משתמש, עגלות וקניות שמורות. דפי מוצר לא נחסמים במפורש, אבל תנאי השימוש של Amazon כן אוסרים גישה אוטומטית. בתי משפט הבחינו בדרך כלל בין הפרת תנאי שימוש (עניין אזרחי) לבין עבירה פלילית לפי CFAA — נדבר יותר על חוקיות בסוף המדריך.

כלים וספריות שתצטרכו

זה הסטאק של Python למדריך הזה:

אופציונלי (לתוכן שמוצג באמצעות JavaScript):

• selenium או playwright — אוטומציה של דפדפן headless

הגדרת סביבת Python

פתחו את הטרמינל והריצו:

1mkdir amazon-scraper && cd amazon-scraper
2python -m venv venv
3source venv/bin/activate  # ב‑Windows: venv\Scripts\activate
4pip install requests beautifulsoup4 lxml curl_cffi pandas

אמתו שהכול הותקן:

1import requests, bs4, curl_cffi, pandas
2print("All good!")

אם אתם רואים "All good!" בלי שגיאות, אתם מוכנים.

למה רוב מדריכי גרידת Amazon נשברים (ולמה המדריך הזה שונה)

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

Amazon מעדכנת לעיתים קרובות את מבנה ה‑HTML שלה, שמות המחלקות וה‑element IDs. קהילת הגרידה מדווחת ש‑ זקוקים לתיקונים שבועיים בגלל שינויי DOM ושינויים בטביעת הדפדפן. הקורבן הידוע לשמצה ביותר? ה‑selector #priceblock_ourprice, שהופיע במאות מדריכים מ‑2018–2023. ה‑ID הזה כבר לא קיים בדפי מוצר של Amazon.

השוואה מהירה בין מה ששבור לבין מה שעובד עכשיו:

כל קטע קוד במדריך הזה נבדק על דפי Amazon חיים ב‑2025. אציג לכם את ה‑CSS selectors האמיתיים יחד עם פלט צפוי — בלי להעתיק ממדריכים של 2022.

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

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

שלב 1: לשלוח את הבקשה הראשונה ל‑Amazon

כנסו לכל עמוד מוצר של Amazon בדפדפן והעתיקו את ה‑URL. נתחיל עם requests.get() פשוט:

1import requests
2url = "https://www.amazon.com/dp/B0DGNFM9YJ"
3response = requests.get(url)
4print(response.status_code)
5print(response.text[:500])

אם תריצו את זה, כמעט בוודאות תקבלו קוד מצב 503 או עמוד שאומר "To discuss automated access to Amazon data please contact…". זו מערכת ה‑WAF (Web Application Firewall) של Amazon שמזהה את סקריפט ה‑Python שלכם. קריאה בסיסית של requests.get() בלי headers מתאימים מצליחה נגד Amazon רק בכ‑ מהמקרים.

סביר שתראו משהו כמו: 503 ועמוד חסימה ב‑HTML. זה צפוי — נתקן את זה בשלב הבא.

שלב 2: להגדיר headers מותאמים והתחזות TLS

להוסיף רק header של User-Agent כבר לא מספיק. Amazon משווה בין ה‑HTTP headers שלכם לבין טביעת ה‑TLS. אם אתם טוענים שאתם Chrome 120 אבל ה‑TLS handshake חושף את ספריית requests של Python, אתם .

הגישה האמינה ביותר ב‑2025 היא להשתמש ב‑curl_cffi עם התחזות לדפדפן:

1from curl_cffi import requests as cfreq
2headers = {
3    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
4    "Accept-Language": "en-US,en;q=0.9",
5    "Accept-Encoding": "gzip, deflate, br",
6    "Referer": "https://www.google.com/",
7    "DNT": "1",
8    "Connection": "keep-alive",
9    "Upgrade-Insecure-Requests": "1",
10}
11url = "https://www.amazon.com/dp/B0DGNFM9YJ"
12response = cfreq.get(url, headers=headers, impersonate="chrome124")
13print(response.status_code)
14print(len(response.text))

עם curl_cffi שמתחזה ל‑Chrome 124, שיעורי ההצלחה קופצים לכ‑ — שיפור של פי 47 לעומת requests רגיל. עכשיו אתם אמורים לראות קוד מצב 200 ותגובה ארוכה הרבה יותר ב‑HTML (מעל 100,000 תווים).

אם עדיין מתקבל 503, נסו ערך אחר ל‑impersonate (למשל "chrome131") או הוסיפו השהיה קצרה לפני ניסיון חוזר.

שלב 3: לנתח את ה‑HTML ולחלץ נתוני מוצר

עכשיו כשה‑HTML המלא בידינו, נחלץ את הנתונים באמצעות BeautifulSoup עם selectors מאומתים ל‑2025:

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(response.text, "lxml")
3# כותרת מוצר
4title_el = soup.select_one("span#productTitle")
5title = title_el.get_text(strip=True) if title_el else None
6# מחיר
7price_el = soup.select_one(
8    "div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen"
9)
10if not price_el:
11    price_el = soup.select_one("span.priceToPay .a-offscreen")
12if not price_el:
13    price_el = soup.select_one(".apexPriceToPay .a-offscreen")
14price = price_el.get_text(strip=True) if price_el else None
15# דירוג
16rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17rating = rating_el.get_text(strip=True) if rating_el else None
18# מספר ביקורות
19reviews_el = soup.select_one("span#acrCustomerReviewText")
20reviews = reviews_el.get_text(strip=True) if reviews_el else None
21# זמינות
22avail_el = soup.select_one("div#availability span")
23availability = avail_el.get_text(strip=True) if avail_el else None
24# כתובת תמונה ראשית
25img_el = soup.select_one("#landingImage")
26image_url = img_el.get("src") if img_el else None
27print(f"Title: {title}")
28print(f"Price: {price}")
29print(f"Rating: {rating}")
30print(f"Reviews: {reviews}")
31print(f"Availability: {availability}")
32print(f"Image: {image_url}")

פלט צפוי (לדוגמה):

1Title: Apple AirPods Pro (2nd Generation) with USB-C
2Price: $189.99
3Rating: 4.7 out of 5 stars
4Reviews: 98,432 ratings
5Availability: In Stock
6Image: https://m.media-amazon.com/images/I/61SUj2...

שימו לב שיש כמה selectors חלופיים למחיר — Amazon משתמשת במכולות שונות בהתאם לסוג המוצר, מצב המבצע והווריאנט של בדיקות A/B. עטיפת כל חילוץ בבדיקת תנאי מונעת מה‑scraper לקרוס כשה‑selector לא תואם.

שלב 4: לגרד כמה מוצרים מדפי תוצאות חיפוש

כדי לבנות דאטה אמיתי, תרצו להתחיל מדף תוצאות חיפוש של Amazon, לאסוף ASINs, ואז לגרד כל דף מוצר בנפרד.

1import time
2import random
3def get_search_asins(keyword, max_pages=1):
4    """איסוף ASINs מתוצאות חיפוש של Amazon."""
5    asins = []
6    for page in range(1, max_pages + 1):
7        search_url = f"https://www.amazon.com/s?k={keyword}&page={page}"
8        resp = cfreq.get(search_url, headers=headers, impersonate="chrome124")
9        if resp.status_code != 200:
10            print(f"Search page {page} returned {resp.status_code}")
11            break
12        search_soup = BeautifulSoup(resp.text, "lxml")
13        results = search_soup.select('div[data-component-type="s-search-result"]')
14        for r in results:
15            asin = r.get("data-asin")
16            if asin:
17                asins.append(asin)
18        print(f"Page {page}: found {len(results)} products")
19        time.sleep(random.uniform(2, 5))  # השהיה מנומסת
20    return asins
21asins = get_search_asins("wireless+earbuds", max_pages=2)
22print(f"Collected {len(asins)} ASINs")

כל ASIN ממופה לכתובת מוצר נקייה: https://www.amazon.com/dp/{ASIN}. זה אמין יותר מכתובות מלאות של תוצאות חיפוש, שיכולות להכיל פרמטרים ספציפיים לסשן.

שלב 5: לטפל בפאג'ינציה ולגרד בהיקף גדול

עכשיו נחבר בין איסוף החיפוש לבין גרידת דפי המוצר לצינור עבודה מלא:

1import pandas as pd
2def scrape_product(asin):
3    """גרידת דף מוצר בודד ב‑Amazon."""
4    url = f"https://www.amazon.com/dp/{asin}"
5    try:
6        resp = cfreq.get(url, headers=headers, impersonate="chrome124")
7        if resp.status_code != 200:
8            return None
9        soup = BeautifulSoup(resp.text, "lxml")
10        title_el = soup.select_one("span#productTitle")
11        price_el = (
12            soup.select_one("div#corePriceDisplay_desktop_feature_div span.a-price .a-offscreen")
13            or soup.select_one("span.priceToPay .a-offscreen")
14            or soup.select_one(".apexPriceToPay .a-offscreen")
15        )
16        rating_el = soup.select_one("#acrPopover span.a-icon-alt")
17        reviews_el = soup.select_one("span#acrCustomerReviewText")
18        avail_el = soup.select_one("div#availability span")
19        img_el = soup.select_one("#landingImage")
20        return {
21            "asin": asin,
22            "title": title_el.get_text(strip=True) if title_el else None,
23            "price": price_el.get_text(strip=True) if price_el else None,
24            "rating": rating_el.get_text(strip=True) if rating_el else None,
25            "reviews": reviews_el.get_text(strip=True) if reviews_el else None,
26            "availability": avail_el.get_text(strip=True) if avail_el else None,
27            "image_url": img_el.get("src") if img_el else None,
28            "url": url,
29        }
30    except Exception as e:
31        print(f"Error scraping {asin}: {e}")
32        return None
33# גרידת כל ה-ASINs שנאספו
34products = []
35for i, asin in enumerate(asins):
36    print(f"Scraping {i+1}/{len(asins)}: {asin}")
37    product = scrape_product(asin)
38    if product:
39        products.append(product)
40    time.sleep(random.uniform(2, 5))  # השהיה אקראית בין בקשות
41df = pd.DataFrame(products)
42print(f"\nScraped {len(df)} products successfully")
43print(df.head())

ההשהיה האקראית בין 2–5 שניות היא קריטית. תזמון קבוע מדי (למשל בדיוק 3 שניות בכל פעם) נראה חשוד למערכות הניתוח ההתנהגותי של Amazon. מרווחים אקראיים מדמים דפוסי גלישה אנושיים.

שלב 6: לשמור נתוני Amazon ל‑CSV

1df.to_csv("amazon_products.csv", index=False, encoding="utf-8-sig")
2print("Saved to amazon_products.csv")

עכשיו אמור להיות לכם CSV נקי עם עמודות ל‑ASIN, כותרת, מחיר, דירוג, ביקורות, זמינות, כתובת תמונה וכתובת מוצר. כאן רוב המדריכים עוצרים — אבל אם אתם בונים תהליך עבודה אמיתי, CSV הוא רק ההתחלה.

צלילה עמוקה ל‑Anti-Blocking: איך לשמור על ה‑scraper פעיל

חסימות הן של כל מי שמנסה לגרד מוצרי Amazon עם Python. מערכת ההגנה בשש שכבות של Amazon כוללת ניתוח מוניטין IP, טביעת TLS, בדיקות סביבת דפדפן, ביומטריה התנהגותית, CAPTCHAs וזיהוי חריגות מבוסס ML. הנה אסטרטגיה מדורגת לטיפול בכל שכבה.

לסובב User-Agents וה‑headers המלאים

User-Agent סטטי אחד יסומן מהר. עדיף להחליף בין מחרוזות דפדפן עדכניות:

1import random
2USER_AGENTS = [
3    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.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/143.0.0.0 Safari/537.36",
5    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
6    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/26.0 Safari/605.1.15",
7]
8def get_headers():
9    return {
10        "User-Agent": random.choice(USER_AGENTS),
11        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
12        "Accept-Language": "en-US,en;q=0.9",
13        "Accept-Encoding": "gzip, deflate, br",
14        "Referer": "https://www.google.com/",
15        "DNT": "1",
16        "Connection": "keep-alive",
17    }

פרט אחד שמכשיל הרבה אנשים: ה‑Accept-Language שלכם חייב להתאים למיקום הגיאוגרפי שמשתמע מה‑IP. שליחת Accept-Language: en-US מ‑IP גרמני היא דגל אדום.

התחזות לטביעת TLS עם curl_cffi

כבר נגענו בזה בשלב 2, אבל שווה להדגיש: זו הטכניקה שמביאה את השיפור הגדול ביותר בשיעור ההצלחה. requests רגיל של Python מצליח מול Amazon בערך ב‑2% בלבד. עם התחזות של curl_cffi, אתם מגיעים לכ‑94%. זה ההבדל בין scraper עובד לבין scraper שבור.

1from curl_cffi import requests as cfreq
2# לסובב גם את יעד ההתחזות
3BROWSERS = ["chrome120", "chrome124", "chrome131"]
4response = cfreq.get(
5    url,
6    headers=get_headers(),
7    impersonate=random.choice(BROWSERS),
8)

סיבוב פרוקסים

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

1PROXIES = [
2    "http://user:pass@proxy1.example.com:8080",
3    "http://user:pass@proxy2.example.com:8080",
4    "http://user:pass@proxy3.example.com:8080",
5]
6proxy = random.choice(PROXIES)
7response = cfreq.get(
8    url,
9    headers=get_headers(),
10    impersonate="chrome124",
11    proxies={"http": proxy, "https": proxy},
12)

פרוקסי Residential יעילים יותר מפרוקסי של data center (Amazon חוסמת מראש טווחי IP של data centers), אבל הם גם יקרים יותר. לפרויקט קטן אפשר להתחיל עם ולהתרחב לפי הצורך.

הגבלת קצב ו‑Exponential Backoff

אף מאמר מתחרה שמצאתי לא מסביר את זה, אבל זה חיוני. כשמקבלים 503 או CAPTCHA, אל תנסו שוב מיד — זו דרך מהירה לחסימה קבועה.

1import time
2import random
3def fetch_with_backoff(url, max_retries=3):
4    """משיכת URL עם exponential backoff בעת כשל."""
5    for attempt in range(max_retries):
6        response = cfreq.get(
7            url,
8            headers=get_headers(),
9            impersonate=random.choice(BROWSERS),
10        )
11        if response.status_code == 200:
12            return response
13        # Exponential backoff עם jitter
14        wait = min(2 ** attempt + random.uniform(0, 1), 30)
15        print(f"Attempt {attempt+1} failed ({response.status_code}). Waiting {wait:.1f}s...")
16        time.sleep(wait)
17    return None  # כל הניסיונות מוצו

הנוסחה wait = min(2^attempt + jitter, max_delay) מבטיחה שההשהיות יגדלו (2 שניות, 4 שניות, 8 שניות...) אבל לא יעברו גבול סביר. ה‑jitter האקראי מונע זיהוי של דפוסי הניסיון החוזר שלכם.

חלופה עם Selenium או Playwright לתוכן שמוצג ב‑JS

חלק מדפי Amazon (במיוחד כאלה עם ווידג'טים דינמיים של תמחור או בוררי וריאציות) דורשים JavaScript כדי להיטען במלואם. כש‑curl_cffi מחזיר HTML חלקי, דפדפן headless הוא חלופת הגיבוי:

1from playwright.sync_api import sync_playwright
2def scrape_with_browser(url):
3    with sync_playwright() as p:
4        browser = p.chromium.launch(headless=True)
5        page = browser.new_page()
6        page.goto(url, wait_until="domcontentloaded")
7        page.wait_for_timeout(3000)  # לתת ל‑JS להיטען
8        html = page.content()
9        browser.close()
10        return html

זה איטי יותר — 3–5 שניות לעמוד במקום פחות משנייה עם curl_cffi. השתמשו בזה רק כשצריך.

מניסיוני, curl_cffi מטפל ביותר מ‑90% מדפי המוצרים של Amazon בלי דפדפן.

סיכום Anti-Blocking

מעבר ל‑CSV: לייצא נתוני Amazon ל‑Google Sheets, Airtable ועוד

כל מדריך שבדקתי נעצר בייצוא ל‑CSV. אבל תהליכי עבודה אמיתיים צריכים נתונים ב‑Google Sheets, במסדי נתונים, או בכלים כמו Airtable ו‑Notion.

ייצוא ל‑Google Sheets עם gspread

ראשית, הגדירו Google service account (הגדרה חד‑פעמית):

1. היכנסו ל‑ → APIs & Services → Credentials
2. צרו service account והורידו את קובץ מפתח ה‑JSON
3. שמרו אותו ב‑~/.config/gspread/service_account.json
4. שתפו את הגיליון היעד עם ה‑client_email מתוך קובץ ה‑JSON

ואז:

1import gspread
2from gspread_dataframe import set_with_dataframe
3gc = gspread.service_account()
4sh = gc.open("Amazon Scrape Data")
5worksheet = sh.sheet1
6set_with_dataframe(worksheet, df)
7print("Data exported to Google Sheets!")

זה כותב את כל ה‑DataFrame ישירות ל‑Google Sheet — חי, ניתן לשיתוף, ומוכן לדשבורדים.

אחסון ב‑SQLite לניתוח מקומי

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

1import sqlite3
2conn = sqlite3.connect("amazon_products.db")
3df.to_sql("products", conn, if_exists="append", index=False)
4print(f"Stored {len(df)} products in SQLite")
5# שאילתה מאוחרת יותר:
6historical = pd.read_sql_query(
7    "SELECT * FROM products WHERE price IS NOT NULL ORDER BY rowid DESC LIMIT 100",
8    conn,
9)

החלופה ללא קוד

אם אתם לא רוצים לתחזק סקריפטים של ייצוא ב‑Python, מציעה ייצוא חינמי ל‑Google Sheets, Airtable, Notion, Excel, CSV ו‑JSON — כולל שדות תמונה שמוצגים ישירות ב‑Airtable וב‑Notion. בלי הגדרה של gspread, בלי אישורי API, בלי קוד בכלל. לצוותים שצריכים להזרים נתונים לכלים הקיימים שלהם, זה חוסך המון זמן.

תזמון גרידות אוטומטיות של Amazon — הפרק החסר

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

Cron Jobs (Linux/macOS)

פתחו את ה‑crontab שלכם:

1crontab -e

הוסיפו שורה שמריצה את הסקריפט מדי יום ב‑6 בבוקר:

10 6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

או כל 6 שעות:

10 */6 * * * cd /path/to/amazon-scraper && /path/to/venv/bin/python scraper.py >> ~/scraper.log 2>&1

Windows Task Scheduler

צרו קובץ batch בשם run_scraper.bat:

1@echo off
2cd /d "C:\path\to\amazon-scraper"
3call venv\Scripts\activate
4python scraper.py
5deactivate

אחר כך פתחו Task Scheduler → Create Basic Task → הגדירו את ה‑trigger (Daily, Hourly) → Action: "Start a program" → בחרו את run_scraper.bat.

GitHub Actions (שכבה חינמית)

ללוח זמנים בענן בלי תשתית:

1name: Amazon Scraper
2on:
3  schedule:
4    - cron: "0 6 * * *"  # כל יום ב‑6 בבוקר UTC
5  workflow_dispatch:       # הפעלה ידנית
6jobs:
7  scrape:
8    runs-on: ubuntu-latest
9    steps:
10      - uses: actions/checkout@v3
11      - name: Set up Python
12        uses: actions/setup-python@v4
13        with:
14          python-version: "3.11"
15      - name: Install dependencies
16        run: pip install -r requirements.txt
17      - name: Run scraper
18        run: python scraper.py
19      - name: Commit results
20        run: |
21          git config user.name 'GitHub Actions'
22          git config user.email 'actions@github.com'
23          git add data/
24          git diff --staged --quiet || git commit -m "Update scraped data"
25          git push

שמרו את פרטי ה‑proxy ב‑GitHub Secrets, ויש לכם צינור גרידה אוטומטי בחינם.

חלופה ללא קוד: ה‑Scheduled Scraper של Thunderbit

לצוותים שלא רוצים להתעסק עם תחביר cron או תשתיות ענן, Thunderbit מציעה מובנה. פשוט מתארים את התזמון באנגלית פשוטה (למשל "every day at 8 AM" או "every Monday"), מוסיפים את כתובות ה‑Amazon שלכם, ולוחצים "Schedule". בלי טרמינל, בלי קבצי YAML, בלי pipeline של deployment. זה שימושי במיוחד לצוותי eCommerce שמריצים מעקב מתמשך אחרי מחירים או מלאי.

Python DIY מול Scraper API מול No-Code: איזו גישה מתאימה לכם?

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

Python הוא הבחירה הנכונה אם אתם רוצים ללמוד, להתאים כל פרט, ולא אכפת לכם מתחזוקה שוטפת. Scraper APIs מטפלות עבורכם ב‑anti-blocking, אבל עדיין דורשות קוד. ו‑Thunderbit היא המסלול המהיר ביותר לצוותי מכירות, eCommerce, או כל מי שפשוט צריך את הנתונים — בלי selectors, בלי קוד, ובלי תחזוקה כש‑Amazon משנה את ה‑HTML שלה.

איך Thunderbit מגרדת מוצרי Amazon בכשתי לחיצות

אני כמובן לא אובייקטיבי — הצוות שלי בנה את זה. אבל התהליך באמת פשוט כל כך:

1. מתקינים את
2. נכנסים לעמוד תוצאות חיפוש או לעמוד מוצר ב‑Amazon
3. לוחצים על "AI Suggest Fields" (או משתמשים בתבנית המוכנה של Amazon)
4. לוחצים על "Scrape"

ה‑AI של Thunderbit קורא את העמוד, מזהה את מבנה הנתונים, ומחלץ הכול לטבלה נקייה. אפשר לייצא ל‑Excel, Google Sheets, Airtable או Notion בחינם. היתרון הגדול באמת: כש‑Amazon משנה את ה‑HTML שלה בשבוע הבא (וזה יקרה), ה‑AI של Thunderbit מסתגל אוטומטית. בלי סקריפטים שבורים, בלי עדכוני selectors.

להעשרת רשימות מוצרים בנתונים מדפי מוצר, תכונת Subpage Scraping של Thunderbit עוקבת אוטומטית אחרי קישורים לדפי מוצר ומוסיפה שדות כמו תמונות, תיאורים ווריאציות — משהו שב‑Python דורש הרבה קוד נוסף.

טיפים לשמירה על Python Amazon scraper לאורך זמן

אם אתם הולכים על מסלול Python, הנה איך לצמצם כאבי תחזוקה:

• בדקו selectors באופן קבוע. Amazon משנה אותם לעיתים קרובות. שמרו את המאמר הזה במועדפים — אעדכן את טבלת ה‑selectors כשהדברים ישתנו.
• עקבו אחרי שיעור ההצלחה. מדדו את היחס בין תגובות 200 לבין 503s/CAPTCHAs. הגדירו התראה (אפילו מייל פשוט) כשהשיעור יורד מתחת ל‑80%.
• שמרו HTML גולמי. שמרו את תגובת ה‑HTML המלאה לצד הנתונים שניתחו. אם selectors משתנים, תוכלו לנתח מחדש נתונים היסטוריים בלי לגרד שוב.
• סובבו פרוקסים ו‑User-Agents לעיתים קרובות. טביעות סטטיות מסומנות תוך שעות כשעובדים בהיקף.
• השתמשו ב‑exponential backoff. לעולם אל תנסו שוב מיד אחרי חסימה.
• ארזו ב‑Docker. עטפו את ה‑scraper בקונטיינר Docker לפריסה נוחה וניידות.
• הוסיפו ולידציה לנתונים. בדקו שמחירים הם מספריים, שהדירוגים בין 1–5, ושהכותרות לא ריקות. צוות אחד דיווח על אחרי הוספת שכבות ולידציה.

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

שיקולים משפטיים ואתיים כשמגרדים Amazon

מכיוון שהנושא עולה כמעט בכל שיחה על גרידת Amazon, הנה הערה קצרה על המצב המשפטי:

• גרידת נתונים ציבוריים מותרת בדרך כלל בארה״ב. פסק הדין (2022) קבע שגישה לנתונים ציבוריים אינה מפרה את CFAA. לאחרונה, (2024) ו‑ (2024) חיזקו את העיקרון הזה.
• תנאי השימוש של Amazon אוסרים גישה אוטומטית. זה עניין אזרחי (הפרת חוזה), לא פלילי. בתי משפט נוטים להבחין בין השניים.
• Amazon v. Perplexity (2025) הוא תיק פעיל שקשור לגרידת AI של דפי Amazon. צו מניעה זמני הוצא במרץ 2026. שווה לעקוב.
• היצמדו לדפים ציבוריים. אל תגרדו תוכן שמוגן בסיסמה, נתונים אישיים או כל דבר מאחורי אימות.
• כבדו rate limits. אל תעמיסו על השרתים של Amazon. השהיה של 2–5 שניות בין בקשות היא סבירה.
• השתמשו בנתונים באחריות. גרדו לצורכי ניתוח, לא לפרסום מחדש של תוכן מוגן בזכויות יוצרים.
• התייעצו עם יועץ משפטי לשימוש מסחרי בהיקף גדול, במיוחד אם אתם באיחוד האירופי (GDPR חל על נתונים אישיים).

לקריאה נוספת, ראו את המדריך שלנו על .

לסיכום

עכשיו יש לכם Python Amazon scraper עובד עם selectors מאומתים ל‑2025, אסטרטגיית anti-blocking בשכבות שהולכת הרבה מעבר ל"להוסיף User-Agent", אפשרויות תזמון מעשיות למעקב מתמשך, ושיטות ייצוא שמכניסות את הנתונים שלכם ל‑Google Sheets, למסדי נתונים או לכל כלי שהצוות שלכם משתמש בו.

סיכום קצר:

• Python + curl_cffi + BeautifulSoup נותנים שליטה מלאה ושיעור הצלחה של כ‑94% בשילוב עם התחזות TLS
• Anti-blocking דורש כמה שכבות: סיבוב headers, התחזות TLS, סיבוב פרוקסים, הגבלת קצב ו‑exponential backoff
• תזמון הופך סקריפט חד‑פעמי לצינור ניטור רציף (cron, GitHub Actions או המתזמן המובנה של Thunderbit)
• ייצוא מעבר ל‑CSV — Google Sheets, SQLite, Airtable, Notion — הוא המקום שבו הערך העסקי האמיתי נמצא
• Thunderbit מציעה חלופה בכשתי לחיצות למי שלא מפתח או למי שמעדיף להשקיע את הזמן בניתוח הנתונים ולא בדיבוג selectors

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

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

גרידה נעימה — ושה‑selectors שלכם ישרדו עד עדכון Amazon הבא.

שאלות נפוצות

1. למה ה‑Python Amazon scraper שלי נחסם אחרי כמה בקשות?

Amazon משתמשת במערכת הגנה בשש שכבות: ניתוח מוניטין IP, טביעת TLS (JA3/JA4), זיהוי סביבת דפדפן, ביומטריה התנהגותית, אתגרי CAPTCHA וזיהוי חריגות מבוסס ML. סקריפט requests בסיסי עם header של User-Agent בלבד מצליח רק בכ‑ מהמקרים. צריך התחזות TLS (curl_cffi), סיבוב מלא של headers, סיבוב פרוקסים, והגבלת קצב עם jitter אקראי כדי לשמור על גישה אמינה.

2. אילו ספריות Python הכי מתאימות לגרידת מוצרי Amazon ב‑2025?

curl_cffi לבקשות HTTP עם התחזות TLS (השיפור המשמעותי ביותר), BeautifulSoup4 עם lxml לניתוח HTML, pandas לארגון וייצוא הנתונים, ו‑Selenium או Playwright כחלופה לתוכן שמוצג ב‑JavaScript. Python משמשת ממפתחי הגרידה.

3. האם מותר לגרד נתוני מוצר מ‑Amazon?

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

4. אפשר לגרד Amazon בלי לכתוב קוד בכלל?

כן. כלים כמו מאפשרים לגרד מוצרי Amazon בכשתי לחיצות באמצעות תוסף Chrome. זיהוי השדות מבוסס ה‑AI שלהם מארגן אוטומטית את הנתונים, ואפשר לייצא ל‑Excel, Google Sheets, Airtable או Notion בחינם. כש‑Amazon משנה את ה‑HTML שלה, ה‑AI של Thunderbit מסתגל בלי עדכונים ידניים.

5. באיזו תדירות Amazon משנה את ה‑HTML selectors שלה, ואיך שומרים את ה‑scraper מעודכן?

לעיתים תכופות וללא הודעה מוקדמת. קהילת הגרידה מדווחת ש‑ מה‑crawlers זקוקים לתיקונים שבועיים בגלל שינויי DOM. כדי להישאר קדימה, עקבו אחרי שיעור ההצלחה של ה‑scraper, שמרו HTML גולמי לניתוח חוזר, ובדקו selectors מול דפים חיים באופן קבוע. לחלופין, כלים מבוססי AI כמו Thunderbit מסתגלים אוטומטית ומבטלים את עומס התחזוקה הזה.

למידע נוסף