Monster-Stellenanzeigen mit Python scrapenöffentliche Stellenausschreibungen als strukturierte Datensätze

Monster ist eine der größeren Jobbörsen im Web mit Tausenden aktiver Inserate aus verschiedenen Branchen und Regionen. Jede öffentliche Stellenanzeige enthält die Art strukturierter Signale, die Arbeitsmarktforschung, wettbewerbliche Recruiter-Analysen und benutzerdefinierte Jobsuche-Tools antreiben: Jobtitel, einstellendes Unternehmen, Standort, Veröffentlichungsdatum und ein Link zum vollständigen Inserat. Das Problem: Monster baut seine Suchergebnisse im Browser mit JavaScript auf und lädt beim Scrollen weitere Karten nach, sodass eine einfache HTTP-Anfrage eine nahezu leere Hülle statt der gesuchten Inserate liefert.

Dieser Leitfaden zeigt Ihnen, wie Sie Monster-Stellenanzeigen mit Python scrapen auf zuverlässige Weise. Sie erstellen einen kleinen, lauffähigen Scraper, der eine gerenderte Suchseite über die Crawling API abruft, jede Job-Karte mit BeautifulSoup parst und saubere strukturierte Ausgabe liefert. Die gesamte Anleitung beschränkt sich auf öffentliche Stellenanzeigendaten, und der Rechtsabschnitt am Ende ist kein Boilerplate, also lesen Sie ihn, bevor Sie dies auf reales Volumen richten.

Was Sie erstellen werden

Ein Python-Skript, das eine öffentliche Monster-Such-URL übernimmt, das gerenderte HTML über die Crawling API abruft und für jedes Inserat auf der Seite einen strukturierten Datensatz extrahiert. Wir verwenden eine Entwicklerjob-Suche als laufendes Beispiel und ziehen diese Felder pro Inserat:

• Jobtitel die ausgeschriebene Stelle, zum Beispiel "Java Developer".
• Unternehmen der Arbeitgeber hinter dem Inserat.
• Standort wo der Job angesiedelt ist, zum Beispiel "New York, NY".
• Veröffentlichungsdatum wie kürzlich das Inserat erschienen ist, wenn Monster es für das Inserat anzeigt.
• Job-URL der Link zum vollständigen Inserat, damit Sie pro Stelle nachfassen können.

Warum eine einfache Anfrage bei Monster scheitert

Wenn Sie eine Monster-Such-URL mit einem einfachen HTTP-Client anfordern, erhalten Sie eine Antwort mit Status 200 und fast keine Inserat-Daten im Body. Zwei Dinge arbeiten gegen Sie. Erstens rendert Monster seine Job-Karten im Browser mit JavaScript, sodass das anfängliche HTML eine Hülle ist, die sich erst füllt, nachdem die Skripte der Seite ausgeführt wurden. Zweitens verwendet die Ergebnisseite scroll-basierte Paginierung: Mehr Karten laden, wenn ein echter Benutzer nach unten scrollt, sodass selbst ein zu früh aufgenommener gerenderter Snapshot nur die ersten paar Jobs erfasst.

Ein funktionierender Monster-Scraper braucht also drei Dinge in einer Anfrage: einen Browser, der die Seite tatsächlich rendert, eine IP, die die Plattform als echten Besucher liest, und eine Möglichkeit, den Scroll anzutreiben, damit die lazy-geladenen Karten erscheinen. Sie können das selbst mit einem Headless-Browser, einem Scroll-Skript und einem Pool aus rotierenden Residential-Proxys zusammensetzen, aber diese zusammenzufügen und gesund zu halten ist der größte Teil der Arbeit. Die Crawling API fasst alle drei in einem einzigen Aufruf zusammen: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert und scrollt die Seite hinter einer vertrauenswürdigen IP und gibt Ihnen fertiges HTML zum Parsen zurück.

Voraussetzungen

Sie benötigen einige Vorbereitungen, bevor Sie Code schreiben. Keine davon dauert lange.

Python-Grundkenntnisse. Sie sollten in der Lage sein, ein Python-Skript zu schreiben und auszuführen sowie Pakete mit pip zu installieren. Falls Sie neu im Parsen von HTML sind, deckt unser Primer über wie man BeautifulSoup in Python verwendet die Selektor-Grundlagen ab, auf die dieses Tutorial aufbaut.

Python 3.8 oder höher. Bestätigen Sie Ihre Version mit python --version. Falls nicht vorhanden, installieren Sie es von python.org oder über eine Distribution wie Anaconda.

Ein Crawlbase-Konto und ein JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript (JS)-Token von der Konto-Docs-Seite. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, also halten Sie es aus der Versionskontrolle heraus. Das kostenlose Kontingent umfasst genug Anfragen, um diesem Leitfaden von Anfang bis Ende zu folgen.

Das Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, um Projektabhängigkeiten isoliert zu halten, und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt.

python --version

python -m venv monster_env
source monster_env/bin/activate

pip install crawlbase beautifulsoup4

Unter Windows aktivieren Sie die Umgebung mit monster_env\Scripts\activate statt der source-Zeile. Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, und beautifulsoup4 parst das zurückgegebene HTML, damit Sie einzelne Felder per CSS-Selektor herausziehen können.

Schritt 1: Die gerenderte Suchseite abrufen

Beginnen Sie damit, die fertige Seite zu laden. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem JS-Token und fordern Sie die Such-URL an. Die Statusprüfung vor dem Parsen macht Fehler laut statt still. Beachten Sie die zwei Wait-Optionen: ajax_wait weist die API an, auf das Beenden des Ladens asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden an, damit spät rendernde Karten erscheinen, bevor die Seite erfasst wird.

from crawlbase import CrawlingAPI

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

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

if __name__ == "__main__":
    page_url = "https://www.monster.com/jobs/search?q=Java+Developer&where=New+York"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Führen Sie das Skript mit python scraper.py aus und Sie sollten echtes Job-Karten-Markup sehen, nicht die leere Hülle, die eine einfache Anfrage zurückgibt. Fünf Sekunden ist ein vernünftiger Ausgangswert für page_wait; erhöhen Sie ihn, wenn die Karten leer zurückkommen. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Die Job-Karten-Struktur inspizieren

Bevor Sie Selektoren schreiben, öffnen Sie eine Monster-Suchseite in Ihrem Browser und inspizieren Sie eine Job-Karte mit den Entwicklertools. Zum Zeitpunkt dieses Schreibens befindet sich jedes Inserat in einem <article> mit einem data-testid="svx_jobCard"-Attribut, gruppiert innerhalb eines Containers mit der ID JobCardGrid. Innerhalb jeder Karte hängen die gewünschten Felder an stabilen Test-IDs:

• Jobtitel und URL befinden sich auf einem <a data-testid="jobTitle">: der Link-Text ist der Titel, das href ist die Inserat-URL.
• Unternehmen sitzt in einem <span data-testid="company">.
• Standort sitzt in einem <span data-testid="jobDetailLocation">.
• Veröffentlichungsdatum erscheint in einem <span data-testid="jobDetailDateRecency">, wenn Monster es für das jeweilige Inserat anzeigt.

Das gezielte Ansprechen von data-testid-Attributen statt CSS-Klassennamen ist bewusst. Monster liefert gehashte, build-generierte Klassennamen, die sich bei jedem Deploy ändern, während Test-IDs tendenziell stabil bleiben, weil die eigene Testsuite der Seite davon abhängt. Sie sind die dauerhaftesten Anker, die die Seite bietet.

Schritt 3: Die Job-Karten mit BeautifulSoup parsen

Mit gerendertem HTML in der Hand laden Sie es in BeautifulSoup, wählen jede Job-Karte aus und ziehen jedes Feld per Test-ID von der Karte. Jedes Feldlesen in einem kleinen Helfer zu verpacken, der einen leeren String zurückgibt, wenn ein Element fehlt, verhindert, dass ein fehlendes Feld den Lauf abbricht.

from bs4 import BeautifulSoup

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

def parse_jobs(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('div#JobCardGrid article[data-testid="svx_jobCard"]')

    jobs = []
    for card in cards:
        title_link = card.select_one('a[data-testid="jobTitle"]')
        jobs.append({
            "title": title_link.get_text(strip=True) if title_link else "",
            "company": text_of(card, 'span[data-testid="company"]'),
            "location": text_of(card, 'span[data-testid="jobDetailLocation"]'),
            "posted": text_of(card, 'span[data-testid="jobDetailDateRecency"]'),
            "url": title_link["href"] if title_link else "",
        })
    return jobs

Der Titel-Link wird einmal gelesen und wiederverwendet, da er sowohl den Titeltext als auch die Inserat-URL in seinem href trägt. Alles andere fließt durch den text_of-Helfer, der ein einzelnes Element abfragt und einen leeren String zurückgibt, wenn es fehlt, statt bei einem .get_text()-Aufruf gegen nichts zu werfen. Das hält die Extraktion robust, wenn eine Karte ein Feld weglässt, was häufig vorkommt, da nicht jedes Inserat ein Veröffentlichungsdatum anzeigt.

Schritt 4: Die vollständige Ergebnisseite mit Scrolling erfassen

Der Abruf in Schritt 1 rendert die Seite, aber Monster lädt nur die erste Charge von Karten, bis der Benutzer scrollt. Um den gesamten Ergebnissatz in einer Anfrage zu ziehen, übergeben Sie die Scroll-Arbeit an die Crawling API statt einen Headless-Browser selbst zu betreiben. Zwei Optionen steuern es: scroll aktiviert scroll-basierte Paginierung, und scroll_interval legt fest, wie lange die API weiterscrollt, in Sekunden, bis zu einem Maximum von 60. Wenn Scrolling aktiviert ist, brauchen Sie page_wait nicht zusätzlich zu setzen, da das Scroll-Fenster Inhalte bereits Zeit zum Laden gibt.

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

Tauschen Sie crawl_with_scroll gegen das einfache crawl aus, wenn Sie die vollständige Seite statt nur der ersten Karten möchten. Der Parser aus Schritt 3 ändert sich nicht: Er wählt weiterhin jede svx_jobCard im zurückgegebenen HTML aus, nur dass es jetzt mehr davon gibt.

Schritt 5: Alles zusammensetzen und als JSON speichern

Verbinden Sie nun den gescrollten Abruf, den Parser und einen kleinen JSON-Writer in einem lauffähigen Skript. Rufen Sie das gerenderte und gescrollte HTML ab, geben Sie es an den Parser weiter und schreiben Sie die strukturierten Datensätze auf die Festplatte.

import json
from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup

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

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

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

def parse_jobs(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select('div#JobCardGrid article[data-testid="svx_jobCard"]')
    jobs = []
    for card in cards:
        title_link = card.select_one('a[data-testid="jobTitle"]')
        jobs.append({
            "title": title_link.get_text(strip=True) if title_link else "",
            "company": text_of(card, 'span[data-testid="company"]'),
            "location": text_of(card, 'span[data-testid="jobDetailLocation"]'),
            "posted": text_of(card, 'span[data-testid="jobDetailDateRecency"]'),
            "url": title_link["href"] if title_link else "",
        })
    return jobs

def main():
    page_url = "https://www.monster.com/jobs/search?q=Java+Developer&where=New+York"
    html = crawl_with_scroll(page_url)
    if not html:
        return
    jobs = parse_jobs(html)
    with open("monster_jobs.json", "w") as f:
        json.dump(jobs, f, indent=2)
    print(f"Saved {len(jobs)} jobs to monster_jobs.json")

if __name__ == "__main__":
    main()

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit python scraper.py aus und Sie erhalten eine Liste sauberer strukturierter Datensätze, einen pro Inserat, bereit zum Schreiben in CSV oder eine Datenbank.

[
  {
    "title": "Java Developer (Core Java)",
    "company": "Georgia IT Inc.",
    "location": "New York, NY",
    "posted": "2 days ago",
    "url": "https://www.monster.com/job-openings/java-developer-core-java-new-york-ny"
  },
  {
    "title": "Java Backend Developer",
    "company": "Diverse Lynx",
    "location": "Manhattan, NY",
    "posted": "5 days ago",
    "url": "https://www.monster.com/job-openings/java-backend-developer-manhattan-ny"
  }
]

Ergebnisseiten in einer Schleife durchlaufen

Eine Suchseite ist eine Demo; ein echter Job läuft über viele Seiten und Suchanfragen. Monster paginiert mit einem page-Abfrageparameter, also können Sie Seiten durchlaufen, indem Sie ihn erhöhen und dasselbe Abruf-und-Parse-Paar wiederverwenden. Da jede Ergebnisseite dieselbe Karten-Struktur teilt, funktioniert der Parser, den Sie bereits geschrieben haben, seitenübergreifend ohne Änderungen. Takten Sie die Schleife, damit Sie keine Anfragen hintereinander abfeuern.

import time

def scrape_pages(query, where, pages=3):
    all_jobs = []
    for page in range(1, pages + 1):
        url = (
            "https://www.monster.com/jobs/search"
            f"?q={query}&where={where}&page={page}"
        )
        html = crawl_with_scroll(url)
        if html:
            all_jobs.extend(parse_jobs(html))
        time.sleep(2)
    return all_jobs

Das time.sleep(2) zwischen Seiten ist bewusst. Die Suche in einer engen Schleife zu hämmern ist der schnellste Weg, gedrosselt zu werden, selbst wenn Rendering und Rotation für Sie übernommen werden. Verteilen Sie Anfragen und hören Sie früh auf, sobald eine Seite keine neuen Karten mehr zurückgibt.

Ungeblockt bleiben

Selbst wenn Rendering und Scrolling behandelt sind, beobachtet Monster Scraper-artigen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes schwierige kommerzielle Ziel.

• Dosieren Sie Ihre Anfragen. Verteilen Sie Anfragen und variieren Sie Ihre Suchanfragen statt einen Suchpfad mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool aus Residential-IPs verteilt Anfragen auf viele echte Benutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Lesen Sie die Status-Codes. Ein Lauf, der anfängt, Herausforderungen oder Fehler zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückschalten, nicht als Rauschen zum Ignorieren.

Das umfassendere Playbook finden Sie unter wie man Websites scrapt, ohne geblockt zu werden und dem tiefen Einblick in wie man CAPTCHAs beim Web-Scraping umgeht. Wenn Ihr Projekt auch professionelle Netzwerke berührt, deckt unser Leitfaden über wie man LinkedIn scrapt ein vergleichbares anmeldegesteuertes Ziel ab. Und wenn Sie lieber Ihren eigenen Traffic durch einen rotierenden Pool routen statt die verwaltete API zu nutzen, gibt Ihnen der Smart AI Proxy (auch AI Proxy genannt) dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, Monster zu scrapen?

Ob das Scrapen von Monster erlaubt ist, hängt von Monsters Nutzungsbedingungen, Ihrer Rechtsordnung und dem Umgang mit den Daten ab. Monsters Bedingungen schränken automatisierten Zugriff ein, sodass das Scrapen gegen diese Bedingungen verstoßen kann, unabhängig davon, wie sorgfältig Ihr Tooling ist. Keiner der hier gezeigten Codes ändert das; er lässt nur den technischen Teil funktionieren. Lesen Sie Monsters Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze für das, was Sie erheben.

Einige Grundregeln, an die Sie sich halten sollten. Sammeln Sie nur öffentliche Stellenanzeigendaten: Jobtitel, Unternehmen, Standort, Veröffentlichungsdatum und Inserat-URL, die jeder auf einer öffentlichen Suchseite ohne Anmeldung sehen kann. Respektieren Sie Monsters angegebene Rate-Erwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie die Server nicht belasten. Beschränken Sie Ihre Arbeit strikt auf öffentliche Stellenanzeigen.

Dieser Leitfaden beschränkt sich bewusst auf öffentliche Stellenanzeigen, weil das die Grenze ist, die die Arbeit verteidigbar hält. Er deckt keine Bewerber- oder Recruiter-Personaldaten ab, keine Lebensläufe oder Kandidatenprofile, nichts hinter einem Login oder kostenpflichtigen Tier und keine Authentifizierungsumgehungsversuche. Personenbezogene Daten von Jobsuchenden und Recruitern sind genau die Art von Daten, die man in Ruhe lassen sollte. Wenn Ihr Projekt mehr als öffentliche Inserate benötigt, ist eine offizielle Datenvereinbarung oder Monsters eigenes Arbeitgeber-Tooling der richtige Weg, kein raffinierterer Scraper.

Häufig gestellte Fragen

Kann ich Monster-Jobs nur mit requests und BeautifulSoup scrapen?

Nicht zuverlässig. Monster rendert seine Job-Karten im Browser mit JavaScript und lädt beim Scrollen weitere nach, sodass ein roher requests-Aufruf Status 200 mit leeren Inseraten zurückgibt. Sie brauchen etwas, das die Seite rendert und den Scroll antreibt, was das JS-Token der Crawling API zusammen mit den Scroll-Optionen übernimmt, bevor BeautifulSoup das HTML überhaupt sieht.

Brauche ich das normale Token oder das JS-Token für Monster?

Das JS-Token. Das normale Token ruft statisches HTML ab, das auf Monster dieselbe leere Hülle wie eine einfache Anfrage ist. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Job-Karten vorhanden sind, wenn BeautifulSoup sie parst.

Wie behandle ich Monsters Scroll-Paginierung?

scroll: "true" und scroll_interval: "60" in den Anfrage-Optionen übergeben. Die Crawling API scrollt die Seite dann bis zu 60 Sekunden, das Maximum, sodass die lazy-geladenen Karten rendern, bevor das HTML erfasst wird. Mit aktiviertem Scrolling brauchen Sie page_wait nicht zusätzlich. Um über eine Ergebnisseite hinaus zu gehen, erhöhen Sie Monsters page-Abfrageparameter und verwenden Sie dasselbe Abruf-und-Parse-Paar.

Meine Selektoren geben leere Strings zurück. Was hat sich geändert?

Mit großer Wahrscheinlichkeit Monsters Markup. Die data-testid-Hooks, auf die der Parser angewiesen ist, können in einem Redesign umbenannt werden, und die build-generierten Klassennamen ändern sich ständig. Inspizieren Sie eine Live-Suchseite in den Entwicklertools Ihres Browsers erneut und aktualisieren Sie die Selektoren. Periodische Selektor-Wartung ist normal für jeden produktiven Scraper.

Kann ich Lebensläufe oder Recruiter-Kontaktdaten von Monster scrapen?

Nein, und dieser Leitfaden deckt das nicht ab. Lebensläufe, Kandidatenprofile sowie Recruiter- oder Bewerber-Personaldaten liegen hinter einem Login oder sind persönliche Daten, keine öffentlichen Stellenanzeigendaten. Anmeldegeschützte Inhalte zu scrapen oder Authentifizierung zu umgehen, um sie zu erreichen, liegt außerhalb des Rahmens hier und verstößt gegen Monsters Bedingungen. Beschränken Sie Ihren Umfang auf die öffentlichen Inserate auf Such- und Anzeigenseiten.

Wie vermeide ich Blocking beim Scrapen von Monster?

Halten Sie Ihre pro-IP-Anfragerate niedrig, variieren Sie Ihre Suchanfragen statt einen Suchpfad zu schleifen, und leiten Sie über rotierende Residential-IPs weiter, sodass keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, in den Sie investieren sollten. Beobachten Sie die Status-Codes und schalten Sie zurück, wenn Sie anfangen, Herausforderungen 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.