Wie man LinkedIn-Daten im Jahr 2025 scrapt

In diesem Leitfaden erfahren Sie:

Was ein LinkedIn-Scraper ist
Ein Vergleich zwischen LinkedIn-Web-Scraping und dem Abrufen von Daten über seine APIs
Wie Sie die Anmeldebarriere von LinkedIn umgehen
Wie man ein LinkedIn-Scraping-Skript in Python erstellt
Wie Sie LinkedIn-Daten mit einer einfacheren und effektiveren Lösung abrufen können

Lassen Sie uns eintauchen!

Was ist ein LinkedIn-Scraper?

Ein LinkedIn-Scraper ist ein Tool, das automatisch Daten aus LinkedIn-Seiten extrahiert. Es zielt in der Regel auf beliebte Seiten wie Profile, Stellenanzeigen, Unternehmensseiten und Artikel ab.

Der Scraper sammelt wichtige Informationen von diesen Seiten und präsentiert sie in nützlichen Formaten wie CSV oder JSON. Diese Daten sind unter anderem für die Lead-Generierung, die Jobsuche, die Analyse von Wettbewerbern und die Identifizierung von Markttrends wertvoll.

LinkedIn-Web-Scraping vs. LinkedIn-API

LinkedIn bietet eine offizielle API, mit der Entwickler eine Integration in die Plattform vornehmen und bestimmte Daten abrufen können. Warum sollten Sie also überhaupt LinkedIn Web-Scraping in Betracht ziehen? Die Antwort ist einfach und umfasst vier wichtige Punkte:

Die API gibt nur einen Teil der von LinkedIn definierten Daten zurück, der möglicherweise viel kleiner ist als die durch Web-Scraping verfügbaren Daten.
API können sich im Laufe der Zeit ändern, wodurch Ihre Kontrolle über die Daten, auf die Sie zugreifen können, eingeschränkt wird.
Die API von LinkedIn konzentriert sich in erster Linie auf Marketing- und Vertriebsintegrationen, insbesondere für Nutzer der kostenlosen Version.
Die LinkedIn-API kann Dutzende von Dollar pro Monat kosten, unterliegt jedoch weiterhin strengen Beschränkungen hinsichtlich der Daten und der Anzahl der Profile, aus denen Sie Daten abrufen können.

Der Vergleich zwischen den beiden Ansätzen zum Abrufen von LinkedIn-Daten führt zu der folgenden Übersichtstabelle:

Aspekt	LinkedIn API	LinkedIn-Web-Scraping
Verfügbarkeit der Daten	Beschränkt auf einen Teil der von LinkedIn definierten Daten	Zugriff auf alle öffentlich verfügbaren Daten auf der Website
Kontrolle über Daten	LinkedIn kontrolliert die bereitgestellten Daten	Volle Kontrolle über die von Ihnen abgerufenen Daten
Fokus	In erster Linie für Marketing- und Vertriebsintegrationen	Kann jede LinkedIn-Seite ansprechen
Kosten	Kann mehrere Dutzend Dollar pro Monat kosten	Keine direkten Kosten (außer für die Infrastruktur)
Einschränkungen	Begrenzte Anzahl von Profilen und Daten pro Monat	Keine strengen Einschränkungen

Weitere Informationen finden Sie in unserem Leitfaden zum ThemaWeb-Scraping vs. API.

Welche Daten sollten Sie von LinkedIn scrapen?

Hier finden Sie eine unvollständige Liste der Datentypen, die Sie von LinkedIn scrapen können:

Profil: persönliche Angaben, Berufserfahrung, Ausbildung, Kontakte usw.
Unternehmen: Unternehmensinformationen, Mitarbeiterlisten, Stellenanzeigen usw.
Stellenangebote: Stellenbeschreibungen, Bewerbungen, Kriterien usw.
Stellenangebote: Berufsbezeichnung, Unternehmen, Standort, Gehalt usw.
Artikel: veröffentlichte Beiträge, von Nutzern verfasste Artikel usw.
LinkedIn Learning: Kurse, Zertifizierungen, Lernpfade usw.

So umgehen Sie die Anmeldebarriere bei LinkedIn

Wenn Sie versuchen, dieLinkedIn-Jobbörsedirekt nach einer Google-Suche im Inkognito-Modus (oder während Sie nicht angemeldet sind) aufzurufen, sollten Sie Folgendes sehen:

Die obige Seite könnte Ihnen den Eindruck vermitteln, dass die Jobsuche auf LinkedIn nur nach dem Einloggen möglich ist. Da das Scraping von Daten hinter einer Login-Barriere zu rechtlichen Problemen führen kann, da es gegen die Nutzungsbedingungen von LinkedIn verstößt, sollten Sie dies vermeiden.

Glücklicherweise gibt es eine einfache Möglichkeit, auf die Jobseite zuzugreifen, ohne blockiert zu werden. Sie müssen lediglich die LinkedIn-Homepage aufrufen und auf die Registerkarte „Jobs“ klicken:

Clicking on the “Jobs” link on LinkedIn’s homepage

Diesmal erhalten Sie Zugriff auf die Jobsuche-Seite:

Wie Sie in der URL-Leiste Ihres Browsers sehen können, enthält die URL in Ihrem Browser diesmal spezielle Abfrageparameter:

https://www.linkedin.com/jobs/search?trk=guest_homepage-basic_guest_nav_menu_jobs&position=1&pageNum=0

Insbesondere das Argument „trk=guest_homepage-basic_guest_nav_menu_jobs“ scheint der entscheidende Faktor zu sein, der LinkedIn daran hindert, eine Login-Sperre durchzusetzen.

Das bedeutet jedoch nicht, dass Sie auf alle LinkedIn-Daten zugreifen können. In einigen Bereichen müssen Sie weiterhin angemeldet sein. Wie wir jedoch gleich sehen werden, stellt dies keine wesentliche Einschränkung für das Web-Scraping von LinkedIn dar.

Erstellen eines LinkedIn-Web-Scraping-Skripts: Schritt-für-Schritt-Anleitung

In diesem Tutorial-Abschnitt erfahren Sie, wie Sie Datenzu Stellenangeboten fürSoftwareentwickler in New York von LinkedIn scrapen können:

Wir beginnen auf der Suchergebnisseite, rufen automatisch die URLs der Stellenanzeigen ab und extrahieren dann die Daten aus den Detailseiten. Der LinkedIn-Scraper wird in Python geschrieben, einer derbesten Programmiersprachen für Web-Scraping.

Führen wir das LinkedIn-Datenscraping mit Python durch!

Schritt 1: Projekt einrichten

Bevor Sie beginnen, stellen Sie sicher, dass Python 3 auf Ihrem Computer installiert ist. Falls nicht,laden Sie es herunterund folgen Sie den Anweisungen des Installationsassistenten.

Verwenden Sie nun den folgenden Befehl, um einen Ordner für Ihr Scraping-Projekt zu erstellen:

mkdir linkedin-scraper

linkedin-scraper steht für den Projektordner Ihres Python-LinkedIn-Scrapers.

Öffnen Sie ihn und initialisieren Sie darin einevirtuelle Umgebung:

cd linkedin-scraper
python -m venv venv

Laden Sie den Projektordner in Ihre bevorzugte Python-IDE.Visual Studio Code mit der Python-ErweiterungoderPyCharm Community Editionsind dafür geeignet.

Erstellen Sie eine Dateiscraper.pyim Projektordner, die folgende Dateistruktur enthalten sollte:

The file structure of the LinkedIn Scraper

Derzeit ist scraper.py ein leeres Python-Skript, aber es wird bald die gewünschte Scraping-Logik enthalten.

Aktivieren Sie die virtuelle Umgebung im Terminal der IDE. Führen Sie unter Linux oder macOS diesen Befehl aus:

./env/bin/activate

Unter Windows führen Sie stattdessen folgenden Befehl aus:

env/Scripts/activate

Großartig! Sie haben nun eine Python-Umgebung für das Web-Scraping.

Schritt 2: Auswahl und Installation der Scraping-Bibliotheken

Bevor Sie mit dem Programmieren beginnen, müssen Sie die Zielwebsite analysieren, um die richtigen Scraping-Tools für die Aufgabe zu ermitteln.

Öffnen Sie zunächst die LinkedIn-Jobs-Suchseite im Inkognito-Modus, wie zuvor beschrieben. Der Inkognito-Modus stellt sicher, dass Sie abgemeldet sind und keine zwischengespeicherten Daten den Scraping-Prozess beeinträchtigen.

Das sollten Sie sehen:

LinkedIn zeigt mehrere Popups im Browser an. Diese können bei der Verwendung von Browser-Automatisierungstools wieSelenium oder Playwright störend sein.

Glücklicherweise enthält der HTML-Quellcode der vom Server zurückgegebenen Seite bereits die meisten Daten der Seite, wie Sie bei der Überprüfung feststellen können:

Wenn Sie die Registerkarte „Netzwerk“ in DevTools überprüfen, werden Sie feststellen, dass die Seite nicht auf bedeutende dynamische API-Aufrufe angewiesen ist:

Mit anderen Worten: Der Großteil der Inhalte auf LinkedIn-Jobseiten ist statisch. Das bedeutet, dass Sie kein Browser-Automatisierungstool benötigen, um LinkedIn zu scrapen. Eine Kombination aus einem HTTP-Client und einem HTML-Parser reicht aus, um Jobdaten abzurufen.

Daher verwenden wir zwei Python-Bibliotheken, um LinkedIn-Stellenangebote zu scrapen:

Requests: Eine einfache HTTP-Bibliothek zum Senden von GET-Anfragen und Abrufen von Webseiteninhalten.
Beautiful Soup: Ein leistungsstarker HTML-Parser, mit dem sich Daten leicht aus Webseiten extrahieren lassen.

Installieren Sie in einer aktivierten virtuellen Umgebung beide Bibliotheken mit:

pip install requests beautifulsoup4

Importieren Sie sie anschließend in scraper.py mit:

from bs4 import BeautifulSoup
import requests

Großartig! Jetzt haben Sie alles, was Sie brauchen, um mit dem Scraping von LinkedIn zu beginnen.

Schritt 3: Strukturieren Sie das Scraping-Skript

Wie in der Einleitung dieses Abschnitts erläutert, führt der LinkedIn-Scraper zwei Hauptaufgaben aus:

Abrufen der URLs von Stellenangeboten aus der LinkedIn-Stellensuchseite
Extrahieren Sie Jobdetails von jeder einzelnen Jobseite

Um das Skript übersichtlich zu halten, strukturieren Sie Ihre Datei scraper.py mit zwei Funktionen:

def retrieve_job_urls(job_search_url):
    pass
    # Zu implementieren...

def scrape_job(job_url):
    pass
    # Zu implementieren...

# Funktionsaufrufe und Datenausfuhrlogik...

Im Folgenden wird beschrieben, was die beiden Funktionen leisten:

retrieve_job_urls(job_search_url): Akzeptiert die URL der Jobsuchseite und gibt eine Liste mit Jobseiten-URLs zurück.
scrape_job(job_url): Akzeptiert eine Job-Seiten-URL und extrahiert Jobdetails wie Titel, Unternehmen, Standort und Beschreibung.

Rufen Sie dann am Ende des Skripts diese Funktionen auf und implementieren Sie die Datenausfuhrlogik, um die extrahierten Jobdaten zu speichern. Zeit, diese Logik zu implementieren!

Schritt 4: Verbindung zur Jobsuchseite herstellen

Verwenden Sie in der Funktion retrieve_job_urls() die Bibliothek „requests“, um die Zielseite mithilfe der als Argument übergebenen URL abzurufen:

response = requests.get(job_url)

Im Hintergrund wird dabei eine HTTP-GET-Anfrage an die Zielseite gestellt und das vom Server zurückgegebene HTML-Dokument abgerufen.

Um auf den HTML-Inhalt der Antwort zuzugreifen, verwenden Sie das Attribut .text:

html = response.text

Großartig! Sie sind nun bereit, den HTML-Code zu analysieren und mit der Extraktion der Job-URLs zu beginnen.

Schritt 5: Job-URLs abrufen

Um den zuvor abgerufenen HTML-Code zu analysieren, übergeben Sie ihn an den Beautiful Soup-Konstruktor:

soup = BeautifulSoup(html, "html.parser")

Das zweite Argument gibt den zu verwendenden HTML-Parser an.html.parserist der Standard-Parser, der in der Standardbibliothek von Python enthalten ist.

Überprüfen Sie als Nächstes die Elemente der Jobkarte auf der LinkedIn-Jobsuche-Seite. Klicken Sie mit der rechten Maustaste auf eines davon und wählen Sie „Untersuchen” in den DevTools Ihres Browsers:

Wie Sie im HTML-Code der Jobkarte sehen können, können Job-URLs mit dem folgenden CSS-Selektor extrahiert werden:

[data-tracking-control-name="public_jobs_jserp-result_search-card"]

Hinweis: Die Verwendung vondata-*-Attributen für die Knotenauswahl beim Web-Scraping ist ideal, da diese häufig für Tests oder interne Nachverfolgung verwendet werden. Dadurch ist es weniger wahrscheinlich, dass sie sich im Laufe der Zeit ändern.

Wenn Sie sich nun die Seite ansehen, werden Sie feststellen, dass einige Jobkarten hinter einem Login-Einladungselement verschwommen erscheinen:

The blurred job cards have the same HTML structure as the non-blurred ones

Keine Sorge, das ist nur ein Frontend-Effekt. Der zugrunde liegende HTML-Code enthält weiterhin die URLs der Job-Seiten, sodass Sie diese URLs ohne Anmeldung abrufen können.

Hier ist die Logik zum Extrahieren von Stellenanzeigen-URLs aus der LinkedIn-Stellenseite:

job_urls = []

job_url_elements = soup.select("[data-tracking-control-name="public_jobs_jserp-result_search-card"]")
for job_url_element in job_url_elements:
  job_url = job_url_element["href"]
  job_urls.append(job_url)

select() gibt alle Elemente zurück, die dem angegebenen CSS-Selektor entsprechen und Job-Links enthalten. Anschließend führt das Skript Folgendes aus:

durchläuft diese Elemente
Greift auf das HTML-Attributhref(die URL der Jobseite) zu
hängt es an die Listejob_urlsan

Wenn Sie mit der oben genannten Logik nicht vertraut sind, lesen Sie unseren Leitfaden zumWeb-Scraping mit Beautiful Soup.

Am Ende dieses Schritts sieht Ihre Funktion retrieve_job_urls() wie folgt aus:

def retrieve_job_urls(job_search_url):
    # Führen Sie eine HTTP-GET-Anfrage durch, um den HTML-Code der Seite abzurufen.
    response = requests.get(job_search_url)

    # Greifen Sie auf den HTML-Code zu und analysieren Sie ihn.
    html = response.text
    soup = BeautifulSoup(html, "html.parser")

    # Speicherort für die gescrapten Daten
    job_urls = []

    # Scraping-Logik
    job_url_elements = soup.select("[data-tracking-control-name="public_jobs_jserp-result_search-card"]")
    for job_url_element in job_url_elements:
      # Extrahieren Sie die URL der Jobseite und fügen Sie sie der Liste hinzu.
      job_url = job_url_element["href"]
      job_urls.append(job_url)

    return job_urls

Sie können diese Funktion auf der Zielseite wie folgt aufrufen:

public_job_search_url = "https://www.linkedin.com/jobs/search?keywords=Software%2BEngineer&location=New%20York%2C%20New%20York%2C%20United%20States&geoId=102571732&trk=public_jobs_jobs-search-bar_search-submit&position=1&pageNum=0"
job_urls = retrieve_job_urls(public_job_search_url)

Gut gemacht! Sie haben nun die erste Aufgabe Ihres LinkedIn-Scrapers abgeschlossen.

Schritt 6: Initialisieren Sie die Aufgabe zum Scrapen der Jobdaten

Konzentrieren Sie sich nun auf die Funktion scrape_job(). Verwenden Sie wie zuvor die Bibliothek „requests“, um den HTML-Code der Jobseite von der angegebenen URL abzurufen, und analysieren Sie ihn mit Beautiful Soup:

response = requests.get(job_url)

html = response.text
soup = BeautifulSoup(html, "html.parser")

Da das Scraping von LinkedIn-Jobdaten das Extrahieren verschiedener Informationen umfasst, werden wir den Vorgang zur Vereinfachung in zwei Schritte unterteilen.

Schritt 7: Abrufen von Jobdaten – Teil 1

Bevor Sie mit dem Scraping von LinkedIn-Daten beginnen, müssen Sie eine Detailseite einer Stellenanzeige überprüfen, um zu verstehen, welche Daten sie enthält und wie Sie diese abrufen können.

Öffnen Sie dazu eine Stellenangebotsseite im Inkognito-Modus und überprüfen Sie die Seite mit den DevTools. Konzentrieren Sie sich auf den oberen Bereich der Stellenangebotsseite:

The HTML code of the top section of the page

Beachten Sie, dass Sie die folgenden Daten extrahieren können:

Die Stellenbezeichnung aus dem<h1>-Tag
Das Unternehmen, das die Stelle anbietet, aus dem Element[data-tracking-control-name="public_jobs_topcard-org-name"]
Die Standortinformationen aus.topcard__flavor--bullet
Die Anzahl der Bewerber aus dem Knoten.num-applicants__caption

Verwenden Sie in der Funktion scrape_job() nach dem Parsen des HTML-Codes die folgende Logik, um diese Felder zu extrahieren:

title_element = soup.select_one("h1")
title = title_element.get_text().strip()

company_element = soup.select_one("[data-tracking-control-name="public_jobs_topcard-org-name"]")
company_name = company_element.get_text().strip()
company_url = company_element["href"]

location_element = soup.select_one(".topcard__flavor--bullet")
location = location_element.get_text().strip()

applicants_element = soup.select_one(".num-applicants__caption")
applicants = applicants_element.get_text().strip()

Die Funktion strip() ist erforderlich, um führende oder nachstehende Leerzeichen aus dem extrahierten Text zu entfernen.

Als Nächstes konzentrieren Sie sich auf den Abschnitt „Gehalt“ der Seite:
The HTML code of the salary section

Sie können diese Informationen über den CSS-Selektor .salary abrufen. Da nicht alle Stellenangebote diesen Abschnitt enthalten, benötigen Sie eine zusätzliche Logik, um zu überprüfen, ob das HTML-Element auf der Seite vorhanden ist:

salary_element = soup.select_one(".salary")
if salary_element is not None:
    salary = salary_element.get_text().strip()
else:
    salary = None

Wenn .salary nicht auf der Seite vorhanden ist, gibt select_one() None zurück, und die Variable salary wird auf None gesetzt.

Großartig! Sie haben gerade einen Teil der Daten aus einer LinkedIn-Stellenangebotsseite extrahiert.

Schritt 8: Abrufen von Jobdaten – Teil 2

Konzentrieren Sie sich nun auf den unteren Bereich der LinkedIn-Stellenseite, beginnend mit der Stellenbeschreibung:

Sie können mit diesem Code auf den Text der Stellenbeschreibung aus dem Element.description__text .show-more-less-htmlzugreifen:

description_element = soup.select_one(".description__text .show-more-less-html")
description = description_element.get_text().strip()

Der schwierigste Teil des Web-Scraping auf LinkedIn ist schließlich der Umgang mit dem Abschnitt „Kriterien“:

In diesem Fall können Sie nicht genau vorhersagen, welche Daten auf der Seite vorhanden sein werden. Daher müssen Sie jeden Eintrag als<name, value>-Paar behandeln. So scrapen Sie die Kriterien-Daten:

Wählen Sie das Element<ul>mit dem CSS-Selektor.description__job-criteria-list liaus.
Durchlaufen Sie die ausgewählten Elemente und führen Sie für jedes Element Folgendes aus:
1. Kratzen Sie den Namen des Elements aus.description__job-criteria-subheader
2. Kratzen Sie den Wert des Elements aus.description__job-criteria-text
3. Hängen Sie die extrahierten Daten als Wörterbuch an ein Array an.

Implementieren Sie die LinkedIn-Scraping-Logik für den Kriterienbereich mit diesen Codezeilen:

criteria = []
criteria_elements = soup.select(".description__job-criteria-list li")
for criteria_element in criteria_elements:
    name_element = criteria_element.select_one(".description__job-criteria-subheader")
    name = name_element.get_text().strip()

    value_element = criteria_element.select_one(".description__job-criteria-text")
    value = value_element.get_text().strip()

    criteria.append({
        "name": name,
        "value": value
    })

Perfekt! Sie haben die Jobdaten erfolgreich gescrapt. Der nächste Schritt besteht darin, alle gescrapten LinkedIn-Daten in einem Objekt zu sammeln und zurückzugeben.

Schritt 9: Sammeln Sie die extrahierten Daten

Verwenden Sie die aus den beiden vorherigen Schritten extrahierten Daten, um ein Job- Objekt zu füllen und es aus der Funktion zurückzugeben:

job = {
    "url": job_url,
    "title": title,
    "company": {
        "name": company_name,
        "url": company_url
    },
    "location": location,
    "applications": applicants,
    "salary": salary,
    "description": description,
    "criteria": criteria
}
return job

Nach Abschluss der vorherigen drei Schritte sollte scrape_job() wie folgt aussehen:

def scrape_job(job_url):
    # Sende eine HTTP-GET-Anfrage, um den HTML-Code der Seite abzurufen.
    response = requests.get(job_url)

    # Greife auf den HTML-Text aus der Antwort zu und parse ihn.
    html = response.text
    soup = BeautifulSoup(html, "html.parser")

    # Scraping-Logik
    title_element = soup.select_one("h1")
    title = title_element.get_text().strip()

    company_element = soup.select_one("[data-tracking-control-name="public_jobs_topcard-org-name"]")
    company_name = company_element.get_text().strip()
    company_url = company_element["href"]

    location_element = soup.select_one(".topcard__flavor--bullet")
    location = location_element.get_text().strip()

    applicants_element = soup.select_one(".num-applicants__caption")
    applicants = applicants_element.get_text().strip()

    salary_element = soup.select_one(".salary")
    if salary_element is not None:
      salary = salary_element.get_text().strip()
    else:
       salary = None

    description_element = soup.select_one(".description__text .show-more-less-html")
    description = description_element.get_text().strip()

    criteria = []
    criteria_elements = soup.select(".description__job-criteria-list li")
    for criteria_element in criteria_elements:
        name_element = criteria_element.select_one(".description__job-criteria-subheader")
        name = name_element.get_text().strip()

        value_element = criteria_element.select_one(".description__job-criteria-text")
        value = value_element.get_text().strip()

        criteria.append({
            "name": name,
            "value": value
        })

    # Die gesammelten Daten erfassen und zurückgeben
    job = {
        "url": job_url,
        "title": title,
        "company": {
            "name": company_name,
            "url": company_url
        },
        "location": location,
        "applications": applicants,
        "salary": salary,
        "description": description,
        "criteria": criteria
    }
    return job

Um die Jobdaten zu sammeln, rufen Sie diese Funktion auf, indem Sie die von retrieve_job_urls() zurückgegebenen Job-URLs durchlaufen. Fügen Sie dann die gesammelten Daten an ein Jobs-Array an:

jobs = []
for job_url in job_urls:
    job = scrape_job(job_url)
    jobs.append(job)

Fantastisch! Die Logik zum Scraping der LinkedIn-Daten ist nun vollständig.

Schritt 10: In JSON exportieren

Die aus LinkedIn extrahierten Jobdaten sind nun in einem Array von Objekten gespeichert. Da diese Objekte nicht flach sind, ist es sinnvoll, diese Daten in einem strukturierten Format wie JSON zu exportieren.

Mit Python können Sie Daten ohne zusätzliche Abhängigkeiten in JSON exportieren. Dazu können Sie die folgende Logik verwenden:

file_name = "jobs.json"
with open(file_name, "w", encoding="utf-8") as file:
    json.dump(jobs, file, indent=4, ensure_ascii=False)

Die Funktionopen()erstellt die Ausgabedateijobs.json, die dann mitjson.dump() gefüllt wird. Der Parameterindent=4sorgt dafür, dass das JSON lesbar formatiert wird, undensure_ascii=Falsestellt sicher, dass Nicht-ASCII-Zeichen korrekt codiert werden.

Damit der Code funktioniert, vergessen Sie nicht,jsonaus der Python-Standardbibliothek zu importieren:

import json

Schritt 11: Fertigstellen der Scraping-Logik

Nun ist das LinkedIn-Scraping-Skript im Wesentlichen fertig. Es gibt jedoch noch einige Verbesserungen, die Sie vornehmen können:

Begrenzen Sie die Anzahl der gescrapten Jobs
Fügen Sie einige Protokollierungen hinzu, um den Fortschritt des Skripts zu überwachen

Der erste Punkt ist wichtig, weil:

Sie den Zielserver nicht mit zu vielen Anfragen Ihres LinkedIn-Scrapers überlasten möchten
Sie wissen nicht, wie viele Jobs sich auf einer einzelnen Seite befinden

Daher ist es sinnvoll, die Anzahl der gescrapten Jobs wie folgt zu begrenzen:

scraping_limit = 10
jobs_to_scrape = job_urls[:scraping_limit]

jobs = []
for job_url in jobs_to_scrape:
    # ...

Dadurch wird die Anzahl der gescrapten Seiten auf maximal 10 begrenzt.

Fügen Sie dann einige print() -Anweisungen hinzu, um zu überwachen, was das Skript während der Ausführung tut:

public_job_search_url = "https://www.linkedin.com/jobs/search?keywords=Software%2BEngineer&location=New%20York%2C%20New%20York%2C%20United%20States&geoId=102571732&trk=public_jobs_jobs-search-bar_search-submit&position=1&pageNum=0"

print("Starting job retrieval from LinkedIn search URL...")

job_urls = retrieve_job_urls(public_job_search_url)

print(f"{len(job_urls)} Job-URLs abgerufenn")

scraping_limit = 10
jobs_to_scrape = job_urls[:scraping_limit]

print(f"{len(jobs_to_scrape)} Jobs werden gescrapt...n")

jobs = []
for job_url in jobs_to_scrape:
    print(f"Beginne mit der Datenextraktion für "{job_url}"")

    job = scrape_job(job_url)
    jobs.append(job)

    print(f"Job gescrapt")

print(f"nExportiere {len(jobs)} gescrapten Jobs nach JSON")
file_name = "jobs.json"
with open(file_name, "w", encoding="utf-8") as file:
    json.dump(jobs, file, indent=4, ensure_ascii=False)

print(f"Jobs erfolgreich in "{file_name}" gespeichertn")

Die Protokollierungslogik hilft Ihnen dabei, den Fortschritt des Scrapers zu verfolgen, was angesichts der Tatsache, dass er mehrere Schritte durchläuft, unerlässlich ist.

Schritt 12: Alles zusammenfügen

Dies ist der endgültige Code Ihres LinkedIn-Scraping-Skripts:

from bs4 import BeautifulSoup
import requests
import json

def retrieve_job_urls(job_search_url):
    # HTTP-GET-Anfrage stellen, um den HTML-Code der Seite abzurufen
    response = requests.get(job_search_url)

    # Auf den HTML-Code zugreifen und ihn parsen
    html = response.text
    soup = BeautifulSoup(html, "html.parser")

    # Speicherort für die gescrapten Daten
    job_urls = []

    # Scraping-Logik
    job_url_elements = soup.select("[data-tracking-control-name="public_jobs_jserp-result_search-card"]")
    for job_url_element in job_url_elements:
      # Extrahieren der URL der Jobseite und Anhängen an die Liste
      job_url = job_url_element["href"]
      job_urls.append(job_url)

    return job_urls

def scrape_job(job_url):
    # Senden einer HTTP-GET-Anfrage zum Abrufen des HTML-Codes der Seite
    response = requests.get(job_url)

    # Greife auf den HTML-Text aus der Antwort zu und parse ihn
    html = response.text
    soup = BeautifulSoup(html, "html.parser")

    # Scraping-Logik
    title_element = soup.select_one("h1")
    title = title_element.get_text().strip()

    company_element = soup.select_one("[data-tracking-control-name="public_jobs_topcard-org-name"]")
    company_name = company_element.get_text().strip()
    company_url = company_element["href"]

    location_element = soup.select_one(".topcard__flavor--bullet")
    location = location_element.get_text().strip()

    applicants_element = soup.select_one(".num-applicants__caption")
    applicants = applicants_element.get_text().strip()

    salary_element = soup.select_one(".salary")
    if salary_element is not None:
      salary = salary_element.get_text().strip()
    else:
       salary = None

    description_element = soup.select_one(".description__text .show-more-less-html")
    description = description_element.get_text().strip()

    criteria = []
    criteria_elements = soup.select(".description__job-criteria-list li")
    for criteria_element in criteria_elements:
        name_element = criteria_element.select_one(".description__job-criteria-subheader")
        name = name_element.get_text().strip()

        value_element = criteria_element.select_one(".description__job-criteria-text")
        value = value_element.get_text().strip()

        criteria.append({
            "name": name,
            "value": value
        })

    # Die gesammelten Daten erfassen und zurückgeben
    job = {
        "url": job_url,
        "title": title,
        "company": {
            "name": company_name,
            "url": company_url
        },
        "location": location,
        "applications": applicants,
        "salary": salary,
        "description": description,
        "criteria": criteria
    }
    return job

# Die öffentliche URL der LinkedIn-Jobs-Suchseite
public_job_search_url = "https://www.linkedin.com/jobs/search?keywords=Software%2BEngineer&location=New%20York%2C%20New%20York%2C%20United%20States&geoId=102571732&trk=public_jobs_jobs-search-bar_search-submit&position=1&pageNum=0"

print("Abruf der Stellenangebote von der LinkedIn-Such-URL wird gestartet...")

# Abruf der einzelnen URLs für jede Stelle auf der Seite
job_urls = retrieve_job_urls(public_job_search_url)

print(f"{len(job_urls)} Stellen-URLs abgerufenn")

# Nur bis zu 10 Stellen von der Seite scrapen
scraping_limit = 10
jobs_to_scrape = job_urls[:scraping_limit]

print(f"{len(jobs_to_scrape)} Stellen scrapen...n")

# Daten von jeder Stellenangebotsseite scrapen
jobs = []
for job_url in jobs_to_scrape:
    print(f"Beginne mit der Datenextraktion auf "{job_url}"")

    job = scrape_job(job_url)
    jobs.append(job)

    print(f"Stelle gescrapt")

# Exportieren der gescraped Daten in CSV
print(f"nExportieren von {len(jobs)} gescraped Jobs in JSON")
file_name = "jobs.json"
with open(file_name, "w", encoding="utf-8") as file:
    json.dump(jobs, file, indent=4, ensure_ascii=False)

print(f"Jobs erfolgreich in "{file_name}" gespeichertn")

Starten Sie es mit dem folgenden Befehl:

python scraper.py

Der LinkedIn-Scraper sollte die folgenden Informationen protokollieren:

Starten des Abrufs von Stellenangeboten aus der LinkedIn-Such-URL...
60 Stellen-URLs abgerufen                                                                                                        
10 Stellenangebote scrapen...

Starten der Datenextraktion für „https://www.linkedin.com/jobs/view/software-engineer-recent-graduate-at-paypal-4149786397?position=1&pageNum=0&refId=nz9sNo7HULREru1eS2L9nA%3D%3D&trackingId=uswFC6EjKkfCPcv0ykaojw%3D%3D”
Stellenangebot gescrapt

# der Kürze halber ausgelassen...

Datenauszug gestartet für „https://www.linkedin.com/jobs/view/software-engineer-full-stack-at-paces-4090771382?position=2&pageNum=0&refId=UKcPcvFZMOsZrn0WhZYqtg%3D%3D&trackingId=p6UUa6cgbpYS1gDkRlHV2g%3D%3D"
Stellenangebot gescrapt

Exportieren von 10 gescrapten Stellenangeboten nach JSON
Stellenangebote erfolgreich in „jobs.json” gespeichert

Von den 60 gefundenen Job-Seiten hat das Skript nur 10 Jobs gescrapt. Daher enthält die vom Skript generierte Ausgabedatei „jobs.json” genau 10 Stellenangebote:

[
    {
        "url": "https://www.linkedin.com/jobs/view/software-engineer-recent-graduate-at-paypal-4149786397?position=1&pageNum=0&refId=UKcPcvFZMOsZrn0WhZYqtg%3D%3D&trackingId=UzOyWl8Jipb1TFAGlLJxqw%3D%3D",
        „title”: „Software Engineer – Recent Graduate”,
        „company”: {
            „name”: „PayPal”,
            „url”: „https://www.linkedin.com/company/paypal?trk=public_jobs_topcard-org-name”
        },
        "location": "New York, NY",
        "applications": "Über 200 Bewerber",
        "salary": null,
        "description": "Der Kürze halber weggelassen...",
        „criteria”: [
            {
                „name”: „Dienstalter”,
                „value”: „Nicht zutreffend”
            },
            {
                „name”: „Beschäftigungsart”,
                „value”: „Vollzeit”
            },
            {
                "name": "Tätigkeitsbereich",
                "value": "Technik"
            },
            {
                "name": "Branchen",
                "value": "Softwareentwicklung, Finanzdienstleistungen sowie Technologie, Information und Internet"
            }
        ]
    },

    // weitere 8 Positionen...

    {
        "url": "https://www.linkedin.com/jobs/view/software-engineer-full-stack-at-paces-4090771382?position=2&pageNum=0&refId=UKcPcvFZMOsZrn0WhZYqtg%3D%3D&trackingId=p6UUa6cgbpYS1gDkRlHV2g%3D%3D",
        „title”: „Software Engineer (Full-Stack)”,
        „company”: {
            „name”: „Paces”,
            „url”: „https://www.linkedin.com/company/pacesai?trk=public_jobs_topcard-org-name”
        },
        "location": "Brooklyn, NY",
        "applications": "Über 200 Bewerber",
        "salary": "$150.000,00/Jahr - $200.000,00/Jahr",
        "description": "Der Kürze halber weggelassen...",
        „criteria”: [
            {
                „name”: „Seniority level”,
                „value”: „Entry level”
            },
            {
                „name”: „Employment type”,
                „value”: „Full-time”
            },
            {
                "name": "Tätigkeitsbereich",
                "value": "Ingenieurwesen und Informationstechnologie"
            },
            {
                "name": "Branchen",
                "value": "Softwareentwicklung"
            }
        ]
    },
]

Et voilà! Das Web-Scraping von LinkedIn in Python ist gar nicht so schwer.

Optimieren Sie das Scraping von LinkedIn-Daten

Das von uns erstellte Skript lässt das Scraping von LinkedIn wie eine einfache Aufgabe erscheinen, aber das ist nicht der Fall. Die Login-Barriere und Techniken zur Verschleierung von Daten können schnell zu Herausforderungen werden, insbesondere wenn Sie Ihren Scraping-Vorgang skalieren.

Darüber hinaus verfügt LinkedIn über Mechanismen zur Begrenzung der Zugriffsrate, um automatisierte Skripte zu blockieren, die zu viele Anfragen stellen. Eine gängige Abhilfe besteht darin,Ihre IP-Adresse in Python zu rotieren, was jedoch zusätzlichen Aufwand erfordert.

Beachten Sie außerdem, dass LinkedIn sich ständig weiterentwickelt, sodass der Wartungsaufwand und die Kosten für Ihren Scraper nicht zu vernachlässigen sind. LinkedIn verfügt über eine Fundgrube an Daten in verschiedenen Formaten, von Stellenanzeigen bis hin zu Artikeln. Um all diese Informationen abzurufen, müssten Sie verschiedene Scraper erstellen und diese alle verwalten.

Mitder LinkedIn Scraper API von Bright Data gehört dieser Aufwand der Vergangenheit an. Dieses spezielle Tool kann alle benötigten LinkedIn-Daten scrapen und über No-Code-Integrationen oder einfache Endpunkte, die Sie mit jedem HTTP-Client aufrufen können, bereitstellen.

Verwenden Sie es, um LinkedIn-Profile, Beiträge, Unternehmen, Stellenangebote und vieles mehr in Sekundenschnelle zu scrapen – ohne eine ganze Scraping-Architektur verwalten zu müssen.

Fazit

In dieser Schritt-für-Schritt-Anleitung haben Sie gelernt, was ein LinkedIn-Scraper ist und welche Arten von Daten er abrufen kann. Außerdem haben Sie ein Python-Skript erstellt, um Stellenanzeigen von LinkedIn zu scrapen.

Die Herausforderung besteht darin, dass LinkedIn IP-Sperren und Login-Walls verwendet, um automatisierte Skripte zu blockieren. Mit unseremLinkedIn-Scraper umgehen Sie diese Probleme.

Wenn Web-Scraping nichts für Sie ist, Sie aber dennoch an den Daten interessiert sind, sehen Sie sich unsere gebrauchsfertigenLinkedIn-Datensätze an!

Erstellen Sie noch heute ein kostenloses Bright Data-Konto, um unsere Scraper-APIs auszuprobieren oder unsere Datensätze zu erkunden.

Vertrieb kontaktieren Gratis testen

Wie man LinkedIn scrapt: Leitfaden 2025