Craigslist עדיין מושך בערך 108 מיליון כניסות בחודש דרך כ־700 אתרים מקומיים — ועדיין אין לו API ציבורי. אם אתם רוצים נתונים מובְנים מתוך מודעות דירות, רכבים יד שנייה, משרות או גיגים, scraping הוא כמעט תמיד הפתרון היחיד.
אבל מערכת ההגנה המותאמת של Craigslist נגד בוטים היא אגרסיבית במיוחד. היא לא משתמשת ב-Cloudflare או ב-DataDome — אלא במנגנון rate limiting משלה מבוסס nginx, ששופר במשך יותר מעשור. אם תפגעו בו לא נכון, תקבלו 403 עוד לפני שתספיקו לשתות את הקפה של הבוקר. הקדשתי לא מעט זמן לבדיקת גישות שונות מול ההגנות של Craigslist, והמדריך הזה הוא התוצאה: מדריך Python מעודכן ל-2025, שמתאים לכל קטגוריה, כולל שיטת החילוץ דרך JSON-LD (השיפור המשמעותי ביותר לעומת מדריכים ישנים), אסטרטגיות אמיתיות להימנעות מחסימה, סקירה משפטית, וגם חלופה ללא קוד למי שרוצה רק את הנתונים בלי לכתוב שורת קוד אחת.
מה זה אומר לגרד את Craigslist עם Python?
Web scraping של Craigslist אומר להשתמש בסקריפטים ב-Python כדי לבקר אוטומטית בעמודי Craigslist, לחלץ את הנתונים המובְנים שמעניינים אתכם — כותרות, מחירים, תיאורים, תמונות, מיקומים, תאריכי פרסום — ולשמור אותם בגיליון אלקטרוני, מסד נתונים או קובץ JSON.
Python הוא השפה המועדפת לזה בזכות האקוסיסטם העשיר של הספריות שלו. עם requests, BeautifulSoup, lxml ו-curl_cffi, אפשר לבנות scraper עובד ל-Craigslist בפחות מ־100 שורות. הקהילה עצומה, כך שכאשר Craigslist משנה משהו (וזה קורה), כמעט תמיד כבר יש מישהו שמצא את הפתרון.
הנקודה החשובה ביותר: ל-Craigslist אין API ציבורי לקריאה. הממשק הרשמי היחיד הוא Bulk Posting Interface (BAPI), והוא מיועד לכתיבה בלבד — הוא מאפשר למפרסמים מאושרים להעלות מודעות, לא לשלוף אותן. כל מוצר "Craigslist API" שתראו בפלטפורמות צד שלישי הוא למעשה scraper לא רשמי, לא endpoint מורשה. אם אתם צריכים נתונים בהיקף גדול — מגרדים.
למה לגרד Craigslist? שימושים אמיתיים
Craigslist הוא לא רק מקום למצוא ספה משומשת. זהו מאגר נתונים עצום שמתעדכן כל הזמן בעשרות תחומים. הנה מי באמת יכול להרוויח מחילוץ הנתונים ממנו:
| שימוש | מי מרוויח | מה מחלצים |
|---|---|---|
| מעקב אחר מחירי דירות ושכירות | סוכני נדל"ן, שוכרים, חברות PropTech | מחיר, שטח, מספר חדרי שינה, שכונה, קואורדינטות |
| ניתוח שוק הרכב המשומש | סוכנויות רכב, אפליקציות צרכניות, חוקרים | מחיר, יצרן, דגם, שנה, ק"מ, מצב הרכב |
| מחקר שוק העבודה | מגייסים, כלכלני עבודה, אנליסטים של כוח אדם | כותרת, שכר, סוג העסקה, תאריך פרסום |
| יצירת לידים | צוותי מכירות, נותני שירות | פרטי קשר, שמות עסקים, אזור שירות |
| תמחור תחרותי | ספקי שירות מקומיים, תפעול ecommerce | תמחור שירותים, תיאורים, אזורי שירות |
הדוגמה האקדמית הכי מצוטטת היא Kaggle "Used Cars Dataset" — בערך 500,000 מודעות רכב משומש מארה"ב עם 26 משתנים, ששימשה בסיס לעשרות מאמרים, כולל מחקר ב-ResearchGate מ-2024 על דינמיקת שוק הרכב המשומש בארה"ב. קרנות גידור רוכשות נתוני שכירות מאוחדים מ-Craigslist לצורך מחקר מגמות שכר דירה. וגם צוותי מכירות מגרדים בקביעות את קטגוריות השירותים והגיגים לצורך יצירת לידים.
החישוב פשוט: 8 שעות של העתקה והדבקה ידנית מול בערך 10 דקות עם scraper בנוי היטב.
לגרד את Craigslist עם Python: כל קטגוריה, לא רק רכבים
כמעט כל מדריך שמצאתי לגרידת Craigslist עוסק רק במכירת רכבים — כמו לכתוב מדריך ל-Google שמכסה רק חיפוש תמונות. ל-Craigslist יש עשרות קטגוריות, ומבנה ה-URL שונה בין אחת לשנייה.
המבנה תמיד הוא: https://{city}.craigslist.org/search/{category_slug}
מחליפים את תת-הדומיין של העיר ואת ה-slug, ומקבלים תחום אחר לגמרי. הנה טבלת עזר של הקטגוריות הפופולריות ביותר (נבדק באפריל 2025):
| קטגוריה | Slug ב-URL | שדות נפוצים לחילוץ |
|---|---|---|
| דירות / דיור | /search/apa | מחיר, שטח, חדרי שינה, מיקום, מדיניות חיות מחמד |
| מכוניות ומשאיות | /search/cta | מחיר, יצרן, דגם, שנה, ק"מ |
| משרות | /search/jjj | כותרת, חברה, שכר, סוג העסקה |
| שירותים | /search/bbb | כותרת, תיאור, מספר טלפון, אזור |
| גיגים | /search/ggg | כותרת, תגמול, תאריך, קטגוריה |
| למכירה (כללי) | /search/sss | כותרת, מחיר, מצב, מיקום |
אפשר גם לשלב פרמטרי שאילתה לסינון:
| פרמטר | מטרה | דוגמה |
|---|---|---|
query | מילת מפתח בחיפוש מלא | ?query=studio |
min_price / max_price | טווח מחירים | &min_price=1500&max_price=3000 |
hasPic | רק מודעות עם תמונות | &hasPic=1 |
postedToday | 24 השעות האחרונות | &postedToday=1 |
sort | מיון | &sort=priceasc |
s | היסט עימוד (120 לעמוד) | ?s=120 |
לכן URL כמו https://newyork.craigslist.org/search/apa?min_price=1500&max_price=3000&hasPic=1 מחזיר דירות בניו יורק במחיר שבין 1,500 ל-3,000 דולר עם תמונות. כל סקריפט Python במדריך הזה עובד על כל הקטגוריות האלה — פשוט מחליפים את ה-slug.
סלקטורים ל-HTML של Craigslist ב-2025: ישן מול חדש (והקיצור דרך של JSON)
הסיבה מספר אחת לכך שסקריפטים ל-Craigslist נשברים היא שינוי במבנה ה-HTML. אם אתם עוקבים אחרי מדריך מ-2022 שמבקש מכם לכוון ל-.result-row או .result-info, הסקריפט שלכם כבר לא רלוונטי.
Craigslist כתב מחדש את מבנה תוצאות החיפוש שלו ב-2023–2024. שמות המחלקות הישנים עדיין מקוננים בתוך wrappers חדשים, אבל כיוון אליהם בראש עץ ה-DOM מחזיר רשימה ריקה. הנה מה השתנה:
| אלמנט | סלקטור ישן (לפני 2024) | סלקטור נוכחי (2025) |
|---|---|---|
| מיכל של המודעה | .result-info | .cl-search-result |
| קישור הכותרת | .result-title | .posting-title a |
| מחיר | .result-price | .priceinfo |
| מטא־דאטה (אזור) | .result-hood | .meta |
אבל הנה התובנה האמיתית — זו שמבדילה scraper עדכני ל-2025 מכל השאר: לא צריך בכלל לפענח HTML בתוצאות החיפוש.
Craigslist מטמיע עכשיו כל מודעה גלויה בתוך תגית <script id="ld_searchpage_results"> כנתוני JSON-LD מובְנים. קריאה אחת של requests.get() מחזירה את כל ה-schema.org ItemList עם כל המודעות בעמוד — כותרת, מחיר, מטבע, מיקום, URL לתמונה, וקישור לעמוד המלא. בלי רינדור JavaScript. בלי שבריריות של CSS selectors.
הגישה של JSON-LD מהירה יותר, יציבה יותר, ופחות מועדת להישבר כש-Craigslist משנה את ה-UI. זה מה שכל מאגר GitHub שמתחזק כיום משתמש בו, וזה גם מה שנשתמש בו במדריך למטה.
שימו לב: בלוק ה-JSON-LD קיים בקטגוריות עם מחירים — דירות (apa), למכירה (sss), רכבים (cta), דיור (hhh). הוא לרוב חסר או דל בקטגוריות משרות (jjj), גיגים (ggg), קהילה (ccc) ושירותים (bbb), כי למודעות האלה אין schema.org/Offer עם מחיר. בקטגוריות האלה כדאי לחזור לנתיב HTML של .cl-search-result.
בחירת סטאק Python: Requests + BS4 מול Selenium מול Playwright
זו השאלה שעולה בכל פורום גרידה: "באיזו ספרייה כדאי להשתמש?" ספציפית ל-Craigslist, התשובה הרבה יותר חד-משמעית מאשר ברוב האתרים.
| גורם | requests + BeautifulSoup | Selenium | Playwright |
|---|---|---|---|
| מהירות | 5–15 עמודים/שנייה (מוגבל רשת) | 0.3–1 עמוד/שנייה | 0.5–2 עמודים/שנייה |
| תוכן מרונדר ב-JS | לא | כן | כן |
| זיכרון | ~30–60 MB | ~400–700 MB | ~300–500 MB |
| מורכבות התקנה | נמוכה | בינונית | בינונית |
| עמידות נגד בוטים | נמוכה (צריך headers/proxies) | בינונית (דפדפן אמיתי) | בינונית-גבוהה |
| שימוש אידיאלי ב-Craigslist | תוצאות חיפוש (JSON-LD) | עמודי פירוט עם תוכן דינמי | גרידה אסינכרונית בהיקף גדול |
| עקומת למידה | ידידותי למתחילים | בינונית | בינונית |
העמודים של Craigslist נבנים בצד השרת. בלוק ה-JSON-LD כבר נמצא ב-HTML הראשוני. אין אתגר JavaScript במסלולי קריאה. כל scraper פעיל ומתוחזק של Craigslist ב-GitHub משתמש ב-requests + BeautifulSoup או Scrapy. אפס שימוש ב-Selenium או ב-Playwright. זה לא במקרה — framework לאוטומציית דפדפן מוסיף מאות מגה־בייט של זיכרון, האטה של פי 10–100, וטביעת אצבע בולטת יותר, בלי כל תועלת.
ההמלצה שלי:
- requests + BS4: להתחיל כאן. זה משתלב מצוין עם שיטת החילוץ של JSON-LD ומכסה 95% מצרכי הגרידה של Craigslist.
- Selenium: רק אם צריך אינטראקציה עם תוכן דינמי בעמודי פירוט מסוימים (נדיר ב-Craigslist).
- Playwright: אם אתם מגדילים להיקפים של אלפי עמודים עם concurrency אסינכרוני — אבל בכנות, צוואר הבקבוק הוא ה-rate limiter של Craigslist, לא התפוקה של הספרייה.
כיסינו בנפרד גם את ההשוואה בין Playwright ל-Puppeteer ואת הסיכום של כלי ה-web scraping הטובים ביותר ל-Python אם תרצו פירוט מלא.
גרדו את Craigslist בלי לכתוב Python Get Started Free
החלופה ללא קוד: לגרד את Craigslist בלי לכתוב Python
לפני שנכנסים לקוד — הסעיף הזה מיועד למי שאינו מפתח. סוכני נדל"ן, צוותי מכירות, מנהלי תפעול — אם אתם רק רוצים את הנתונים ולא רוצים להתעסק בכתיבת Python, יש מסלול מהיר יותר.
Thunderbit הוא AI web scraper שפועל כהרחבת Chrome. הוא יכול לגרד את Craigslist בכ־2 קליקים, בלי צורך בקוד. כך זה עובד:
- נכנסים לכל עמוד תוצאות של Craigslist (דירות, רכבים, משרות — כל קטגוריה).
- לוחצים על "AI Suggest Fields" בסרגל הצד של Thunderbit. ה-AI קורא את הדף ומזהה אוטומטית עמודות כמו כותרת המודעה, מחיר, מיקום וקישור.
- לוחצים על "Scrape" — הנתונים נשלפים תוך שניות.
- משתמשים ב-Subpage Scraping כדי להיכנס לכל עמוד פירוט ולהעשיר את הנתונים עם תיאורים מלאים, מספרי טלפון, תמונות ותכונות.
- מייצאים ישירות ל-Google Sheets, Excel, Airtable או Notion — בחינם לגמרי.
לצרכים חוזרים — למשל מעקב יומי אחרי מחירי דירות או צילום שבועי של מודעות משרות — ה-Scheduled Scraper של Thunderbit מאפשר לתאר את לוח הזמנים בשפה פשוטה, והוא פועל אוטומטית. בלי cron jobs, בלי הקמת שרת.
Thunderbit גם מטפל באמצעי ההגנה נגד בוטים דרך מצב Cloud Scraping, כך שאין צורך להסתבך עם proxies מסתובבים או בניית headers ידנית. אם תרצו לנסות, התקינו את Thunderbit Chrome Extension ותראו בעצמכם.
אם אתם כן רוצים שליטה מלאה והתאמה אישית, המשיכו לקרוא להדרכה צעד-אחר-צעד ב-Python.
שלב אחר שלב: איך לגרד את Craigslist עם Python (מדריך מלא)
- רמת קושי: בינונית
- זמן נדרש: כ־30 דקות (התקנה + גרידה ראשונה)
- מה צריך: Python 3.8+, דפדפן Chrome (לבדיקת עמודים), טרמינל
שלב 1: הקמת סביבת Python
התקינו את הספריות הנדרשות:
pip install requests beautifulsoup4 lxml
lxml הוא אופציונלי, אבל מאיץ משמעותית את parsing של BeautifulSoup. אם בהמשך תיתקלו בבעיות TLS fingerprinting (עוד על כך בסעיף ההימנעות מחסימה), אפשר להתקין גם curl_cffi:
pip install curl_cffi
בלוק ה-import שלכם:
import requests
from bs4 import BeautifulSoup
import json
import csv
import time
import random
עכשיו אמורה להיות לכם סביבת Python נקייה עם כל התלויות מותקנות.
שלב 2: בניית URL של Craigslist לכל קטגוריה
בנו את ה-URL היעד באופן דינמי לפי עיר + slug של קטגוריה + פילטרים אופציונליים:
from urllib.parse import urlencode
BASE = "https://{city}.craigslist.org/search/{slug}"
def build_url(city, slug, **params):
return f"{BASE.format(city=city, slug=slug)}?{urlencode(params)}"
# דוגמה: דירות בניו יורק, 1500$–3000$, עם תמונות
url = build_url("newyork", "apa", min_price=1500, max_price=3000, hasPic=1)
print(url)
# https://newyork.craigslist.org/search/apa?min_price=1500&max_price=3000&hasPic=1
החליפו את "apa" ב-"cta" (רכבים), "jjj" (משרות), "bbb" (שירותים), או כל slug אחר מטבלת הקטגוריות למעלה. החליפו את "newyork" ב-"sfbay", "chicago", "losangeles" וכו'.
שלב 3: שליפת העמוד וחילוץ JSON מוטמע
שלחו בקשת GET עם headers מתאימים, ואז פרסו את בלוק ה-JSON-LD:
HEADERS = {
"User-Agent": (
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/124.0.0.0 Safari/537.36"
),
"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
"Accept-Language": "en-US,en;q=0.9",
"Accept-Encoding": "gzip, deflate, br",
"Referer": "https://www.craigslist.org/",
"Sec-Fetch-Dest": "document",
"Sec-Fetch-Mode": "navigate",
"Sec-Fetch-Site": "same-origin",
"Upgrade-Insecure-Requests": "1",
}
session = requests.Session()
r = session.get(url, headers=HEADERS, timeout=20)
r.raise_for_status()
soup = BeautifulSoup(r.text, "html.parser")
tag = soup.select_one("script#ld_searchpage_results")
data = json.loads(tag.text) if tag else {"itemListElement": []}
אם tag הוא None, בלוק ה-JSON-LD לא קיים עבור אותה קטגוריה — חזרו ל-parsing של HTML (ראו טבלת הסלקטורים למעלה). עבור דירות, רכבים וקטגוריות למכירה, בלוק ה-JSON-LD נמצא באופן עקבי.
שלב 4: הפיכת נתוני המודעות לרשומות מובְנות
עברו על פריטי ה-JSON וחלצו את השדות שצריך:
listings = []
for entry in data["itemListElement"]:
item = entry["item"]
offers = item.get("offers", {}) or {}
addr = (offers.get("availableAtOrFrom") or {}).get("address", {})
listings.append({
"name": item.get("name"),
"url": offers.get("url"),
"price": offers.get("price"),
"currency": offers.get("priceCurrency"),
"locality": addr.get("addressLocality"),
"region": addr.get("addressRegion"),
"image": item.get("image"),
})
print(f"נמצאו {len(listings)} מודעות")
אמור להופיע משהו כמו "נמצאו 120 מודעות" (Craigslist מציג 120 תוצאות לעמוד). ייתכן שלחלק מהמודעות יהיה None במחיר אם המפרסם לא הזין מחיר — כדאי לטפל בזה בעדינות בהמשך.
שלב 5: גרידת עמודי פירוט עבור נתונים עשירים יותר
תוצאות החיפוש נותנות רק סיכום. לתיאורים מלאים, מאפיינים (חדרי שינה, שטח, מדיניות חיות מחמד), קואורדינטות lat/long ותמונות — צריך להיכנס לעמוד הפירוט של כל מודעה.
def fetch_detail(url, session):
r = session.get(url, headers=HEADERS, timeout=20)
r.raise_for_status()
s = BeautifulSoup(r.text, "html.parser")
body = s.select_one("#postingbody")
mp = s.select_one("#map")
return {
"description": body.get_text("\n", strip=True) if body else None,
"attributes": [x.get_text(" ", strip=True)
for x in s.select("p.attrgroup span, div.attrgroup .attr")],
"lat": mp.get("data-latitude") if mp else None,
"lng": mp.get("data-longitude") if mp else None,
"images": [img["src"] for img in s.select("div.gallery img")],
}
for item in listings:
item.update(fetch_detail(item["url"], session))
time.sleep(random.uniform(3, 6)) # קריטי: jitter נגד חסימה
ה-time.sleep(random.uniform(3, 6)) הוא לא אופציונלי. אם תדלגו עליו, תיתקלו ב-403 תוך כמה עשרות בקשות. עמודי הפירוט נבנים בצד השרת עם סלקטורים יציבים (#titletextonly, #postingbody, #map) שלא השתנו בערך מאז 2017 — אחד הדברים הבודדים ב-Craigslist שבאמת נשארו עקביים.
שלב 6: טיפול בעימוד כדי לגרד את כל התוצאות
Craigslist משתמש בפרמטר היסט ?s=120 לעימוד. כל עמוד מציג 120 תוצאות, וה-offset המקסימלי הוא בדרך כלל 2999.
def iter_all(city, slug, max_pages=25, **filters):
for page in range(max_pages):
offset = page * 120
url = build_url(city, slug, s=offset, **filters)
r = session.get(url, headers=HEADERS, timeout=20)
r.raise_for_status()
soup = BeautifulSoup(r.text, "html.parser")
tag = soup.select_one("script#ld_searchpage_results")
if not tag:
break
data = json.loads(tag.text)
items = data.get("itemListElement", [])
if not items:
break
for entry in items:
item = entry["item"]
offers = item.get("offers", {}) or {}
yield {
"name": item.get("name"),
"url": offers.get("url"),
"price": offers.get("price"),
}
time.sleep(random.uniform(2.5, 5.0))
אל תנסו לגרד אלפי עמודים ברצף מהיר. ה-rate limiter של Craigslist מבוסס IP, והתפוקה הסבירה מ-IP יחיד עומדת בערך על 0.3–0.5 בקשות בשנייה, בלי קשר לספרייה שבה משתמשים. המגבלה הזו נקבעת על ידי Craigslist, לא על ידי Python.
שלב 7: ייצוא נתוני Craigslist ל-CSV, JSON או Google Sheets
שמרו את התוצאות:
# CSV
with open("craigslist.csv", "w", newline="", encoding="utf-8") as f:
w = csv.DictWriter(f, fieldnames=listings[0].keys())
w.writeheader()
w.writerows(listings)
# JSON
with open("craigslist.json", "w", encoding="utf-8") as f:
json.dump(listings, f, indent=2, ensure_ascii=False)
אם אתם מעדיפים לדלג לגמרי על קוד הייצוא, Thunderbit מציע ייצוא חינמי ישירות ל-Google Sheets, Excel, Airtable או Notion מהדפדפן. אבל בפייפליינים של Python, CSV ו-JSON הם הפלט הסטנדרטי. אפשר גם להעביר את הנתונים ישירות ל-pandas לניתוח או למסד נתונים עם sqlite3.
איך להימנע מחסימה כשמגרדים את Craigslist עם Python
רוב המדריכים מדלגים על החלק הזה או מרפרפים עליו. מערכת האנטי-בוט של Craigslist בנויה בהתאמה אישית, לא מוצר מדף, ויש לה כמה מאפיינים ייחודיים.
להשתמש ב-Request Headers שנראים אמיתיים
Craigslist מאמת גם את סדר ה-headers וגם את השלמות שלהם. בקשה שחסר בה Sec-Fetch-Dest או שיש בה User-Agent ישן תסומן עוד לפני שהיא מגיעה לתוכן. סט ה-headers המלא של Chrome 120+ (שמופיע בשלב 3) הוא המינימום. מומלץ להחליף User-Agent לכל session מבין 5–10 מחרוזות עדכניות של Chrome/Firefox לדסקטופ — אבל לא לשנות באמצע session, כי זה נראה לא טבעי.
חוסר ב-headers מסוג Sec-Fetch-* הוא הסיבה הנפוצה ביותר לכך שסקריפטים חדשים נחסמים מיד.
להוסיף השהיות אקראיות בין בקשות
הקונצנזוס מהקהילה וממקורות רבים (ScrapingBee, Scraperly, Oxylabs, Multilogin) מתכנס ל-2–5 שניות אקראיות בין שליפות של עמודי חיפוש ו-3–6 שניות בין עמודי פירוט. מרווחים קבועים נראים כמו בוט. השתמשו ב-time.sleep(random.uniform(2, 5)) — לעולם לא ב-time.sleep(2).
להחליף Proxies אם עובדים בהיקף גדול
Craigslist חוסם מראש טווחי IP שלמים של AWS, GCP ו-Azure. פרוקסי של data center לעיתים קרובות מתים כבר מהבקשה הראשונה. לכל דבר מעבר לכמה מאות עמודים, תצטרכו residential rotating proxies, ולסובב אותם כל 20–30 בקשות. פרוקסי סלולריים הם בעלי הסיכון הנמוך ביותר לזיהוי, אבל עולים $8–30 לכל GB.
| סוג Proxy | סיכון זיהוי ב-Craigslist | עלות (2025) |
|---|---|---|
| Datacenter | גבוה מאוד — לעיתים נחסם כבר בבקשה הראשונה | $0.50–2/GB |
| Residential rotating | נמוך — מומלץ | $5–15/GB |
| Mobile | הנמוך ביותר | $8–30/GB |
מצב Cloud Scraping של Thunderbit מטפל בסיבוב proxies אוטומטית אם אתם מעדיפים לא לנהל את זה בעצמכם.
לטפל ב-CAPTCHA בצורה נכונה
CAPTCHA ב-Craigslist נדירים במסלולי קריאה — הם מופיעים בעיקר בתהליכי פרסום/תגובה. אם אחד מופיע: עצרו לפחות ל-60 שניות, החליפו IP, נקו cookies והאטו. CAPTCHA חוזרים הם סימן לכך שהקצב שלכם אגרסיבי מדי, לא חידה שצריך לפרוץ בכוח עם solver.
לכבד Rate Limits וליישם Backoff
Craigslist מחזיר 403 (ולא 429) כשמגיעים למגבלת הקצב. 403 אומר שה-IP הנוכחי נכנס לרשימת חסימה — אל תנסו שוב בעיוורון. החליפו IP, שנו UA, והמתינו.
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
retry = Retry(
total=5,
backoff_factor=1.5, # 1.5, 3, 6, 12, 24 שניות
status_forcelist=[429, 500, 502, 503, 504],
allowed_methods={"GET"},
respect_retry_after_header=True,
)
adapter = HTTPAdapter(max_retries=retry)
session.mount("https://", adapter)
עוד טיפ: דיווחים מהקהילה מציינים בעקביות את 2–6 לפנות בוקר לפי שעון העיר היעד כחלון הבטוח ביותר לגרידה, עם שיעור חסימות נמוך בכ־30–40% לעומת שעות היום.
TLS Fingerprinting — המלכודת הנסתרת
שכבת האנטי-בוט של Craigslist בודקת את ה-TLS ClientHello. ספריית requests של Python (שמבוססת על OpenSSL) מייצרת JA3 fingerprint שלא תואם לדפדפן אמיתי. User-Agent מושלם בשילוב fingerprint TLS לא-דפדפני הוא חוסר התאמה שניתן לזהות. הפתרון הוא curl_cffi עם impersonate="chrome124", שמדמה את handshake של Chrome:
from curl_cffi import requests as cffi_requests
r = cffi_requests.get(url, headers=HEADERS, impersonate="chrome124")
אם אתם מקבלים 403 לא מוסברים עם IP-ים residential נקיים ו-headers נכונים — סביר מאוד שזה ה-TLS fingerprinting.
robots.txt של Craigslist, תנאי השימוש, וגרידה אתית
רוב המדריכים או מדלגים על זה לגמרי, או קוברים שורה אחת ב-FAQ. בהתחשב בכך ש-Craigslist זכתה בפסק דין של 60.5 מיליון דולר נגד scraper (RadPad, 2017), זה ראוי ליותר מהערת שוליים.
מה באמת כתוב ב-robots.txt של Craigslist
קובץ ה-robots.txt קצר באופן מפתיע. יש בו בלוק יחיד של User-agent: * עם שבעה נתיבים חסומים בלבד:
Disallow: /reply
Disallow: /fb/
Disallow: /suggest
Disallow: /flag
Disallow: /mf
Disallow: /mailflag
Disallow: /eaf
כל השבעה הם endpoints אינטראקטיביים/משני-מצב: reply, flag, suggest, email-a-friend. עמודי המודעות (/search/..., כתובות של פוסטים בודדים) אינם חסומים. אין הוראת Crawl-delay, אף ש-Craigslist אוכף בפועל מגבלה כזו באמצעות חסימות IP.
תתי-הדומיין של הערים כן מפרסמים sitemaps — למשל https://newyork.craigslist.org/sitemap/index.xml — שהם המסלול הרשמי לגילוי מודעות.
תקדימים משפטיים: המקרים החשובים
Craigslist v. 3Taps (2013, הסתיים בפשרה ב-2015): 3Taps גרדו מודעות מ-Craigslist ומכרו אותן מחדש. כש-Craigslist שלחה התראה והחסימה את ה-IP-ים שלהם, 3Taps עקפו את החסימה באמצעות proxies מסתובבים. בית המשפט קבע שעקיפת חסימות IP לאחר שלילה מפורשת של הרשאה מהווה פעולה "without authorization" לפי ה-CFAA. 3Taps הגיעו לפשרה של מיליון דולר.
Meta v. Bright Data (2024): פסק דין עדכני יותר קבע שתנאי השימוש של Meta אינם יכולים לאסור גרידה של נתונים ציבוריים כאשר המשתמש אינו מחובר. בית המשפט קבע שסקרייפר שאינו מחובר נמצא "באותו מצב של מבקר". זהו פסק הדין החשוב ביותר עבור סקרייפרים ב-2024–2025 — אם אתם לא יוצרים חשבון ב-Craigslist, לא מתחברים, וניגשים רק לעמודים ציבוריים, ייתכן שתנאי השימוש אינם ניתנים לאכיפה נגדכם כחוזה.
המסקנה המעשית: הסיכון לפי CFAA צומצם משמעותית אחרי Van Buren (2021) ו-hiQ v. LinkedIn (2022) עבור עמודים ציבוריים. אבל תביעות נזיקין לפי דיני מדינות (כמו trespass-to-chattels, misappropriation) עדיין קיימות — וזה מה שהוביל גם להסדר של 3Taps וגם לפסק הדין של 60.5 מיליון דולר נגד RadPad.
זהו מידע כללי בלבד, לא ייעוץ משפטי. אם אתם מגרדים Craigslist לשימוש מסחרי, כדאי להתייעץ עם עורך דין.
צ'ק-ליסט אתי לגרידה בפועל
- ✅ לכבד כל
Disallowב-robots.txt — במיוחד את שבעת ה-endpoints של פעולות - ✅ להישאר הרבה מתחת ל-1,000 עמודים לכל 24 שעות לכל IP (בתנאי השימוש של Craigslist יש $0.25 לעמוד מעל הסף הזה כפיצוי מוסכם)
- ✅ להישאר לא מחוברים — לא ליצור חשבון Craigslist לצורך גרידה
- ✅ לא לעקוף חסימות IP באמצעות proxies אחרי חסימה מפורשת (זה מה שהפיל את 3Taps)
- ✅ להוסיף השהיות בין בקשות — מינימום 2–5 שניות
- ✅ לא לגרד מידע אישי ליצירת ספאם
- ✅ לא להפיץ מחדש נתונים גולמיים מ-Craigslist או להציג אותם כפלטפורמה שלכם
- ✅ להשתמש בנתונים למחקר לגיטימי, ניתוח, או שימוש אישי
- ✅ להעדיף sitemaps שפורסמו על פני crawling בכוח, כשאפשר
- ✅ להסיר PII (אימיילים, מספרי טלפון) כבר בקליטה אם אתם שומרים את הנתונים
כתבנו מדריך מעמיק יותר על ההשלכות המשפטיות של web scraping אם תרצו תמונה מלאה.
Python מול No-Code: איזו גישה מתאימה לכם?
| גורם | Python (requests + BS4) | Thunderbit (ללא קוד) |
|---|---|---|
| זמן הקמה | 30–60 דק׳ (התקנה, כתיבת קוד) | 2 דקות (התקנת תוסף Chrome) |
| מיומנות טכנית נדרשת | Python ברמה בינונית | אין |
| התאמה אישית | שליטה מלאה על לוגיקה, שדות וזרימה | AI מזהה שדות אוטומטית; אפשר לכוון ידנית |
| סקייל | בלתי מוגבל (עם proxies, תזמון) | Scheduled Scraper למשימות חוזרות |
| טיפול נגד חסימה | ידני (headers, השהיות, proxies, TLS) | מובנה (Cloud Scraping) |
| אפשרויות ייצוא | CSV, JSON (תכתבו לבד) | Google Sheets, Excel, Airtable, Notion — בחינם |
| מתאים במיוחד ל | מפתחים, data scientists, פייפליינים מותאמים | צוותי מכירות, סוכני נדל"ן, מנהלי תפעול |
בחרו ב-Python אם אתם צריכים התאמה אישית מלאה, מתכננים לשלב את זה בפייפליין נתונים גדול יותר, או רוצים להבין בדיוק מה קורה מתחת למכסה המנוע. בחרו ב-Thunderbit אם אתם רוצים תוצאות מהר, בלי לכתוב או לתחזק קוד. שתי האופציות לגיטימיות. זה תלוי בתרחיש השימוש שלכם והאם אתם מעדיפים לעבוד בטרמינל או בדפדפן.
לסיכום
Craigslist הוא מקור נתונים עשיר ומתעדכן כל הזמן בתחומי דיור, רכב, משרות, שירותים, גיגים ועוד — ובלי API ציבורי, scraping הוא הדרך היחידה להשיג ממנו נתונים מובְנים בקנה מידה גדול. הגישה שבאמת עובדת ב-2025: לחלץ את ה-JSON-LD המוטמע מתוצאות החיפוש (ולא CSS selectors שבירים), להשתמש ב-requests + BeautifulSoup (ולא Selenium), להוסיף headers מציאותיים עם שדות Sec-Fetch-*, לרנדומז השהיות, ולהשתמש ב-residential proxies אם אתם עוברים כמה מאות עמודים.
שיטת ה-JSON-LD היא השיפור הגדול ביותר מול מדריכים מיושנים. היא מהירה יותר, עמידה יותר לשינויי עיצוב, ולא דורשת רינדור JavaScript. אם מוסיפים לה את אסטרטגיות ההימנעות מחסימה שלמעלה, אפשר להימנע מה-403 שמכשילים את רוב הסקריפטים.
אם תרצו לדלג על הקוד לגמרי, Thunderbit Chrome Extension יכול לגרד כל קטגוריה ב-Craigslist בכמה קליקים ולייצא ישירות לגיליון או למסד הנתונים המועדף עליכם. ואם תרצו להעמיק, המדריכים שלנו על איך לגרד אתרים עם Python ועל שיטות עבודה מומלצות ל-web scraping מכסים את היסודות בפירוט רב יותר.
נסו את Thunderbit לגרידת Craigslist
נסו AI Web Scraper עבור נתוני Craigslist Get Started Free
שאלות נפוצות
האם מותר לגרד את Craigslist מבחינה חוקית?
תנאי השימוש של Craigslist אוסרים גרידה אוטומטית וכוללים סעיף פיצוי מוסכם ($0.25 לעמוד מעל 1,000 ביום). עם זאת, פסקי דין עדכניים — במיוחד Meta v. Bright Data (2024) ו-hiQ v. LinkedIn (2022) — צמצמו את האחריות לפי CFAA עבור גרידה של נתונים ציבוריים כאשר המשתמש אינו מחובר. תביעות נזיקין לפי דיני מדינה (כמו trespass-to-chattels) עדיין מהוות סיכון, במיוחד בהפצה מסחרית מחדש. כבדו robots.txt, הישארו לא מחוברים, הוסיפו השהיות, ואל תפיצו מחדש נתונים גולמיים. זהו מידע כללי בלבד, לא ייעוץ משפטי.
האם ל-Craigslist יש API ציבורי?
לא. Craigslist מציע רק Bulk Posting Interface (BAPI) לכתיבה בלבד עבור מפרסמים מאושרים בתשלום. אין API ציבורי לקריאה, אין פורטל מפתחים, ואין tier מוגבל־קצב לשליפת נתונים. כל "Craigslist API" שתראו בפלטפורמות צד שלישי הוא scraper לא רשמי.
למה הסקריפט שלי ל-Craigslist ממשיך להישבר?
כמעט תמיד בגלל שינויים במבנה ה-HTML. Craigslist כתב מחדש את markup של תוצאות החיפוש ב-2023–2024, ומדריכים שמשתמשים בסלקטורים ישנים כמו .result-row או .result-info כבר לא עובדים. עברו לשיטת ה-JSON-LD המוטמע (parse של script#ld_searchpage_results) כדי לקבל גישה עמידה הרבה יותר. בדקו גם שה-headers שלכם כוללים שדות Sec-Fetch-* — חוסר בהם גורם לחסימה מיידית.
אפשר לגרד את Craigslist בלי Python?
כן. תוסף ה-Chrome של Thunderbit, שהוא AI web scraper, עובד על כל עמוד ב-Craigslist — דירות, רכבים, משרות, שירותים. לוחצים על "AI Suggest Fields" כדי לזהות עמודות אוטומטית, לוחצים על "Scrape" כדי לחלץ נתונים, ואז מייצאים ל-Google Sheets, Excel, Airtable או Notion בחינם. בלי קוד, בלי התקנה מורכבת, בלי ניהול proxies.
כל כמה זמן אפשר לגרד את Craigslist בלי להיחסם?
עם IP residential יחיד, תפוקה בת-קיימא היא בערך 0.3–0.5 בקשות לשנייה, עם השהיות אקראיות של 2–5 שניות בין עמודים. כדאי להישאר מתחת ל-1,000 עמודים לכל 24 שעות לכל IP כדי להימנע גם מחסימה וגם מסף הפיצוי המוסכם בתנאי השימוש של Craigslist. גרידה בשעות שפל (2–6 לפנות בוקר לפי שעון העיר היעד) מפחיתה את שיעור החסימות בכ־30–40%. לנפחים גדולים יותר, כדאי לסובב residential proxies כל 20–30 בקשות.
למידע נוסף
