So scrapen Sie Gumtree-DatenKleinanzeigen, Preise und Standorte

Gumtree ist eine der meistbesuchten Kleinanzeigen-Websites in Großbritannien, ein einzelner Marktplatz, auf dem Menschen Autos, Möbel, Immobilien, Elektronik und Jobs für ihre lokale Umgebung inserieren. Jede Suchergebnisseite ist ein öffentlicher, strukturierter Feed dessen, was gerade zum Verkauf steht: Jede Kachel trägt einen Titel, einen Angebotspreis, einen Standort und einen Link zur vollständigen Anzeige. Das macht sie zu einer sauberen Quelle für Preisvergleiche, regionale Nachfrageforschung und das Verfolgen, wie sich Anzeigen im Zeitverlauf bewegen.

Dieser Leitfaden zeigt Ihnen, wie Sie Gumtree-Kleinanzeigen scrapen mit Python. Sie bauen einen kleinen, lauffähigen Scraper, der eine Gumtree-Suchseite über die Crawling API abruft, einen sauberen Datensatz für jede Anzeigenkachel parst, die Paginierung handhabt und die Ergebnisse nach JSON und CSV exportiert. Die gesamte Anleitung bleibt auf öffentliche Anzeigendaten beschränkt: die Titel, Preise, Standorte und Links, die jeder auf einer Suchergebnisseite sehen kann, ohne sich anzumelden.

Was Sie bauen werden

Ein Python-Skript, das eine Gumtree-Such-URL entgegennimmt, die gerenderte Ergebnisseite über die Crawling API abruft und einen strukturierten Datensatz pro Anzeigenkachel extrahiert. Wir verwenden eine Headset-Suche als durchgängiges Beispiel, dieselbe Abfrage, die auch die ältere Anleitung verwendete, und ziehen diese Felder aus jeder Kachel:

• Titel der Anzeigentitel, der auf der Kachel angezeigt wird, zum Beispiel die Marke und das Modell eines Autos.
• Preis der vom Verkäufer geforderte Preis, sofern die Kachel einen anzeigt.
• Standort die Gegend, in der der Artikel inseriert ist, nützlich für die regionale Nachfrageanalyse.
• Link die absolute URL zur eigenen Anzeigenseite des Inserats.

Warum eine einfache Anfrage bei Gumtree scheitert

Wenn Sie einen schlichten HTTP-Client auf eine Gumtree-Such-URL richten, erhalten Sie selten die Kacheln, für die Sie gekommen sind. Zwei Dinge arbeiten gegen Sie. Erstens rendert Gumtree einen Großteil des Ergebnisrasters clientseitig: Der Server liefert eine leichtgewichtige Hülle, und die Anzeigenkacheln werden erst befüllt, während das JavaScript der Seite läuft, sodass das anfängliche HTML, das Sie von einem schlichten requests.get erhalten, oft genau die Kacheln vermissen lässt, die Sie parsen möchten. Zweitens achtet Gumtree auf automatisierten Traffic. Rechenzentrums-IP-Bereiche und Anfragemuster, die nicht wie ein echter Browser aussehen, werden mit einer Challenge-Seite, einem Rate-Limit oder einer regelrechten Sperre konfrontiert, bevor Sie die Anzeigen je erreichen.

Ein funktionierender Gumtree-Scraper braucht also zwei Dinge in einer Anfrage: einen Browser, der die Seite rendert, und eine IP, die Gumtree als echten Besucher liest. Sie können das selbst mit einem Headless-Browser und einem Pool aus rotierenden Residential-Proxys zusammenstellen, aber diesen Stack gesund zu halten ist der größte Teil der Arbeit. Die Crawling API fasst beides in einem einzigen Aufruf zusammen: Sie senden ihr die Such-URL, sie rendert die Seite hinter einer vertrauenswürdigen Residential-IP, übernimmt die Rotation und jegliches CAPTCHA und gibt Ihnen fertiges HTML zum Parsen zurück.

Voraussetzungen

Bevor Sie Code schreiben, müssen einige Dinge bereitstehen. Keines davon dauert lange.

Grundlegende Python-Kenntnisse. Sie sollten damit vertraut sein, ein Python-Skript zu schreiben und auszuführen und Pakete mit pip zu installieren. Wenn Sie neu in der Sprache sind, deckt der Leitfaden zum Web Scraping mit Python das Niveau ab, das dieses Tutorial voraussetzt.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version (oder python3 --version). Falls Sie es nicht haben, installieren Sie es von python.org und stellen Sie sicher, dass Python in Ihrem System-PATH liegt.

Ein Crawlbase-Konto und ein Token. Melden Sie sich für ein kostenloses Konto an, öffnen Sie Ihr Dashboard und kopieren Sie Ihr Token. Der kostenlose Tarif umfasst bis zu 20.000 Anfragen ohne Karte, was reichlich ist, um diesen Scraper zu bauen und zu testen. Behandeln Sie das Token wie ein Passwort und halten Sie es aus der Versionskontrolle heraus.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit die Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die beiden Bibliotheken, die der Scraper benötigt. crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie jedes Feld per CSS-Selektor aus den Anzeigenkacheln herausziehen können.

python --version

python -m venv gumtree_env
source gumtree_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit gumtree_env\Scripts\activate statt der source-Zeile. Wenn beide Bibliotheken installiert sind, erstellen Sie die Skriptdatei, die der Rest des Leitfadens aufbaut:

touch gumtree_scraper.py

Die Suchseite auf Selektoren untersuchen

Bevor Sie Selektoren schreiben, öffnen Sie eine Gumtree-Suchergebnisseite in Ihrem Browser, klicken Sie mit der rechten Maustaste auf eine Anzeigenkachel und wählen Sie Untersuchen. Gumtree umschließt jedes Ergebnis mit einem article-Element, das mit einem data-q="search-result"-Attribut markiert ist, und legt die Felder innerhalb dieses Containers über ihre eigenen stabilen data-*-Attribute offen. Stützen Sie sich auf diese strukturellen Attribute statt auf eine brüchige Kette generierter Klassennamen: Sie überstehen kosmetische Redesigns weitaus besser.

Aus der Untersuchung einer Ergebnisseite sind dies die Selektoren, auf die sich die ältere Anleitung verließ, und sie bleiben der richtige Ausgangspunkt:

• Titel ein <div> mit data-q="tile-title".
• Preis ein <div> mit data-testid="price".
• Standort ein <div> mit data-q="tile-location".
• Link das href auf dem <a>-Tag mit data-q="search-result-anchor", das relativ ist und dem der Host https://www.gumtree.com vorangestellt werden muss.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu holen. Importieren Sie die Klasse CrawlingAPI, initialisieren Sie sie mit Ihrem Token, setzen Sie die Such-URL und fordern Sie sie an. Den Statuscode zu prüfen, bevor Sie parsen, hält Fehler laut statt still.

from crawlbase import CrawlingAPI

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8", "ignore")
    print(f"Request failed: {response['status_code']}")
    return None

if __name__ == "__main__":
    search_url = "https://www.gumtree.com/search?q=headset"
    html = crawl(search_url)
    print(html[:500] if html else "No HTML returned")

Die beiden Wait-Optionen sind wichtig für ein Raster, das sich beim Laden der Seite befüllt. ajax_wait weist die API an, auf den Abschluss asynchroner Inhalte zu warten, und page_wait hält nach dem Laden eine feste Anzahl von Millisekunden, damit die spät rendernden Kacheln erscheinen, bevor die Seite erfasst wird. Führen Sie das Skript aus, und Sie sollten echtes Anzeigen-Markup sehen, keine Challenge-Hülle. Das bestätigt, dass das Rendern funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Anzeigenkacheln mit BeautifulSoup parsen

Mit gerendertem HTML in der Hand laden Sie es in BeautifulSoup, finden jede Ergebniskachel und ziehen jedes Feld über seinen Selektor heraus. Gumtree umschließt jedes Ergebnis mit einem article[data-q="search-result"]-Container und legt Titel, Preis und Standort darin über ihre eigenen data-*-Attribute offen. Lesen Sie den Anzeigenlink aus dem Anchor der Kachel und normalisieren Sie ihn zu einer absoluten URL. Umschließen Sie jede Kachel mit einem try/except, damit eine fehlerhafte Anzeige nicht den gesamten Lauf zum Absturz bringt.

from bs4 import BeautifulSoup

BASE = "https://www.gumtree.com"

def text_of(tile, selector):
    el = tile.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_link(tile):
    a = tile.select_one('a[data-q="search-result-anchor"]')
    if not a or not a.get("href"):
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_gumtree_search(html):
    soup = BeautifulSoup(html, "html.parser")
    tiles = soup.select('article[data-q="search-result"]')
    results = []
    for tile in tiles:
        try:
            results.append({
                "title": text_of(tile, 'div[data-q="tile-title"]'),
                "price": text_of(tile, 'div[data-testid="price"]'),
                "location": text_of(tile, 'div[data-q="tile-location"]'),
                "link": parse_link(tile),
            })
        except Exception as e:
            print(f"Skipped a tile: {e}")
    return results

Der text_of-Helfer fragt ein Element innerhalb einer Kachel ab und gibt None zurück, wenn es fehlt, statt bei einem .get_text()-Aufruf gegen nichts eine Exception zu werfen. Das hält die Extraktion robust, wenn ein Feld fehlt, was häufig vorkommt, da nicht jede Anzeige einen sauberen Preis zeigt. Der Link stammt aus dem Anchor a[data-q="search-result-anchor"] und wird zu einer absoluten URL normalisiert, weil Gumtree ein relatives href ausliefert, das auf die Anzeigenseite zeigt.

Schritt 3: Paginierung handhaben und nach JSON und CSV exportieren

Eine Ergebnisseite ist eine Demo; ein echter Auftrag durchläuft mehrere. Gumtree paginiert seine Suchergebnisse mit einem ?page=N-Query-Parameter, sodass Sie über eine feste Anzahl von Seiten schleifen, jede einzelne abrufen und die Kacheln sammeln können. Verdrahten Sie nun das Abrufen, das Parsen und die Paginierungsschleife zu einem lauffähigen Skript und schreiben Sie die Datensätze dann sowohl nach JSON als auch nach CSV, damit Sie sie in ein Notebook oder eine Tabellenkalkulation laden können.

import csv
import json
import time
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_TOKEN"})
BASE = "https://www.gumtree.com"
FIELDS = ["title", "price", "location", "link"]

def crawl(page_url):
    options = {"ajax_wait": "true", "page_wait": 3000}
    response = api.get(page_url, options)
    if response["status_code"] == 200:
        return response["body"].decode("utf-8", "ignore")
    print(f"Request failed: {response['status_code']}")
    return None

def text_of(tile, selector):
    el = tile.select_one(selector)
    return el.get_text(strip=True) if el else None

def parse_link(tile):
    a = tile.select_one('a[data-q="search-result-anchor"]')
    if not a or not a.get("href"):
        return None
    href = a["href"]
    return href if href.startswith("http") else BASE + href

def scrape_gumtree_search(html):
    soup = BeautifulSoup(html, "html.parser")
    tiles = soup.select('article[data-q="search-result"]')
    results = []
    for tile in tiles:
        try:
            results.append({
                "title": text_of(tile, 'div[data-q="tile-title"]'),
                "price": text_of(tile, 'div[data-testid="price"]'),
                "location": text_of(tile, 'div[data-q="tile-location"]'),
                "link": parse_link(tile),
            })
        except Exception as e:
            print(f"Skipped a tile: {e}")
    return results

def scrape_pages(base_url, max_pages):
    all_listings = []
    for page in range(1, max_pages + 1):
        page_url = f"{base_url}&page={page}"
        html = crawl(page_url)
        if not html:
            break
        found = scrape_gumtree_search(html)
        if not found:
            break
        all_listings.extend(found)
        print(f"Page {page}: {len(found)} listings")
        time.sleep(2)
    return all_listings

def export(rows, name="gumtree_listings"):
    with open(f"{name}.json", "w", encoding="utf-8") as f:
        json.dump(rows, f, indent=2, ensure_ascii=False)
    with open(f"{name}.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=FIELDS)
        writer.writeheader()
        writer.writerows(rows)
    print(f"Saved {len(rows)} listings to {name}.json and {name}.csv")

def main():
    base_url = "https://www.gumtree.com/search?q=headset"
    rows = scrape_pages(base_url, max_pages=5)
    export(rows)

if __name__ == "__main__":
    main()

Führen Sie das vollständige Skript mit python gumtree_scraper.py aus. Es durchläuft bis zu fünf Seiten der Headset-Suche, parst eine Zeile pro Anzeigenkachel und schreibt sowohl gumtree_listings.json als auch gumtree_listings.csv. Die scrape_pages-Schleife hängt &page=N an die Such-URL an, bricht früh ab, wenn eine Seite keine Kacheln zurückgibt (sodass Sie am Ende der Ergebnisse stoppen, statt leere Seiten abzurufen), und das time.sleep(2) zwischen den Anfragen taktet den Lauf. Die gemeinsame FIELDS-Liste hält die CSV-Spaltenreihenfolge im Einklang mit den Dictionary-Schlüsseln, sodass die beiden Exporte nie auseinanderdriften.

Wie die Ausgabe aussieht

Sie erhalten eine saubere Liste von Anzeigendatensätzen, in Seitenreihenfolge, bereit zum Schreiben nach JSON, CSV oder in eine Datenbank.

[
  {
    "title": "SteelSeries Arctis 7 Wireless Gaming Headset",
    "price": "£65.00",
    "location": "Manchester, Greater Manchester",
    "link": "https://www.gumtree.com/p/headphones/steelseries-arctis-7/1488114476"
  },
  {
    "title": "Sony WH-1000XM4 Noise Cancelling Headphones",
    "price": "£180.00",
    "location": "Leeds, West Yorkshire",
    "link": "https://www.gumtree.com/p/headphones/sony-wh-1000xm4/1483456978"
  }
]

Die CSV spiegelt diese Zeilen mit einer Zeile pro Anzeige unter einem title,price,location,link-Header. Von dort aus können Sie nach Preis sortieren, nach Standort gruppieren, um zu sehen, wo ein bestimmter Artikel am häufigsten vorkommt, oder aufeinanderfolgende Läufe vergleichen, um zu verfolgen, wie sich Anzeigen und Angebotspreise im Zeitverlauf bewegen. Für ein durchgearbeitetes Beispiel, wie man Anzeigenexporte in eine Vergleichsansicht überführt, siehe E-Commerce-Web-Scraping.

Über eine einzelne Suche hinaus skalieren

Dasselbe Muster lässt sich auf so viele Suchen erweitern, wie Sie benötigen. Führen Sie eine Zuordnung von Abfragenamen zu Such-URLs, schleifen Sie darüber und führen Sie den paginierten Scraper für jede einzelne aus, wobei Sie die Ausgabe nach Abfrage schlüsseln, damit die Listen getrennt bleiben. Wenn Sie reichhaltigere Datensätze möchten, folgen Sie dem link jeder Kachel zu ihrer Anzeigenseite und parsen Sie dort die ausführlicheren Felder (die vollständige Beschreibung, das Inseratsdatum, Bild-URLs) und führen Sie diese dann in den Anzeigendatensatz zusammen. So oder so, halten Sie die Anfragerate maßvoll und stützen Sie sich auf die Rotation der Crawling API, damit ein Fan-out über viele Suchen kein Rate-Limit auslöst.

Für lokale Marktforschung ist das Standortfeld der Hebel: das Filtern nach Gegend oder das Scrapen derselben Abfrage über mehrere Stadtsuchen hinweg lässt Sie Preise und Angebot Region für Region vergleichen. Genau das ist die Art von regionalem Signal, für die sich Gumtrees öffentliche Anzeigen gut eignen, und es ist der Grund, warum es sich lohnt, Kleinanzeigendaten in strukturierter Form zu sammeln, statt die Website nur mit dem Auge zu überfliegen.

Nicht gesperrt werden

Selbst wenn das Rendern erledigt ist, achtet Gumtree auf Scraper-förmigen Traffic. Ein paar Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes Kleinanzeigen- oder Marktplatzziel.

• Takten Sie Ihre Anfragen. Verteilen Sie Anfragen mit einer Verzögerung zwischen Seiten und Suchen, statt alles mit voller Geschwindigkeit zu crawlen. Planen Sie schwerere Aufträge in den Nebenzeiten, um die Last auf Gumtrees Servern zu verringern.
• Stützen Sie sich auf Rotation. Ein Pool aus Residential-IPs verteilt Anfragen über viele Adressen echter Nutzer, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack bauen, ist dies der Teil, den Sie richtig hinbekommen müssen.
• Behalten Sie nur, was Sie brauchen. Speichern Sie die öffentlichen Anzeigenfelder, die Ihr Projekt verwendet, und verwerfen Sie den Rest. Überprüfen Sie Ihre Selektoren regelmäßig erneut, damit der Scraper mit Markup-Änderungen Schritt hält.

Für das umfassendere Playbook zum Vermeiden von Sperren siehe wie man Websites scrapt, ohne gesperrt zu werden, und für mehr dazu, warum Rendern hier wichtig ist, wie man JavaScript-Websites crawlt. Wenn Sie die BeautifulSoup-Seite vertiefen möchten, deckt der Leitfaden zur Verwendung von BeautifulSoup in Python die Parsing-Bibliothek im Detail ab.

Ist es legal, Gumtree zu scrapen?

Ob das Scrapen von Gumtree erlaubt ist, hängt von den Nutzungsbedingungen von Gumtree, Ihrer Gerichtsbarkeit und davon ab, was Sie mit den Daten tun. Gumtrees Bedingungen setzen dem automatisierten Zugriff Grenzen, sodass Scraping diesen Bedingungen zuwiderlaufen kann, ganz gleich, wie sorgfältig Ihr Werkzeug ist. Nichts vom Code hier ändert das; er bringt nur den technischen Teil zum Laufen. Lesen Sie Gumtrees Nutzungsbedingungen und seine robots.txt und behandeln Sie beide als die Grenze für das, was Sie sammeln. Für kommerzielle oder wettbewerbliche Nutzung wird das rechtliche Bild komplexer, und einen Rechtsexperten zu Ihrem konkreten Fall zu konsultieren, ist der vernünftige Schritt.

Ein paar Leitlinien, an die es sich zu halten lohnt. Sammeln Sie nur öffentliche Anzeigendaten: die Titel, Preise, Standorte und Anzeigenlinks, die jeder auf einer Suchergebnisseite ohne Konto sehen kann. Sammeln Sie keine personenbezogenen Daten privater Verkäufer: Namen, Telefonnummern, E-Mail-Adressen oder alles, was eine Einzelperson identifizieren könnte, selbst wenn es auf einer öffentlichen Anzeige erscheint. Halten Sie Ihr Anfragevolumen niedrig genug, dass Sie Gumtrees Server nicht belasten, und scrapen Sie niemals etwas hinter einem Login oder einem Kontakt-Freischalt-Schritt, der existiert, um die Details eines Verkäufers abzuschirmen.

Dieser Leitfaden ist bewusst auf öffentliche Suchanzeigenfelder beschränkt, weil das die Linie ist, die die Arbeit vertretbar hält. Er behandelt keine Konto- oder Nachrichtendaten, die persönlichen Kontaktdaten eines Verkäufers oder irgendeinen Versuch, eine Authentifizierung oder ein CAPTCHA zu umgehen, das Sie nicht passieren dürfen. Wenn Ihr Projekt mehr als öffentliche Anzeigendaten benötigt, ist der richtige Weg eine Erlaubnis oder eine Datenvereinbarung, nicht ein cleverer Scraper. Wo eine Website eine offizielle API oder einen Daten-Feed anbietet, bevorzugen Sie diese für lizenzierten oder massenhaften Zugriff.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage keine Anzeigen von Gumtree zurück?

Zwei Gründe. Gumtree befüllt einen Großteil des Ergebnisrasters clientseitig beim Laden der Seite, sodass ein rohes requests.get oft eine Hülle erhält, in der die Anzeigenkacheln fehlen. Obendrein fordert Gumtree Traffic heraus oder sperrt ihn, der nicht wie ein echter Browser aussieht. Die Seite über die Crawling API hinter einer vertrauenswürdigen IP zu rendern, löst beides, weshalb der Scraper hier seine Anfrage darüber leitet.

Welche Daten kann ich von einer Gumtree-Suchseite scrapen?

Aus jeder Ergebniskachel können Sie die öffentlichen Felder lesen, die die Anzeige zeigt: den Titel, den geforderten Preis, den Standort und den Link zur vollständigen Anzeige. Diese Anleitung extrahiert genau diese vier. Dem Link zur Anzeigenseite zu folgen, gibt Ihnen ausführlichere Felder wie die Beschreibung, das Inseratsdatum und Bild-URLs, aber beschränken Sie das Sammeln auf öffentliche Anzeigeninhalte und vermeiden Sie die persönlichen Kontaktdaten eines privaten Verkäufers.

Wie handhabe ich die Paginierung bei Gumtree?

Gumtree paginiert Suchergebnisse mit einem ?page=N-Query-Parameter, sodass Sie &page=2, &page=3 und so weiter an die Such-URL anhängen und jede einzelne abrufen. Die Funktion scrape_pages in diesem Leitfaden schleift über einen Seitenbereich, stoppt früh, wenn eine Seite keine Kacheln zurückgibt, und fügt eine kurze Verzögerung zwischen den Anfragen hinzu, damit Sie die Website nicht überstrapazieren.

Welche Selektoren verwendet der Scraper?

Jedes Ergebnis ist ein article[data-q="search-result"]. Darin ist der Titel div[data-q="tile-title"], der Preis ist div[data-testid="price"], der Standort ist div[data-q="tile-location"], und der Anzeigenlink ist das href auf a[data-q="search-result-anchor"]. Diese data-*-Attribute sind langlebiger als generierte Klassennamen, aber untersuchen Sie die Live-Seite erneut, wenn ein Feld anfängt, leer zurückzukommen.

Kann ich die Daten in eine Tabellenkalkulation exportieren?

Ja. Die Funktion export schreibt sowohl eine JSON-Datei als auch eine CSV mit einem title,price,location,link-Header, eine Zeile pro Anzeige. Öffnen Sie die CSV direkt in Excel, Google Sheets oder einem beliebigen Tabellenkalkulationstool, oder laden Sie das JSON in einen pandas-DataFrame oder ein Notebook zur Analyse und Diagrammerstellung.

Wie vermeide ich es, beim Scrapen von Gumtree gesperrt zu werden?

Halten Sie Ihre Anfragerate pro IP niedrig, fügen Sie eine Verzögerung zwischen Seiten und Suchen hinzu und leiten Sie über rotierende Residential-IPs, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation, einen vertrauenswürdigen IP-Pool und CAPTCHA-Handhabung für Sie; wenn Sie Ihren eigenen Stack bauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Statuscodes und nehmen Sie sich zurück, wenn Sie anfangen, Challenges zu sehen.

HR

Hassan Rehan

Softwareentwickler · Crawlbase

Softwareentwickler bei Crawlbase, der praxisnahe Anleitungen zu rotierenden Proxys, Scraping und den praktischen Details schreibt, Proxys in echten Code einzubinden.