Daten mit Python scrapen: Einsteiger-Tutorial

Hast du dich schon mal dabei ertappt, wie du vor einer Webseite sitzt und dir denkst: „Wäre doch cool, wenn ich all diese spannenden Infos einfach direkt in eine Tabelle ziehen könnte – ganz ohne stundenlanges Copy-Paste?“ Damit bist du echt nicht allein. Im Jahr 2025 ist daten scrapen längst kein Nischenthema mehr, sondern ein echter Gamechanger fürs Business. Egal ob Vertriebsteams auf Lead-Jagd oder E-Commerce-Manager beim Preisvergleich – alle wollen Webdaten, und das am besten sofort. Die gute Nachricht: Mit Python wird scrapen nicht nur möglich, sondern ist auch für Anfänger überraschend easy – selbst wenn dein letzter Kontakt mit Code das Pimpen deines MySpace-Profils war.

In diesem Guide zeige ich dir Schritt für Schritt, wie du mit Python Daten von Webseiten scrapen kannst. Wir starten bei den Basics, schauen uns an, wie du statische und dynamische Seiten knackst, und wie du mit , unserem KI-Web-Scraper, deinen Workflow noch smarter machst. Egal, ob du gerade erst loslegst oder schon ein bisschen Erfahrung hast: Hier findest du praktische Tipps, echte Code-Beispiele und ein paar Learnings aus meinen Jahren in der SaaS- und Automatisierungswelt.

Was ist Web Scraping und warum Python?

Lass uns ganz vorne anfangen. Web Scraping heißt, dass du automatisiert Infos von Webseiten sammelst. Stell dir vor, du bringst deinem Rechner bei, eine Webseite zu „lesen“ und gezielt die Daten rauszuziehen, die dich interessieren – zum Beispiel Produktpreise, News-Headlines oder Kontaktdaten – und das alles, ohne dass du selbst Hand anlegen musst (). Unternehmen nutzen daten scrapen für alles Mögliche: von Echtzeit-Wettbewerbsanalysen über Marktforschung und Lead-Generierung bis hin zum Training von KI-Modellen ().

Warum ist Python beim scrapen so beliebt? Zum einen ist die Sprache super einsteigerfreundlich – der Code liest sich fast wie Englisch, was gerade für Neulinge angenehm ist. Das eigentliche Ass im Ärmel ist aber das riesige Ökosystem: Bibliotheken wie requests, BeautifulSoup, Scrapy, Selenium und pandas nehmen dir alles ab – vom Laden der Webseite über das Auslesen des HTML bis zum Export sauberer Daten. Kein Wunder, dass rund – weit vor anderen Sprachen.

Warum Python fürs Web Scraping?

Ich hab schon viele Programmiersprachen ausprobiert, aber Python bleibt mein Favorit fürs scrapen – vor allem für Einsteiger. Hier die wichtigsten Gründe:

• Einfach & Lesbar: Python-Code ist klar und kompakt, was das Schreiben und Debuggen von Scraping-Skripten super easy macht ().
• Starke Bibliotheken: Tools wie requests (HTTP), BeautifulSoup (HTML-Parsing), Scrapy (für große Crawls), Selenium (Browser-Automatisierung) und pandas (Datenanalyse) decken jeden Schritt ab ().
• Große Community: Die Python-Community ist riesig und aktiv. Fast jedes Problem wurde schon mal gelöst und online dokumentiert.

Wie schlägt sich Python im Vergleich zu anderen Ansätzen? Hier ein schneller Überblick:

(, )

Für die meisten Business-Anwender und Datenfans ist Python die goldene Mitte: leistungsstark, flexibel und nicht abschreckend.

Python-Umgebung fürs Data Scraping einrichten

Bevor du loslegst, musst du deine Python-Umgebung vorbereiten. Keine Sorge – das ist wirklich einfacher als ein IKEA-Regal aufzubauen und du hast garantiert keine Schrauben übrig.

1. Python installieren:
Hol dir die aktuelle Python-3-Version von . Unter Windows beim Installieren „Add Python to PATH“ anhaken. Auf dem Mac geht’s mit Homebrew (brew install python3). Linux-User haben meist schon alles, sonst hilft apt install python3 python3-pip ().

2. (Empfohlen) Virtuelle Umgebung einrichten:
So bleiben die Bibliotheken deines Projekts sauber getrennt. Im Projektordner:

1python -m venv venv
2# Aktivieren:
3# Windows:
4venv\Scripts\activate
5# Mac/Linux:
6source venv/bin/activate

3. Wichtige Bibliotheken installieren:
Öffne das Terminal und tippe:

1pip install requests beautifulsoup4 pandas selenium lxml

• requests: Für HTTP-Anfragen
• beautifulsoup4: Zum Parsen von HTML
• pandas: Für Datenbearbeitung/-export
• selenium: Für dynamische Seiten (optional)
• lxml: Schnelles HTML/XML-Parsing

4. Editor auswählen:

• (mit Python-Erweiterung): Leichtgewichtig, beliebt, ideal für Einsteiger.
• : Umfangreich, speziell für Python.
• : Interaktiv, perfekt zum Experimentieren und für Datenanalysen ().

5. (Für Selenium) WebDriver installieren:
Selenium braucht einen Browser-Treiber (z.B. ChromeDriver). Am einfachsten geht’s mit webdriver_manager:

1pip install webdriver-manager

Im Skript dann:

1from selenium import webdriver
2from selenium.webdriver.chrome.service import Service
3from webdriver_manager.chrome import ChromeDriverManager
4driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))

Tipp: Wenn pip nicht erkannt wird, prüfe, ob Python im PATH ist und die virtuelle Umgebung aktiv ist.

Statische Webseiten mit Python scrapen: Schritt für Schritt

Statische Webseiten sind der perfekte Einstieg. Siehst du die Daten im „Seitenquelltext“, kannst du sie mit Python scrapen.

Wir scrapen gemeinsam , eine beliebte Übungsseite.

Schritt 1: Seite abrufen

1import requests
2url = "http://quotes.toscrape.com/page/1/"
3response = requests.get(url)
4html = response.text
5print(response.status_code)  # 200 bedeutet OK

Schritt 2: HTML parsen

1from bs4 import BeautifulSoup
2soup = BeautifulSoup(html, 'html.parser')
3quotes = soup.find_all("div", class_="quote")

Schritt 3: Daten extrahieren

1for q in quotes:
2    text = q.find("span", class_="text").get_text()
3    author = q.find("small", class_="author").get_text()
4    print(f"{text} --- {author}")

Schritt 4: Über mehrere Seiten scrapen

1import pandas as pd
2all_data = []
3page = 1
4while True:
5    url = f"http://quotes.toscrape.com/page/{page}/"
6    resp = requests.get(url)
7    if resp.status_code != 200:
8        break
9    soup = BeautifulSoup(resp.text, 'html.parser')
10    quotes = soup.find_all("div", class_="quote")
11    if not quotes:
12        break
13    for q in quotes:
14        text = q.find("span", class_="text").get_text()
15        author = q.find("small", class_="author").get_text()
16        all_data.append({"quote": text, "author": author})
17    page += 1
18df = pd.DataFrame(all_data)
19df.to_csv("quotes.csv", index=False)

Und schon hast du mehrere Seiten gescrapet und die Daten als CSV gespeichert. Gar nicht schlecht für ein paar Zeilen Code, oder? ()

Tipp: Schau immer zuerst in die robots.txt und die Nutzungsbedingungen der Seite. Und sei fair – keine Anfragen im Sekundentakt. Ein kurzes time.sleep(1) zwischen den Requests ist höflich.

Dynamische Webseiten scrapen: Selenium mit Python nutzen

Manche Webseiten machen es einem schwer: Die Daten erscheinen erst, nachdem JavaScript geladen wurde (z.B. bei endlosem Scrollen, Pop-ups oder Dashboards). Hier hilft Selenium.

Schritt 1: Browser starten

1from selenium import webdriver
2from selenium.webdriver.common.by import By
3from selenium.webdriver.chrome.service import Service
4from webdriver_manager.chrome import ChromeDriverManager
5driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
6driver.get("https://example.com/dynamic-products")

Schritt 2: Auf Inhalte warten

1from selenium.webdriver.support.ui import WebDriverWait
2from selenium.webdriver.support import expected_conditions as EC
3WebDriverWait(driver, 10).until(
4    EC.presence_of_element_located((By.ID, "product-list"))
5)

Schritt 3: Scrollen oder Klicken, um mehr zu laden

1import time
2last_height = driver.execute_script("return document.body.scrollHeight")
3while True:
4    driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
5    time.sleep(2)
6    new_height = driver.execute_script("return document.body.scrollHeight")
7    if new_height == last_height:
8        break
9    last_height = new_height

Schritt 4: Daten extrahieren

1products = driver.find_elements(By.CLASS_NAME, "product-item")
2data = []
3for prod in products:
4    name = prod.find_element(By.CSS_SELECTOR, "h2.product-name").text
5    price = prod.find_element(By.CSS_SELECTOR, "span.price").text
6    data.append({"name": name, "price": price})

Schritt 5: Speichern und aufräumen

1import pandas as pd
2df = pd.DataFrame(data)
3df.to_csv("products.csv", index=False)
4driver.quit()

Tipps:

• Nutze explizite Wartezeiten (WebDriverWait), damit du keine Fehler bekommst, wenn Elemente noch nicht geladen sind ().
• Für den Headless-Modus (ohne sichtbaren Browser) setze options.headless = True in den Chrome-Optionen.
• Findest du in den Netzwerkanfragen der Seite eine JSON-API, kannst du oft auf Selenium verzichten und direkt mit requests arbeiten – das ist viel schneller!

Thunderbit und Python kombinieren: Daten-Workflows auf dem nächsten Level

Jetzt wird’s spannend: Selbst mit Pythons Bibliotheken kann das scrapen komplexer oder unübersichtlicher Seiten zur Geduldsprobe werden. Hier kommt ins Spiel.

Thunderbit ist eine KI-basierte Web-Scraper Chrome-Erweiterung, mit der du per Klick Daten von jeder Webseite extrahierst – ganz ohne Code. Ideal für alle, die schnell Ergebnisse brauchen, aber auch perfekt, um mit Python weiterzuarbeiten. So ergänzen sich Thunderbit und Python optimal:

1. Mit Thunderbit Daten scrapen:

   • Öffne die .
   • Klicke auf „KI-Felder vorschlagen“ und lass Thunderbits KI die wichtigsten Datenfelder erkennen.
   • Paginierung, Unterseiten, Bilder oder PDFs – alles mit wenigen Klicks.
   • Exportiere die Daten direkt als CSV, Excel, Google Sheets, Notion oder Airtable.

2. Daten in Python analysieren und bereinigen:

   • Lade die exportierte Datei mit pandas in Python:

     1import pandas as pd
     2df = pd.read_csv("thunderbit_output.csv")

   • Jetzt kannst du filtern, bereinigen, zusammenführen, visualisieren oder tiefer analysieren – ganz nach Bedarf.

3. Automatisiere den Workflow:

   • Thunderbit unterstützt geplantes Scraping, sodass du täglich frische Daten bekommst.
   • Kombiniere das mit Python-Skripten für automatisierte Berichte, Benachrichtigungen oder weitere Verarbeitung.

Warum beide Tools nutzen? Thunderbit spart dir stundenlanges Coden und Debuggen – besonders bei schwierigen oder einmaligen Projekten. Mit Python kannst du die Daten dann flexibel weiterverarbeiten, analysieren und in deine Geschäftsprozesse einbinden. Wie Erdnussbutter und Marmelade: einzeln lecker, zusammen unschlagbar ().

Typische Herausforderungen beim Web Scraping mit Python

daten scrapen läuft nicht immer reibungslos. Hier die häufigsten Stolpersteine – und wie du sie umgehst:

1. Blockiert werden (403/429-Fehler, CAPTCHAs):

• User-Agent-String rotieren, um wie ein echter Browser zu wirken.
• Proxys nutzen, um IP-Adressen zu wechseln ().
• Pausen zwischen Anfragen einbauen (time.sleep()).
• robots.txt und Crawl-Delay-Regeln beachten.
• Bei CAPTCHAs: Selenium für manuelles Lösen oder spezielle CAPTCHA-Dienste nutzen.

2. Dynamische Inhalte werden nicht geladen:

• Selenium einsetzen, um JavaScript-lastige Seiten zu rendern.
• Im Netzwerk-Tab nach internen API-Aufrufen suchen – oft kannst du die Daten direkt als JSON abgreifen.

3. Login- oder Session-Probleme:

• Mit requests.Session() Cookies speichern.
• Login-Prozesse ggf. mit Selenium automatisieren.

4. Änderungen an der Webseitenstruktur:

• Robuste Selektoren schreiben (IDs bevorzugen).
• Änderungen überwachen und Skripte anpassen.
• Thunderbits KI passt sich automatisch an Layout-Änderungen an und spart dir Wartungsaufwand.

5. Große Datenmengen:

• Mit Parallelisierung (concurrent.futures oder asyncio) das Scraping beschleunigen.
• Daten schrittweise auf Festplatte oder in eine Datenbank schreiben, um Speicherprobleme zu vermeiden.

(, )

Troubleshooting: Scraping-Skripte debuggen und optimieren

Wenn’s mal hakt (und das passiert jedem), hilft diese Checkliste:

• HTTP 404/403/429: Prüfe URL, Header und Anfragefrequenz.
• Timeouts/Verbindungsfehler: Wiederholungen mit Backoff-Strategie einbauen.
• AttributeError/NoneType: Vor dem Zugriff auf Elemente prüfen, ob sie existieren; HTML inspizieren.
• Encoding-Probleme: response.encoding = 'utf-8' setzen oder beim Speichern das Encoding angeben.
• Selenium findet Elemente nicht: Explizite Wartezeiten nutzen; Selektoren prüfen.
• Speicherprobleme: Daten in Batches schreiben, Generatoren nutzen oder auf Datenbank umsteigen.
• Debugging: Mit print, Logging oder HTML-Export Fehlerquellen finden.

Für mehr Performance: Asynchrone Requests (aiohttp), Threads oder ein Framework wie Scrapy für große Projekte. Aber: Für kleine Jobs lieber auf Übersichtlichkeit setzen als auf zu viel Optimierung.

Best Practices: Recht und Ethik beim Web Scraping

Mit großer Scraping-Power kommt auch Verantwortung. So bleibst du auf der sicheren Seite:

• robots.txt und Nutzungsbedingungen respektieren: Wenn eine Seite Scraping verbietet, halte dich daran.
• Keine sensiblen oder persönlichen Daten sammeln: Bleib bei öffentlichen Infos; alles andere ist tabu.
• Fair bleiben: Anfragefrequenz begrenzen, Stoßzeiten meiden, Server nicht überlasten.
• Dich identifizieren: Bei Bedarf einen eigenen User-Agent mit Kontaktinfo nutzen.
• Rechtliche Lage prüfen: In den USA ist das Scrapen öffentlicher Daten meist legal, aber Verstöße gegen AGB oder das Scrapen privater Daten können Ärger bringen ().
• APIs bevorzugen: Gibt es eine offizielle API, nutze sie – das ist sicherer und stabiler.

(, )

Fazit & wichtigste Erkenntnisse

daten scrapen mit Python ist eine der wertvollsten Skills in der heutigen datengetriebenen Welt. Das Wichtigste in Kürze:

• Python ist die Top-Wahl fürs Web Scraping – dank einfacher Syntax, starker Bibliotheken und großer Community ().
• Starte mit statischen Seiten (requests, BeautifulSoup); für dynamische Inhalte nutze Selenium.
• Thunderbit spart dir viel Zeit bei komplexen oder einmaligen Scraping-Aufgaben – Python übernimmt dann Analyse und Automatisierung.
• Typische Probleme löst du mit rotierenden Headern, Proxys, Pausen und robuster Fehlerbehandlung.
• Scrape verantwortungsvoll: Respektiere Webseiten, meide sensible Daten und bleib rechtlich sauber.

Mein Tipp: Fang klein an – such dir eine einfache Seite, schreib dein erstes Skript und schau, was du extrahieren kannst. Wenn du dich sicher fühlst, kombiniere Thunderbit und Python für noch mehr Power. Und denk dran: Jeder Fehler ist nur ein Rätsel, das gelöst werden will (und manchmal hilft Stack Overflow).

Du willst Thunderbit in Aktion sehen oder mehr übers scrapen lernen? Schau im vorbei oder abonniere unseren für Tutorials und Tipps.

Viel Spaß beim scrapen – auf dass deine Daten immer sauber, deine Skripte fehlerfrei und deine IPs ungesperrt bleiben.

FAQs

1. Was ist Web Scraping und ist das legal?
Web Scraping ist das automatisierte Auslesen von Daten aus Webseiten. Das scrapen öffentlicher Daten ist in den USA und vielen anderen Ländern meist legal – aber halte dich an die Nutzungsbedingungen, meide sensible Daten und beachte Datenschutzgesetze ().

2. Warum nutzen die meisten fürs Web Scraping Python?
Python ist einsteigerfreundlich, bietet für jeden Scraping-Schritt starke Bibliotheken (requests, BeautifulSoup, Selenium, pandas) und hat eine riesige Community ().

3. Wann sollte ich Selenium statt requests/BeautifulSoup nutzen?
Selenium brauchst du, wenn die Daten erst durch JavaScript geladen werden und nicht im ursprünglichen HTML stehen. Selenium steuert einen echten Browser und sieht die Seite wie ein Nutzer.

4. Wie arbeitet Thunderbit mit Python zusammen?
Mit Thunderbit kannst du auch komplexe oder unstrukturierte Daten per KI in wenigen Klicks scrapen und als CSV/Excel/Sheets exportieren. Diese Daten kannst du dann in Python weiterverarbeiten – das spart dir viel Programmieraufwand.

5. Was sind die wichtigsten Tipps, um beim Scrapen nicht geblockt zu werden?
User-Agent rotieren, Proxys nutzen, Pausen einbauen, robots.txt respektieren und keine sensiblen oder privaten Daten scrapen. Bei großen Projekten ggf. Anti-Bot-Tools oder -Dienste einsetzen.

Bereit, selbst loszulegen? Lade dir die herunter und erlebe, wie einfach sich KI und Python fürs nächste Datenprojekt kombinieren lassen. Und falls du mal nicht weiterkommst: Jeder Profi hat mal mit einer einzigen Codezeile angefangen.

Mehr erfahren