---
title: "Wie man JOBKOREA scrapt: Leitfaden 2026"
slug: how-to-scrape-jobkorea
date: 2026-01-05T13:20:33+00:00
modified: 2026-01-05T13:20:35+00:00
permalink: https://brightdata.de/blog/web-data-de/how-to-scrape-jobkorea
type: blog
---
[ Blog ](https://brightdata.de/blog "Blog") / [Web Data](https://brightdata.de/blog/web-data-de)
[Web Data](https://brightdata.de/blog/web-data-de)
# Wie man JOBKOREA scrapt: Leitfaden 2026
Dieser Leitfaden zeigt, wie Sie JOBKOREA mit Python, Bright Data Web MCP und No-Code-KI-Agenten für eine schnelle und zuverlässige Extraktion von Jobdaten scrapen können.
9 min lesen
[  ](https://brightdata.com/blog/authors/amitesh-anand)
[Amitesh Anand
Technical Writer
](https://brightdata.com/blog/authors/amitesh-anand)
In diesem Tutorial lernen wir, wie man Stellenanzeigen von [JOBKOREA](https://www.jobkorea.co.kr/), einem modernen Jobportal, scrapt.
Wir behandeln folgende Themen:
- Manuelles Python-Scraping durch Extrahieren eingebetteter Next.js-Daten
- Scraping mit [Bright Data MCP für ](/ai/mcp-server)eine stabilere und skalierbarere Lösung
- No-Code-Scraping mit [Bright Data’s KI Scraper Studio](/products/web-scraper/custom)
Jede Technik wird mithilfe des in diesem Repository bereitgestellten Projektcodes implementiert, wobei wir vom Low-Level-Scraping bis hin zur vollständig agentenbasierten, KI-gestützten Extraktion voranschreiten.
## Voraussetzungen
Bevor Sie mit diesem Tutorial beginnen, stellen Sie sicher, dass Sie über Folgendes verfügen:
- Python 3.9+
- Grundkenntnisse in Python und JSON
- Ein [Bright Data-Konto](/ai/mcp-server) mit Zugriff auf MCP
- Claude Desktop installiert (wird als KI-Agent für den No-Code-Ansatz verwendet)
## Projekt einrichten
Klonen Sie das [Projekt-Repository](https://github.com/danielshashko/jobkorea-scraper) und installieren Sie die Abhängigkeiten:
```none
python -m venv venv
source venv/bin/activate # macOS / Linux
venvScriptsactivate # Windows
pip install -r requirements.txt
```
## Projektstruktur
Das Repository ist so organisiert, dass jede Scraping-Technik leicht nachvollziehbar ist:
```none
jobkorea_scraper/
│
├── manual_scraper.py # Manuelles Python-Scraping
├── mcp_scraper.py # Bright Data MCP-Scraping
├── parsers/
│ └── jobkorea.py # Gemeinsame Parsing-Logik
├── schemas.py # Jobdaten-Schema
├── requirements.txt
├── README.md
```
Jedes Skript kann unabhängig ausgeführt werden, je nachdem, welche Methode Sie ausprobieren möchten.
## Technik 1: Manuelles Python-Scraping
Wir beginnen mit dem grundlegendsten Ansatz: Scraping von JOBKOREA mit einfachem Python, ohne Browser, MCP oder KI-Agent.
Diese Technik ist nützlich, um zu verstehen, wie JOBKOREA seine Daten bereitstellt, und um schnell einen Scraper zu prototypisieren, bevor wir zu robusteren Lösungen übergehen.
### Die Seite abrufen
Öffnen Sie `manual_scraper.py`.
Der Scraper beginnt mit dem Senden einer Standard-HTTP-Anfrage unter Verwendung von `Requests`. Um eine sofortige Blockierung zu vermeiden, fügen wir browserähnliche Header hinzu.
```none
headers = {
"User-Agent": "Mozilla/5.0 (...)",
"Accept": "text/html,application/xhtml+xml,*/*",
"Accept-Language": "en-US,en;q=0.9,ko;q=0.8",
"Referer": "https://www.jobkorea.co.kr/"
}
```
Das Ziel besteht einfach darin, die Anfrage wie normalen Web-Traffic aussehen zu lassen. Anschließend rufen wir die Seite ab und erzwingen `die UTF-8-` Kodierung, um Probleme mit koreanischem Text zu vermeiden:
```none
response = requests.get(url, headers=headers, timeout=20)
response.raise_for_status()
response.encoding = "utf-8"
html = response.text
```
Zur Fehlerbehebung wird der rohe HTML-Code lokal gespeichert:
```none
with open("debug.html", "w", encoding="utf-8") as f:
f.write(html)
```
Diese Datei ist äußerst hilfreich, wenn sich die Website ändert und das Parsen plötzlich nicht mehr funktioniert.
### Parsing der Antwort
Sobald der HTML-Code heruntergeladen ist, wird er an eine gemeinsame Parsing-Funktion übergeben:
```none
jobs = parse_job_list(html)
```
Diese Funktion befindet sich in `parsers/jobkorea.py` und enthält die gesamte JOBKOREA-spezifische Logik.
### Versuch eines traditionellen HTML-Parsing
In `parse_job_list` versuchen wir zunächst, Stellenanzeigen mit BeautifulSoup zu extrahieren, als wäre JOBKOREA eine herkömmliche, vom Server gerenderte Website.
```none
soup = BeautifulSoup(html, "html.parser")
job_lists = soup.find_all("div", class_="list-default")
```
Wenn keine Stellenanzeigen gefunden werden, wird ein sekundärer Selektor ausprobiert:
```none
job_lists = soup.find_all("ul", class_="clear")
```
Wenn dies funktioniert, extrahiert der Scraper Felder wie:
- Berufsbezeichnung
- Firmenname
- Standort
- Datum der Veröffentlichung
- Link zur Stellenanzeige
Dieser Ansatz funktioniert jedoch nur, wenn JOBKOREA aussagekräftige HTML-Elemente bereitstellt, was nicht immer der Fall ist.
### Fallback: Extrahieren von Next.js-Hydrationsdaten
Wenn durch HTML-Parsing keine Stellen gefunden werden, wechselt der Scraper zu einer Fallback-Strategie, die auf eingebettete Next.js-Hydration-Daten abzielt.
```none
nextjs_jobs = parse_nextjs_data(html)
```
Diese Funktion durchsucht die Seite nach JSON-Strings, die während der clientseitigen Rendering-Phase eingefügt wurden. Eine vereinfachte Version der Abgleichlogik sieht wie folgt aus:
```none
pattern = r'\"id\":\"(?Pd+)\",\"title\":\"(?P.*?)\",\"postingCompanyName\":\"(?P<company>.*?)\"'
```
Aus diesen Daten rekonstruieren wir die URLs der Stellenanzeigen:
```none
link = f"https://www.jobkorea.co.kr/Recruit/GI_Read/{job_id}"
```
Dieser Fallback ermöglicht es dem Scraper, ohne Browser zu arbeiten.
### Speichern der Ergebnisse
Jede Stellenanzeige wird anhand eines gemeinsamen Schemas validiert und auf die Festplatte geschrieben:
```none
with open("jobs.json", "w", encoding="utf-8") as f:
json.dump(
[job.model_dump() for job in jobs],
f,
ensure_ascii=False,
indent=2
)
```
Führen Sie den Scraper wie folgt aus:
```none
python manual_scraper.py "https://www.jobkorea.co.kr/Search/?stext=python"
```
Sie sollten nun eine Datei `„jobs.json”` mit den extrahierten Einträgen haben.
### Wann dieser Ansatz ideal ist
Manuelles Scraping ist nützlich, wenn Sie die Funktionsweise einer Website erkunden oder einen schnellen Prototyp erstellen möchten. Es ist schnell, einfach und unabhängig von externen Diensten.
Dieser Ansatz ist jedoch eng mit der aktuellen Seitenstruktur von JOBKOREA verbunden. Da er von bestimmten HTML-Layouts und eingebetteten Hydrationsmustern abhängt, kann er bei Änderungen an der Website fehlschlagen.
Für ein stabileres, langfristiges Scraping ist es besser, sich auf Tools zu verlassen, die das Rendering und Website-Änderungen für Sie übernehmen. Genau das werden wir als Nächstes mit Bright Data MCP tun.
## Technik 2: Scraping mit Bright Data MCP
Im vorherigen Abschnitt haben wir JOBKOREA gescrapt, indem wir HTML manuell heruntergeladen und eingebettete Daten extrahiert haben. Dieser Ansatz funktioniert zwar, ist jedoch eng mit der aktuellen Struktur der Website verbunden.
Bei dieser Technik verwenden wir Bright Data MCP, um das Abrufen und Rendern von Seiten zu übernehmen. Wir konzentrieren uns dann nur darauf, die zurückgegebenen Inhalte in strukturierte Jobdaten umzuwandeln.
Dieser Ansatz wird in `mcp_scraper.py` implementiert.
### So erhalten Sie Ihren Bright Data API-Schlüssel/Token
1. Melden Sie sich beim Bright Data-Dashboard an
2. Öffnen Sie die Einstellungen in der linken Seitenleiste
3. Gehen Sie zu „Benutzer und API-Schlüssel“
4. Kopieren Sie Ihren API-Schlüssel
Später in diesem Tutorial zeigen Screenshots genau, wo sich diese Seite befindet und wo das Token angezeigt wird.
Erstellen Sie eine `.env` -Datei im Projektstammverzeichnis und fügen Sie Folgendes hinzu:
```none
BRIGHT_DATA_API_TOKEN=Ihr_Token_hier
```
Das Skript lädt das Token zur Laufzeit und bricht vorzeitig ab, wenn es fehlt.
### Anforderungen für MCP
Bright Data MCP wird lokal mit `npx` gestartet. Stellen Sie daher sicher, dass Sie über Folgendes verfügen:
- Node.js installiert
- npx in Ihrem PATH verfügbar
Der MCP-Server wird von Python aus gestartet mit:
```none
server_params = StdioServerParameters( command="npx", args=["-y", "@brightdata/mcp"], env={"API_TOKEN": BRIGHT_DATA_API_TOKEN, **os.environ} )
```
### Ausführen des MCP-Scrapers
Führen Sie das Skript mit einer JOBKOREA-Such-URL aus:
```none
python mcp_scraper.py "https://www.jobkorea.co.kr/Search/?stext=python"
```
Das Skript öffnet eine MCP-Sitzung und initialisiert die Verbindung:
```none
async with stdio_client(server_params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
```
Sobald die Verbindung hergestellt ist, ist der Scraper bereit, Inhalte abzurufen.
Abrufen der Seite mit MCP
In diesem Projekt verwendet der Scraper das MCP-Tool `scrape_as_markdown`:
```none
result = await session.call_tool(
"scrape_as_markdown",
arguments={"url": url}
)
```
Der zurückgegebene Inhalt wird gesammelt und lokal gespeichert:
```none
with open("scraped_data.md", "w", encoding="utf-8") as f:
f.write(content_text)
```
Dadurch erhalten Sie einen lesbaren Snapshot der von MCP zurückgegebenen Daten, was für die Fehlerbehebung und das Parsing nützlich ist.
### Parsing von Jobs aus Markdown
Die von MCP zurückgegebenen Markdown-Daten werden anschließend in strukturierte Jobdaten umgewandelt.
Die Parsing-Logik sucht nach Markdown-Links:
```none
link_pattern = re.compile(r"[(.*?)]((.*?))")
```
Stellenanzeigen werden anhand von URLs identifiziert, die Folgendes enthalten:
```none
if "Recruit/GI_Read" in url:
```
Sobald ein Job-Link gefunden wurde, werden die umgebenden Zeilen verwendet, um den Firmennamen, den Standort und das Veröffentlichungsdatum zu extrahieren.
Schließlich werden die Ergebnisse auf die Festplatte geschrieben:
```none
with open("jobs_mcp.json", "w", encoding="utf-8") as f:
json.dump(
[job.model_dump() for job in jobs],
f,
ensure_ascii=False,
indent=2
)
```
### Ausgabedateien
Nach Abschluss des Skripts sollten Sie Folgendes haben:
- `scraped_data.md`
Die von Bright Data MCP zurückgegebene Roh-Markdown-Datei
- `jobs_mcp.json`
Die geparsten Stellenanzeigen im strukturierten JSON-Format
### Wann dieser Ansatz ideal ist
Die direkte Verwendung von [Bright Data MCP](/ai/mcp-server) aus Python heraus ist ideal, wenn Sie einen Scraper suchen, der sowohl zuverlässig als auch wiederholbar ist.
Da MCP das Rendering, die Vernetzung und grundlegende Website-Sicherheitsmaßnahmen übernimmt, ist dieser Ansatz weitaus weniger empfindlich gegenüber Layoutänderungen als manuelles Scraping. Gleichzeitig erleichtert die Beibehaltung der Logik in Python die Automatisierung, Planung und Integration in größere Datenpipelines.
Diese Technik eignet sich gut, wenn Sie über einen längeren Zeitraum hinweg konsistente Ergebnisse benötigen oder wenn Sie mehrere Suchseiten oder Schlüsselwörter scrapen. Sie bietet auch einen klaren Upgrade-Pfad vom manuellen Scraping, ohne dass eine vollständige Umstellung auf einen KI-gesteuerten Workflow erforderlich ist.
Als Nächstes gehen wir zur dritten Technik über, bei der wir Claude Desktop als KI-Agenten verwenden, der mit Bright Data MCP verbunden ist, um JOBKOREA zu scrapen, ohne einen Scraping-Code schreiben zu müssen.
## Technik 3: KI-generierter Scraping-Code mit Bright Data IDE
Bei dieser letzten Technik generieren wir Scraping-Code mit dem KI-gestützten Scraper von Bright Data innerhalb der [Web-Scraping IDE](/products/web-scraper/functions).
Sie müssen die Scraping-Logik nicht manuell von Grund auf neu schreiben. Vielmehr beschreiben Sie, was Sie wollen, und die IDE hilft Ihnen bei der Generierung und Verfeinerung des Scrapers.
### Öffnen der Scraper-IDE
Über das Bright Data-Dashboard:
Öffnen Sie „Data“ in der linken Seitenleiste
- Klicken Sie auf „Meine Scraper“
- Wählen Sie „Neu“ in der oberen rechten Ecke
- Wählen Sie „Entwickeln Sie Ihren eigenen Web-Scraper“
Dadurch wird die integrierte JavaScript-Entwicklungsumgebung (IDE) geöffnet
Geben Sie Ihre Ziel-URL „https://www.jobkorea.co.kr/Search/“ ein und klicken Sie auf „Code generieren“
Die IDE verarbeitet Ihre Anfrage und generiert eine gebrauchsfertige Code-Vorlage. Sie erhalten eine E-Mail-Benachrichtigung, sobald diese fertig ist. Sie können den Code dann nach Bedarf bearbeiten oder ausführen.
## Vergleich der drei Scraping-Techniken
Jede Technik in diesem Projekt löst das gleiche Problem, eignet sich jedoch für einen anderen Arbeitsablauf. Die folgende Tabelle zeigt die praktischen Unterschiede auf.
TechnikAufwand für die EinrichtungZuverlässigkeitAutomatisierungWo sie läuftBester AnwendungsfallManuelles Python-ScrapingGeringNiedrig bis mittelBegrenztLokaler RechnerLernen, schnelle ExperimenteBright Data MCP (Python)MittelHochHochLokal + Bright DataProduktions-Scraping, geplante AufgabenKI-generierter Scraper (Bright Data IDE)NiedrigHochHochBright Data-PlattformSchnelle Einrichtung, wiederverwendbare verwaltete Scraper## Zusammenfassung
In diesem Tutorial haben wir drei verschiedene Methoden zum Scrapen von JOBKOREA behandelt: manuelles Python-Scraping, einen stabileren Bright Data MCP-basierten Workflow und die Verwendung von Bright Datas AI Scraper Studio für einen No-Code-Ansatz.
Jede Technik baut auf der vorherigen auf. Manuelles Scraping hilft dabei, die Funktionsweise der Website zu verstehen, MCP-basiertes Scraping bietet Zuverlässigkeit und Automatisierung, und der KI-Agent-Ansatz bietet den schnellsten Weg zu strukturierten Daten mit minimalem Einrichtungsaufwand.
Wenn Sie moderne, clientseitig gerenderte Websites wie JOBKOREA scrapen und eine zuverlässigere Alternative zu instabilen Selektoren und Browser-Automatisierung benötigen, bietet [Bright Data MCP](/ai/mcp-server) eine starke Grundlage, die sowohl mit traditionellen Skripten als auch mit KI-gesteuerten Workflows funktioniert.
Vertrieb kontaktierenGratis testen
Inhaltsverzeichnis
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Wie+man+JOBKOREA+scrapt%3A+Leitfaden+2026&u=https://brightdata.de/blog/web-data-de/how-to-scrape-jobkorea) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Wie+man+JOBKOREA+scrapt%3A+Leitfaden+2026&url=https://brightdata.de/blog/web-data-de/how-to-scrape-jobkorea) [ ](http://www.reddit.com/submit?title=Wie+man+JOBKOREA+scrapt%3A+Leitfaden+2026&url=https://brightdata.de/blog/web-data-de/how-to-scrape-jobkorea)
## Das könnte Sie auch interessieren
[  ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI
Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen.
09-Sep-2026
12 min lesen
](https://brightdata.de/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax "Multimodales Web-Scraping mit MiniMax")
[Web Data
Antonello Zanini
Technical Writer
### Multimodales Web-Scraping mit MiniMax
Kombinieren Sie Bright Data Web Unlocker mit MiniMax M3 Vision, um strukturierte Daten aus Bildern und Webseiten-Screenshots zu extrahieren.
09-Sep-2026
4 min lesen
](https://brightdata.de/blog/web-data-de/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.de/blog/ai/best-cli-tools-for-codex "Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet")
[AI
Daniel Shashko
Web Data & AI Expert
### Die 10 besten CLI-Tools für Codex im Jahr 2026 – Getestet & Bewertet
Die 10 CLI-Tools, die Codex schneller und leistungsfähiger machen, beginnend mit dem Bright Data CLI für echten Web-Zugriff aus der Sandbox heraus.
06-Sep-2026
20 min lesen
](https://brightdata.de/blog/ai/best-cli-tools-for-codex)