eBay Kleinanzeigen Scraper 2026: Anzeigen automatisch scrapen & auswerten

Täglich erscheinen auf Kleinanzeigen.de – früher bekannt als eBay Kleinanzeigen – Tausende neue Inserate. Wer Preise beobachtet, Markttrends analysiert oder frische Angebote in bestimmten Kategorien im Blick behalten möchte, stößt schnell an die Grenzen der manuellen Suche: Seite für Seite aufrufen, filtern, kopieren, und am nächsten Tag von vorne.

Ein Kleinanzeigen Scraper übernimmt diese Arbeit automatisch. Er ruft Suchergebnisse ab, extrahiert Titel, Preise, Standorte und weitere Felder – und das so oft und regelmäßig, wie Sie es brauchen.

In diesem Artikel zeigen wir Ihnen alle gängigen Methoden im Vergleich: vom vorgefertigten Octoparse-Template über eine API-Alternative bis hin zu einem eigenen Python-Skript. Sie erfahren außerdem, ob es eine offizielle Kleinanzeigen API gibt und welche Alternativen sich lohnen.

Was ist ein eBay Kleinanzeigen Scraper?

Ein Kleinanzeigen Scraper ist ein Programm oder ein No-Code-Workflow, der Suchergebnisse und Anzeigenseiten auf Kleinanzeigen.de automatisch aufruft und die gewünschten Felder strukturiert speichert. Das Ergebnis ist eine saubere Tabelle mit Titeln, Preisen, Standorten und weiteren Datenpunkten, die sich direkt in Excel, Google Sheets oder einer Datenbank weiterverarbeiten lässt.

Dabei werden ausschließlich öffentlich sichtbare Daten erfasst. Das Auslesen von Informationen hinter einem Login, das Umgehen von Sicherheitsmechanismen oder das Speichern personenbezogener Daten ist nicht zulässig und verstößt gegen die Nutzungsbedingungen von Kleinanzeigen sowie die DSGVO.

Welche Daten lassen sich von Kleinanzeigen scrapen?

Eine Anzeige auf Kleinanzeigen enthält weit mehr als nur Titel und Preis. Wer die richtigen Felder ausliest, erhält verwertbare Signale zu Produktzustand, aktueller Nachfrage und regionalen Preisunterschieden. Die folgende Tabelle zeigt, welche Daten sich extrahieren lassen und wofür sie sich in der Praxis nutzen lassen.

Für wen lohnt sich das Scraping?

Kleinanzeigen-Daten sind nicht nur für Schnäppchenjäger interessant. Wer systematisch scrapet, verschafft sich einen echten Informationsvorsprung – je nach Anwendungsfall sieht das allerdings sehr unterschiedlich aus.

Privatkäufer und Sammler beobachten bestimmte Artikel über einen längeren Zeitraum und erkennen so, wann ein Preis wirklich günstig ist und wann er nur günstig wirkt.

Gewerbliche Händler und Reseller verdienen genau an dieser Lücke zwischen Angebots- und Marktpreis. Scraping hilft ihnen, Ankaufspreise realistisch zu kalkulieren, unterbewertete Angebote frühzeitig zu erkennen und das Sortiment von Mitbewerbern im Blick zu behalten.

Marktforscher und Analysten nutzen Kleinanzeigen als Echtzeit-Spiegel der Konsumnachfrage – fernab von offiziellen Statistiken zeigen Gebrauchtpreise oft früher, wohin sich ein Markt entwickelt.

Entwickler und technisch versierte Nutzer automatisieren Kleinanzeigen als Datenquelle für eigene Anwendungen, etwa für Preisalerts, Dashboards oder die Anreicherung interner Produktkataloge.

Ähnliche Möglichkeiten bietet übrigens auch das Scraping von willhaben – der größten Kleinanzeigenplattform Österreichs.

Praxis-Szenario: „IKEA Kallax in Berlin” wöchentlich tracken

Ziel: Ein Gebrauchtmöbel-Händler möchte wissen, zu welchen Preisen das Regal „IKEA Kallax 4×4″ in Berlin gehandelt wird, um realistische Ankauf- und Verkaufspreise festzulegen.

Rahmen

• Zeitraum: jeweils die letzten 7 Tage
• Region: Berlin (PLZ-Bereich 10115–14199)
• Gesucht: Medianpreis, Minimalpreis und Anzahl neuer Inserate pro Woche

Ablauf

1. Der Scraper ruft jeden Freitagabend die Such-URL automatisch ab.
2. Die Ergebnisse werden als CSV gespeichert und auf Google Drive abgelegt.
3. Eine Formel in Google Sheets berechnet automatisch Median- und Minimalpreis.
4. Angebote mehr als 20 % unter dem Median werden als potenzielle Ankaufskandidaten markiert.

Ergebnis (KW 28/2025): 142 Inserate, Medianpreis 55 €, Minimum 20 €, 41 Angebote unter 44 €.

Gibt es eine offizielle Kleinanzeigen API? Alternativen im Vergleich

Viele Entwickler und technisch versierte Nutzer suchen zunächst nach einer offiziellen API, um Kleinanzeigen-Daten direkt und strukturiert abzurufen. Die Antwort ist ernüchternd: Eine offizielle, öffentlich zugängliche API gibt es nicht. Die alte Schnittstelle aus eBay-Zeiten unter api.ebay-kleinanzeigen.de ist nicht mehr nutzbar, und Kleinanzeigen bietet aktuell keinen offiziellen API-Zugang für externe Entwickler an.

Was bleibt, sind drei Alternativen – je nach technischem Hintergrund und Anwendungsfall unterschiedlich gut geeignet.

Kleinanzeigen Agent ist ein spezialisierter Drittanbieter-Dienst, der eine strukturierte API für Kleinanzeigen-Daten anbietet. Suchanfragen, Inseratdetails, Verkäuferprofile und Webhook-Benachrichtigungen bei neuen Inseraten lassen sich darüber programmgesteuert abrufen. Der Dienst richtet sich klar an Entwickler, die eine fertige API-Oberfläche benötigen und bereit sind, dafür ein laufendes Abonnement zu zahlen.

Apify bietet mehrere vorgefertigte Kleinanzeigen-Scraper als sogenannte Actors an. Diese lassen sich über eine API aufrufen und liefern strukturierte Daten zu Preisen, Standorten, Beschreibungen und Bildern. Auch hier ist technisches Grundwissen erforderlich, und die Kosten richten sich nach dem Datenvolumen.

Octoparse geht einen anderen Weg: Statt einer API-Integration reicht eine fertige Vorlage, die ohne Programmierkenntnisse eingerichtet und per Cloud-Modus automatisch ausgeführt wird. Wer regelmäßig Kleinanzeigen-Daten benötigt, richtet den Scraper einmal ein und lässt ihn wöchentlich oder täglich automatisch laufen – ohne eigene Infrastruktur, ohne Code.

Wer Kleinanzeigen-Daten regelmäßig und automatisiert benötigen, ohne dafür Code schreiben oder eine API-Integration aufsetzen zu wollen, kommt mit Octoparse ohne Vorkenntnisse direkt ans Ziel. Einfach Vorlage auswählen, Suchparameter eingeben, Cloud-Zeitplan einrichten – fertig. Wer hingegen eine API-Schnittstelle in eine bestehende Anwendung einbinden möchte, ist mit Kleinanzeigen Agent oder Apify besser bedient.

Octoparse 14 Tage kostenlos testen →

Wie kann man eBay Kleinanzeigen ohne Codierung scrapen?

Für Nutzer ohne technischen Hintergrund gibt es zwei Wege, Kleinanzeigen-Daten mit Octoparse zu extrahieren – je nachdem, ob Sie schnell starten oder flexibel anpassen möchten.

Methode 1: Vorgefertigter eBay Kleinanzeigen Scraper (Template)

Octoparse bietet zwei aufeinander abgestimmte Vorlagen für Kleinanzeigen, die sich je nach Anwendungsfall einzeln oder kombiniert einsetzen lassen.

Vorlage 1: Kleinanzeigen Scraper (Product Listing)

https://www.octoparse.de/console/template/kleinanzeigen-scraper-product-listing

Extrahiert Daten aus Suchergebnisseiten: Titel, Preis, Standort, Beschreibung, Ankündigungszeit, Bild-URL und den direkten Link zur Anzeige.

Vorlage 2: Kleinanzeigen Scraper (Product Details)

https://www.octoparse.de/template/kleinanzeigen-scraper-product-details

Extrahiert Detaildaten einzelner Anzeigen: Firma, Versandsmethode, Zufriedenheitsbewertung und weitere Felder, die auf der Listenseite nicht sichtbar sind.

So funktioniert es:

1. Klicken Sie auf der Vorlagenseite auf „Versuchen!” und melden Sie sich bei Octoparse an.
2. Geben Sie die gewünschten URLs ein – eine pro Zeile. Mehrere URLs können gleichzeitig verarbeitet werden.
3. Klicken Sie auf „Starten”. Die beiden Vorlagen laufen ausschließlich im Cloud-Modus – Octoparse übernimmt die Ausführung auf seinen Servern, ohne dass Ihr Computer dabei laufen muss.

Wichtiger Hinweis zur URL bei der Listing-Vorlage:

Die eingegebene URL muss bereits die gewünschte Region enthalten. Konfigurieren Sie daher auf Kleinanzeigen.de zuerst den Standort – entweder durch Auswahl einer Stadt, eines Bundeslandes oder durch Eingabe einer Postleitzahl – und kopieren Sie erst dann die URL aus der Adressleiste. Wenn Sie unsicher sind, ob Ihre URL korrekt ist, orientieren Sie sich am Beispiel im Eingabefeld: https://www.kleinanzeigen.de/s-berlin/sofa/k0l3331

Ein Praxistest:

mit der Suchanfrage „Sofa in Berlin” zeigt sich, was die Vorlage leistet: In 3 Minuten wurden 1538 Inserate erfasst – inklusive Produkttitel, Preis, Standort, Beschreibung, Bild-URL und direktem Anzeigen-Link.

Der Cloud-Modus hat dabei 20 verfügbare Knoten genutzt und 0 CAPTCHAs ausgelöst. Zusätzlich kennzeichnet die Vorlage automatisch gewerbliche PRO-Inserate, sodass sich private und gewerbliche Angebote direkt in der Auswertung unterscheiden lassen.

So sieht der Datenexport im CSV-Format aus:

Listing und Details kombinieren:

Für eine vollständige Datenbasis lassen sich beide Vorlagen hintereinanderschalten. Mit dem Listing Scraper sammeln Sie zunächst die Produkt_url-Spalte aus den Suchergebnissen. Diese URLs importieren Sie anschließend direkt in den Details Scraper – entweder manuell oder über „Aus Datei importieren” – und erhalten so die Detaildaten zu jedem einzelnen Inserat.

Datenvorschau in Excel-Format:

Web oder Desktop App?

Beide Vorlagen laufen im Browser und in der Desktop-App. Für größere Datenmengen empfiehlt sich die Desktop-App: Sie bietet erweiterte Konfigurationsoptionen, eine stabilere Ausführungsumgebung und integrierten Proxy-Support für zuverlässigere Ergebnisse.

Octoparse: Einfaches Web Scraping Tool für jeden

Kostenloser Download

Anmeldung

Konvertiere Website-Daten direkt in Excel, CSV, Google Sheets und Ihre Datenbank.

Scrape Daten einfach mit Auto-Dedektion, ganz ohne Coding.

Scraping-Vorlagen für beliebte Websites, um Daten mit wenigen Klicks zu erhalten.

Mit IP-Proxys und fortschrittlicher API wird nie blockiert.

Cloud-Dienst zur Planung von Datenabfragen zu jedem gewünschten Zeitpunkt.

Methode 2: Auto-Detect in Octoparse

Auto-Detect ist die richtige Wahl, wenn das Template nicht zu Ihrem Anwendungsfall passt – etwa weil Sie zusätzliche Felder auslesen möchten, die die Vorlage nicht abdeckt, oder weil sich das Seitenlayout geändert hat.

Fügen Sie die gewünschte Such-URL in Octoparse ein und klicken Sie auf „Auto-Detect Website Data”. Das Tool erkennt automatisch die Struktur der Seite und markiert alle Anzeigen-Kacheln. Fehlende Felder lassen sich per Klick ergänzen. Aktivieren Sie anschließend Pagination, damit auch die Folgeseiten erfasst werden, schalten Sie die Proxy-Rotation ein und starten Sie den Task.

Der Unterschied zum Template: mehr Flexibilität bei der Feldauswahl und der Seitenstruktur, dafür etwas mehr Einrichtungsaufwand. Für den regelmäßigen Einsatz empfiehlt sich die Desktop-App – sie bietet stabilere Ausführung, erweiterte Proxy-Konfiguration und mehr Kontrolle über den gesamten Workflow.

Zusammenfassung: Greifen Sie zum Template, wenn Sie ohne Vorarbeit schnell zahlreiche Standarddaten extrahieren möchten; wählen Sie Auto-Detect, sobald das Layout abweicht oder Sie zusätzliche, individuell definierte Felder benötigen.

Mit Python scrapen

Für Teams mit Entwickler-Know-how kann ein eigener Python-Crawler sinnvoll sein – besonders wenn die Daten direkt in eine bestehende Pipeline oder Datenbank fließen sollen, ohne Zwischenschritte über ein externes Tool.

Die Vorteile: vollständige Kontrolle über jeden Request, direkte Datenbankanbindung und die Möglichkeit, eigene Filter- und Verarbeitungsregeln einzubauen. Der Nachteil: Der Crawler muss bei Layout-Änderungen manuell angepasst werden, und Anti-Bot-Maßnahmen wie IP-Sperren müssen selbst gehandhabt werden.

Das folgende Code-Beispiel scrapet IKEA-Kallax-Regale in Berlin – passend zum Praxis-Szenario weiter oben – und exportiert die Ergebnisse als CSV:

import requests
import pandas as pd
import time
import random
import logging
from datetime import datetime
from bs4 import BeautifulSoup
from retrying import retry  # Benötigt: pip install retrying

# ----------------------------
# Konfiguration & Einstellungen
# ----------------------------
CONFIG = {
    "basis_url": "https://www.kleinanzeigen.de/s-berlin/kallax/k013331?seite={}",
    "anzahl_seiten": 10,  # Mehr Seiten als ursprünglich
    "wartezeit_min": 1.5,  # Dynamischere Wartezeiten
    "wartezeit_max": 2.5,
    "proxies": [
        "http://34.159.111.0:3128",
        "http://88.99.0.0:8080",
        "http://138.197.209.0:8080"  # Zusätzlicher Proxy
    ],
    "user_agents": [  # Rotation von User-Agents
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.5 Safari/605.1.15",
        "Mozilla/5.0 (X11; Linux x86_64) Firefox/113.0"
    ],
    "ausgabedatei_csv": "kallax_berlin_erweitert.csv",
    "ausgabedatei_json": "kallax_berlin_erweitert.json"
}

# Logging konfigurieren (zur Fehlersuche)
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[logging.FileHandler("scraper_log.log"), logging.StreamHandler()]
)
logger = logging.getLogger(__name__)


# ----------------------------
# Funktionen mit Fehlerbehandlung
# ----------------------------
@retry(
    stop_max_attempt_number=3,  # Maximal 3 Versuche bei Fehlern
    wait_exponential_multiplier=1000,  # Wartet 1s, 2s, 4s zwischen Versuchen
    retry_on_exception=lambda e: isinstance(e, (requests.exceptions.RequestException, ConnectionError))
)
def hole_seite(url):
    """
    Lädt eine Webseite mit zufälligem Proxy und User-Agent.
    Mit Retry-Mechanismus bei Netzwerkfehlern.
    """
    proxy = {"http": random.choice(CONFIG["proxies"])}
    user_agent = random.choice(CONFIG["user_agents"])
    headers = {"User-Agent": user_agent, "Accept-Language": "de-DE,de;q=0.9"}

    logger.info(f"Lade Seite: {url} (Proxy: {proxy['http'].split('@')[-1]})")
    antwort = requests.get(
        url,
        headers=headers,
        proxies=proxy,
        timeout=15  # Längerer Timeout für instabile Proxies
    )
    antwort.raise_for_status()  # Fehler bei 4xx/5xx Statuscodes
    logger.debug(f"Seite geladen (Status-Code: {antwort.status_code})")
    return antwort.text


def parse_anzeigen(html_inhalt):
    """
    Parst HTML-Inhalt und extrahiert detaillierte Daten aus Kleinanzeigen.
    Enthält Fehlerbehandlung für fehlende Elemente.
    """
    suppe = BeautifulSoup(html_inhalt, "html.parser")
    anzeigen = suppe.select("article.aditem")  # Selektor für Anzeigencontainer

    if not anzeigen:
        logger.warning("Keine Anzeigen auf der Seite gefunden - evtl. Selektor veraltet?")
        return

    for anzeige in anzeigen:
        # Extrahiere Felder mit Fallback bei fehlenden Elementen
        titel_element = anzeige.select_one(".text-module-begin h2")
        titel = titel_element.get_text(strip=True) if titel_element else "Ohne Titel"

        preis_element = anzeige.select_one(".aditem-main--middle .price")
        preis = preis_element.get_text(strip=True) if preis_element else "Nicht angegeben"

        ort_datum_element = anzeige.select_one(".aditem-main--top .aditem-addon")
        ort_datum = ort_datum_element.get_text(strip=True) if ort_datum_element else "Unbekannt"
        ort, datum = (ort_datum.split("•") if "•" in ort_datum else (ort_datum, "Unbekannt"))

        beschreibung_element = anzeige.select_one(".aditem-main--middle .aditem-description")
        beschreibung = beschreibung_element.get_text(strip=True)[:200] if beschreibung_element else ""  # Kurzfassung

        link_element = anzeige.get("data-href")
        vollstaendiger_link = f"https://www.kleinanzeigen.de{link_element}" if link_element else "Kein Link"

        # Gibt ein Dictionary pro Anzeige zurück
        yield {
            "titel": titel,
            "preis": preis,
            "ort": ort.strip(),
            "erstellungsdatum": datum.strip(),
            "beschreibung_kurz": beschreibung,
            "link": vollstaendiger_link,
            "gescrapet_am": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        }


def bereinige_daten(df):
    """
    Bereinigt und transformiert die extrahierten Daten:
    - Preis in numerischen Wert umwandeln
    - Datumswerte formatieren
    - Duplikate entfernen
    """
    logger.info("Bereinige Daten...")

    # Preis bereinigen (entferne Währungszeichen, "VB" etc.)
    df["preis_eur"] = df["preis"].str.extract(r"(\d+,\d+|\d+)").replace(",", ".", regex=True)
    df["preis_eur"] = pd.to_numeric(df["preis_eur"], errors="coerce")  # Ungültige Werte zu NaN

    # "VB" (Verhandlungsbasis) markieren
    df["ist_verhandelbar"] = df["preis"].str.contains("VB", case=False, na=False)

    # Erstelldatum formatieren
    df["erstellungsdatum_aufbereitet"] = pd.to_datetime(
        df["erstellungsdatum"],
        format="%d.%m.%Y",
        errors="coerce"
    )

    # Duplikate entfernen (basierend auf Link)
    df = df.drop_duplicates(subset=["link"], keep="first")
    logger.info(f"Nach Bereinigung: {len(df)} eindeutige Anzeigen")
    return df


def haupt_prozess():
    """Hauptfunktion: Koordiniert Scraping, Parsing und Datenaufbereitung"""
    logger.info("Starte eBay Kleinanzeigen Scraper...")
    datensaetze = []

    try:
        # Durch Seiten iterieren (Pagination)
        for seite in range(1, CONFIG["anzahl_seiten"] + 1):
            url = CONFIG["basis_url"].format(seite)
            try:
                html = hole_seite(url)
                anzeigen_daten = list(parse_anzeigen(html))
                datensaetze.extend(anzeigen_daten)
                logger.info(f"Seite {seite} verarbeitet ({len(anzeigen_daten)} Anzeigen)")
            except Exception as e:
                logger.error(f"Fehler bei Seite {seite}: {str(e)}", exc_info=True)
                continue  # Nächste Seite versuchen

            # Zufällige Wartezeit (um Anti-Bot-Maßnahmen zu umgehen)
            wartezeit = random.uniform(CONFIG["wartezeit_min"], CONFIG["wartezeit_max"])
            time.sleep(wartezeit)

        # Datenaufbereitung
        if not datensaetze:
            logger.warning("Keine Daten gesammelt - Scraping abgebrochen")
            return

        df = pd.DataFrame(datensaetze)
        df_bereinigt = bereinige_daten(df)

        # Statistische Auswertung
        statistik = {
            "durchschnittspreis": df_bereinigt["preis_eur"].mean().round(2),
            "medianpreis": df_bereinigt["preis_eur"].median(),
            "anzahl_verhandelbar": df_bereinigt["ist_verhandelbar"].sum(),
            "anzahl_total": len(df_bereinigt)
        }
        logger.info(f"Statistik: {statistik}")

        # Speichern der Daten
        df_bereinigt.to_csv(CONFIG["ausgabedatei_csv"], index=False, encoding="utf-8-sig")
        df_bereinigt.to_json(CONFIG["ausgabedatei_json"], orient="records", force_ascii=False)
        logger.info(f"Daten gespeichert in {CONFIG['ausgabedatei_csv']} und {CONFIG['ausgabedatei_json']}")

    except KeyboardInterrupt:
        logger.info("Scraper manuell gestoppt")
    except Exception as e:
        logger.critical(f"Kritischer Fehler im Hauptprozess: {str(e)}", exc_info=True)


if __name__ == "__main__":
    haupt_prozess()

Ein paar Hinweise zum Code:

• Proxy-Rotation: Wechselt bei jedem Request zufällig zwischen hinterlegten Proxies, um IP-Sperren zu vermeiden.
• Wartezeiten: Eine Pause von 1–2 Sekunden hält die Abrufrate unter 1 Request pro Sekunde.
• Pagination: Den Bereich in range() anpassen, um mehr Seiten zu erfassen.
• Datenbereinigung: Preisangaben wie „55 € VB” werden per Regex in numerische Werte umgewandelt.

Möchten Sie mehr Ergebnisse, erhöhen Sie den Seitenbereich zum Beispiel auf range(1, 11). Das liefert rund hundert Inserate. Für eine andere Region tauschen Sie die PLZ-ID aus, etwa von l3331 (Berlin) auf l3332 (Potsdam). Mehrere Suchbegriffe lassen sich über eine Schleife mit verschiedenen Basis-URLs verarbeiten. Soll der Crawl automatisch laufen, legen Sie das Skript auf einem Linux-Server ab und hinterlegen einen Cron-Job über crontab -e. Wenn Sie die Daten direkt in Ihre Datenbank schreiben möchten, verbinden Sie sich per SQLAlchemy und speichern sie mit df.to_sql(‘tab_kallax’, engine) unmittelbar in der gewünschten Tabelle.

Octoparse oder Python – was passt besser?

Beide Ansätze haben ihre Berechtigung. Welcher besser passt, hängt vor allem vom technischen Hintergrund und dem geplanten Einsatzzweck ab.

Für Nutzer ohne Programmiererfahrung, die schnell und zuverlässig Daten benötigen, ist Octoparse die direktere Wahl. Python lohnt sich, wenn die Daten in eine bestehende technische Infrastruktur integriert werden sollen oder sehr spezifische Anpassungen nötig sind.

Ergebnisse auswerten – von Excel bis KI

Die gesammelten Daten sind erst dann wertvoll, wenn sie sich auswerten lassen. Octoparse exportiert direkt als CSV, Excel oder JSON – bereit für die weitere Verarbeitung.

In Excel oder Google Sheets lassen sich die Daten ohne weitere Schritte importieren. Ein paar nützliche Formeln reichen, um schnell einen Überblick zu bekommen:

• =MEDIAN(E:E) berechnet den Medianpreis aller Inserate
• =MIN(E:E) zeigt das günstigste Angebot
• Eine bedingte Formatierung markiert automatisch alle Preise unterhalb eines definierten Schwellenwerts

Wer regelmäßig scrapt, kann den Export direkt mit Google Sheets verknüpfen und so eine Tabelle aufbauen, die sich bei jedem neuen Crawl automatisch aktualisiert.

Wer einen Schritt weitergehen möchte, kann Octoparse über MCP direkt in KI-Assistenten wie Claude einbinden. Statt Daten manuell zu exportieren und hochzuladen, lässt sich der gesamte Workflow per Texteingabe steuern.

Ein Beispiel aus der Praxis

Mit dem Prompt

„Starte die Octoparse-Vorlage Kleinanzeigen Scraper (Product Listing) mit dieser URL: https://www.kleinanzeigen.de/s-berlin/sofa/k0l3331 und exportiere die Ergebnisse als CSV.”

startet Claude automatisch den Scraping-Task, wartet auf den Abschluss und liefert die Ergebnisse direkt zurück.

Anschließend lassen sich die Daten direkt im selben Chat auswerten. Ein paar Beispiele, was sich daraus herauslesen lässt:

Preisanalyse:
„Berechne den Medianpreis und den Durchschnittspreis aller Sofas. Wie viele Inserate liegen mehr als 20 % unter dem Median?”

Markteinblick:
„Welche Sofa-Typen werden am häufigsten angeboten und zu welchen Durchschnittspreisen?”

Ankaufsstrategie:
„Ich möchte Sofas unter 100 € ankaufen und für 200 € weiterverkaufen. Wie viele potenzielle Ankaufskandidaten gibt es aktuell in Berlin?”

Anomalieerkennung:
„Gibt es Verkäufer mit ungewöhnlich vielen Inseraten – könnten das gewerbliche Händler sein, die als Privatperson inserieren?”

Die gesamte Kette – von der Datenerhebung bis zur Analyse – läuft ohne manuellen Export oder Toolwechsel.

💡 Tipp: Bei größeren Datenmengen kann der Export über MCP etwas länger dauern. In diesem Fall öffnen Sie einfach die Octoparse Desktop-App, suchen Sie den Task anhand der Task-ID und exportieren Sie die Daten direkt dort. Die exportierte CSV-Datei lässt sich anschließend in jeden KI-Assistenten hochladen und weiterverarbeiten.

Wie oft darf man scrapen? – Rechtliche Rahmenbedingungen & robots.txt

Bevor Sie mit dem Scraping beginnen, lohnt ein Blick auf die rechtlichen Rahmenbedingungen. Laut den Nutzungsbedingungen von Kleinanzeigen.de und der robots.txt ist automatisierter Zugriff durch Dritte nicht ausdrücklich erlaubt.

Das bedeutet in der Praxis: Scraping bewegt sich in einer rechtlichen Grauzone. Eine Reihe von Grundregeln hilft, das Risiko zu minimieren:

• Nur öffentlich zugängliche Daten erfassen – kein Login, keine gesperrten Bereiche. Anders als ein einfacher kleinanziegen Bot, der Seiten unkontrolliert abruft, hält Octoparse definierte Wartezeiten ein und lässt sich auf bestimmte Seitenbereiche begrenzen.
• Wartezeiten zwischen den Requests einhalten – mindestens 1–2 Sekunden, um den Server nicht zu überlasten
• Keine personenbezogenen Daten speichern – Namen, Telefonnummern oder E-Mail-Adressen unterliegen der DSGVO
• Kein Umgehen von Captchas oder anderen Schutzmaßnahmen
• Daten nur für den eigenen Bedarf verwenden – kein Weiterverkauf oder öffentliche Veröffentlichung

Die aktuelle robots.txt von Kleinanzeigen.de lässt sich jederzeit unter https://www.kleinanzeigen.de/robots.txt einsehen.

Für gewerbliche oder rechtlich sensible Anwendungsfälle empfiehlt sich eine Rücksprache mit einem auf IT-Recht spezialisierten Anwalt.

Fazit

Kleinanzeigen ist eine der reichhaltigsten öffentlichen Datenquellen für den deutschen Gebrauchtmarkt – und wer sie systematisch auswertet, verschafft sich einen echten Informationsvorsprung, ob als Händler, Analyst oder Entwickler.

Für den schnellen Einstieg ohne Programmierkenntnisse sind die beiden Octoparse-Vorlagen die direkteste Lösung: Der Listing Scraper erfasst Suchergebnisse in Minuten, der Details Scraper liefert die Tiefendaten einzelner Inserate. Wer beide kombiniert, bekommt ein vollständiges Bild des Markts.

Für Teams mit technischem Hintergrund bietet Python maximale Flexibilität – allerdings auf Kosten von Einrichtungsaufwand und Wartung. Und wer Kleinanzeigen-Daten direkt in einen KI-gestützten Workflow einbinden möchte, findet mit Octoparse MCP einen Weg, Scraping, Export und Analyse in einem einzigen Chat zu bündeln.

Eine offizielle API gibt es nicht. Wer eine strukturierte Schnittstelle benötigt, greift zu Kleinanzeigen Agent oder Apify – mit dem Unterschied, dass beide technisches Know-how voraussetzen und nach Volumen abrechnen.

Was auch immer der Anwendungsfall: Halten Sie sich an die robots.txt, vermeiden Sie das Speichern personenbezogener Daten und respektieren Sie die Serverkapazitäten der Plattform.

Octoparse 14 Tage kostenlos testen →

Häufig gestellte Fragen (FAQ)

Was ist der Unterschied zwischen dem Listing Scraper und dem Details Scraper?

Der Listing Scraper erfasst Daten aus den Suchergebnisseiten: Titel, Preis, Standort, Beschreibung, Versandstatus und den direkten Link zur Anzeige. Der Details Scraper ruft diese Links auf und extrahiert zusätzliche Felder aus der einzelnen Anzeigenseite, etwa Verkäuferbewertungen, Firmennamen und weitere Detailangaben. Für eine vollständige Datenbasis empfiehlt sich die Kombination beider Vorlagen: zuerst die Produkt-URLs mit dem Listing Scraper sammeln, dann als Batch in den Details Scraper importieren.

Kann ich Kleinanzeigen-Daten automatisch täglich oder wöchentlich aktualisieren?

Ja. In Octoparse lässt sich für jeden Task ein Cloud-Zeitplan einrichten, der den Scraper automatisch zu einem festgelegten Zeitpunkt startet – täglich, wöchentlich oder in einem eigenen Intervall. So bleiben Ihre Daten immer aktuell, ohne dass Sie manuell eingreifen müssen.

Was tue ich, wenn der Scraper plötzlich keine Daten mehr liefert?

Mögliche Ursachen gibt es mehrere. Am häufigsten liegt es an einer Änderung des Seitenlayouts von Kleinanzeigen – neue HTML-Strukturen, geänderte CSS-Selektoren oder angepasste Ladelogik können dazu führen, dass bestehende Tasks ins Leere laufen. Auch Proxy-Probleme, eine instabile Internetverbindung oder temporäre Sperren durch Anti-Bot-Maßnahmen der Plattform können die Ursache sein.

Als ersten Schritt empfiehlt sich ein Blick ins Octoparse Template Center: Die offiziellen Vorlagen werden regelmäßig gewartet und an Layout-Änderungen angepasst – ein Update der Vorlage löst das Problem in vielen Fällen sofort. Hilft das nicht, lässt sich mit der Auto-Detect-Funktion ein neuer Task auf Basis der aktuellen Seitenstruktur erstellen. Für Proxy-Probleme empfiehlt sich die Aktivierung der automatischen Proxy-Rotation in den Task-Einstellungen.

Sollte das Problem weiterhin bestehen, steht das Octoparse Support-Team unter support@octoparse.com zur Verfügung.

Kann ich nach Postleitzahl oder Umkreis filtern?

Ja. Kleinanzeigen bietet eine Umkreissuche, bei der Sie einen Radius in Kilometern um eine Postleitzahl festlegen können. Konfigurieren Sie den Filter direkt auf Kleinanzeigen.de und kopieren Sie anschließend die generierte URL in Octoparse – der Umkreis ist in der URL bereits enthalten und wird beim Scraping automatisch berücksichtigt.

Wie viele Inserate kann ich mit einem Durchlauf erfassen?

Das hängt von der Anzahl der Suchergebnisseiten ab. In einem Praxistest mit der Suche „Sofa in Berlin” wurden in unter zwei Minuten 745 Inserate erfasst. Theoretisch gibt es keine feste Obergrenze – je mehr Seiten die Suche liefert, desto mehr Datensätze werden erfasst.

Kann ich Kleinanzeigen auch ohne technische Kenntnisse über MCP automatisieren?

Ja. Mit dem Octoparse MCP Server lässt sich der gesamte Workflow per Texteingabe steuern: Task starten, Daten abrufen und exportieren – alles über einen KI-Assistenten wie Claude, ohne Code oder manuelle Konfiguration. Eine Anleitung zur Einrichtung finden Sie unter octoparse.de/mcp.

Octoparse: Einfaches Web Scraping Tool für jeden

Kostenloser Download

Anmeldung

Konvertiere Website-Daten direkt in Excel, CSV, Google Sheets und Ihre Datenbank.

Scrape Daten einfach mit Auto-Dedektion, ganz ohne Coding.

Scraping-Vorlagen für beliebte Websites, um Daten mit wenigen Klicks zu erhalten.

Mit IP-Proxys und fortschrittlicher API wird nie blockiert.

Cloud-Dienst zur Planung von Datenabfragen zu jedem gewünschten Zeitpunkt.