Website-Daten nach Excel scrapen — 3 Wege, die funktionieren

Es gibt drei echte Wege, Daten von einer Website nach Excel zu scrapen: die Bordmittel, die du bereits hast (Excel Power Query und die Import-Formeln von Google Sheets), ein No-Code-Scraper wie Octoparse oder Browse AI und ein kurzes Python-Skript, das eine API aufruft und die Arbeitsmappe für dich schreibt. Jeder Weg funktioniert — für eine bestimmte Art von Website und eine bestimmte Art von Nutzer. Dieser Guide geht alle drei ehrlich durch, mit Copy-Paste-Beispielen, und endet mit einer Vergleichstabelle, damit du in dreißig Sekunden entscheiden kannst.

Methode 1: Die Bordmittel — Excel Power Query und Google-Sheets-Formeln

Wenn die gewünschte Seite eine schlichte HTML-Tabelle ist — eine Wikipedia-Liste, eine Liga-Tabelle, eine Statistik-Tabelle einer Behörde — fang hier an. Es dauert zwei Minuten und kostet nichts.

Excel: Power Query »From Web«

Excel 2016 und neuer bringen Power Query mit, das Tabellen direkt von einer URL ziehen kann:

1. Öffne Excel und geh auf die Registerkarte Data.
2. Klicke auf From Web (in der Gruppe Get and Transform Data) und füge die URL der Seite ein.
3. Im Navigator zeigt Excel eine Vorschau jeder Tabelle, die es auf der Seite gefunden hat. Wähl eine aus.
4. Klicke auf Transform Data, um Spalten und Typen im Power-Query-Editor zu bereinigen, oder auf Load, um sie direkt ins Sheet zu laden.

Das Ergebnis ist eine Live-Abfrage, kein einmaliges Einfügen: Rechtsklick auf die Tabelle und Refresh wählen, oder unter Data → Queries & Connections → Properties → Refresh every N minutes einstellen, dass alle N Minuten neu abgerufen wird, solange die Arbeitsmappe geöffnet ist.

Google Sheets: IMPORTHTML und IMPORTXML

Google Sheets erledigt denselben Job mit zwei Formeln. IMPORTHTML greift die N-te Tabelle oder Liste einer Seite ab:

=IMPORTHTML("https://en.wikipedia.org/wiki/List_of_countries_by_population_(United_Nations)", "table", 1)

IMPORTXML ist das Präzisionswerkzeug — es nimmt eine XPath-Query, sodass du ein einzelnes Element statt einer ganzen Tabelle ziehen kannst:

=IMPORTXML("https://example.com/product", "//h1")
=IMPORTXML("https://en.wikipedia.org/wiki/Moon_landing", "//a/@href")

Die zweite Formel holt jedes Link-href der Seite. Sheets wertet diese Importe periodisch neu aus (grob stündlich), was dir eine grobe Auto-Aktualisierung gratis gibt.

Wo die Bordmittel nicht mehr funktionieren

Beide Tools teilen eine harte Grenze: sie lesen das rohe HTML, das der Server beim ersten Laden sendet. Füllt die Website ihre Daten danach per JavaScript ein — was auf Amazon, Google-Ergebnisse, den meisten E-Commerce, die meisten Dashboards und nahezu jede moderne Web-App zutrifft — sieht Power Query eine leere Seite, und IMPORTXML liefert #N/A oder gar nichts. Es gibt keinen Browser-Rendering-Schritt, kein Login-Handling und keine anti-bot-Umgehung: Websites, die automatisierte Anfragen drosseln oder blockieren, blockieren auch diese Tools, und Googles geteilte IPs für Sheets-Importe werden von vielen Websites von Haus aus gesperrt.

Die Bordmittel sind außerdem auf eine leisere Art brüchig: Die Formel zeigt auf eine Position im Markup der Seite, ein Redesign bricht sie also lautlos. Das ist ein generelles Problem von HTML parsing — die Seite ist ein bewegliches Ziel —, aber mit Formeln bekommst du überhaupt kein Error-Handling, nur #N/A in Zelle A1 am Montagmorgen.

Fazit: perfekt für statische Tabellen, die du gelegentlich anschaust. Das falsche Werkzeug für dynamische Seiten, geschützte Seiten oder alles, was zuverlässig nach Zeitplan laufen muss.

Methode 2: No-Code-Scraper (Octoparse, Browse AI und Co.)

Die nächste Stufe ist ein visueller Scraper. Octoparse bietet dir einen Point-and-Click-Workflow-Builder mit automatischer Erkennung der Datenfelder, vorgefertigten Templates für populäre Websites, Cloud-Scheduling und direktem Export nach Excel, CSV oder Google Sheets. Browse AI trainiert einen »Robot«, indem es dir beim Anklicken der gewünschten Felder zusieht, führt ihn dann nach Zeitplan neu aus (stündlich, täglich) und kann Ergebnisse in Google Sheets oder Airtable synchronisieren, mit Änderungs-Monitoring obendrauf. Beide bewältigen JavaScript-gerenderte Seiten, Pagination und — in Bezahl-Plänen — Proxy-Rotation.

Das ist eine wirklich gute Wahl für einen nicht-technischen Nutzer, der ein oder zwei Websites überwachen muss: kein Code, ein visueller Editor und ein funktionierender Export innerhalb einer Stunde.

Die ehrlichen Kompromisse:

• Setup pro Website. Jede Website ist ihr eigener Robot oder Task. Zehn Websites bedeuten zehn Konfigurationen, die du bauen und hüten musst.
• Brüchigkeit bei Redesigns. Der Robot klickt Selektoren, die er sich gemerkt hat. Liefert die Website ein Redesign aus, gibt der Robot falsche oder leere Daten zurück, bis du ihn neu trainierst — und oft merkst du es erst an der kaputten Tabelle.
• Abo-Kosten. Die kostenlosen Stufen sind klein; nützliche Volumen, Cloud-Scheduling und Proxys liegen in Bezahl-Plänen, die typischerweise etwa beim Preis eines mittleren SaaS-Sitzes starten und mit dem Seitenvolumen klettern.
• Schwer zu versionieren und zu integrieren. Der Scraper lebt in der GUI eines Anbieters, nicht in deinem Repo, und passt daher nicht so in Code-Review, CI oder nachgelagerte Pipelines wie ein Skript.

Fazit: die richtige Wahl für Nicht-Programmierer, die eine Handvoll dynamischer Seiten beobachten. Weniger richtig, sobald du viele Quellen, eigene Transformationen oder etwas brauchst, das dein Team in Git pflegen kann.

Methode 3: Python — API-Aufruf, pandas und to_excel()

Wenn du ein Python-Skript ausführen kannst — oder jemanden in der Nähe hast, der das kann —, ist das die stärkste Option, und sie ist kürzer, als die meisten erwarten. Das Muster: einen Endpoint aufrufen, der sauberes JSON liefert, es mit pandas flachziehen, die Arbeitsmappe mit to_excel() schreiben. Keine Selektoren zu pflegen, denn eine scraping API übernimmt Rendering, Proxys und Retries auf ihrer Seite und liefert dieselben normalisierten Felder, selbst wenn sich das Markup der Website ändert. (Für den ausführlicheren Vergleich zwischen Selbst-Scrapen und API-Aufruf siehe web scraping vs API; für den From-Scratch-Weg decken unser Pillar-Artikel web scraping with Python und das BeautifulSoup tutorial das eigene Parsen von rohem HTML ab.)

Hier die End-to-End-Version mit Crawloras Amazon-Search-Endpoint. Installiere zuerst die drei Bibliotheken:

pip install requests pandas openpyxl

Dann das komplette Skript:

import requests
import pandas as pd

API_KEY = "YOUR_API_KEY"  # free tier: 2,000 credits/month, no card

resp = requests.get(
    "https://api.crawlora.net/api/v1/amazon/search",
    params={"k": "mechanical keyboard"},
    headers={"x-api-key": API_KEY},
    timeout=60,
)
resp.raise_for_status()
rows = resp.json()["data"]  # list of normalized result cards

df = pd.DataFrame(rows)[
    ["asin", "title", "price", "list_price", "rating", "review_count", "link"]
]
df.to_excel("amazon-keyboards.xlsx", index=False, sheet_name="results")
print(f"Wrote {len(df)} rows to amazon-keyboards.xlsx")

Führ es aus, und du hast eine echte .xlsx auf der Platte — Spalten typisiert, kein Copy-Paste, keine Selektoren. Tausch das Keyword im Parameter k aus oder wechsle den Endpoint auf eine der anderen unterstützten Plattformen; die Docs listen die Felder jedes Endpoints, und im Playground kannst du einen Request im Browser testen, bevor du eine Zeile Code schreibst. Weil die API pay-on-success abrechnet — berechnet werden nur erfolgreiche 2xx-Antworten —, kostet ein fehlgeschlagener Abruf dich einen Retry, keine Credits.

Die Google-Sheets-Variante (gspread)

Sollen die Daten lieber in einem geteilten Google Sheet landen statt in einer Datei? Gleiches Skript, anderer letzter Schritt, mit der gspread-Bibliothek und einem Google-Service-Account:

• Erstelle in der Google Cloud Console ein Projekt und aktiviere die Google Sheets API und die Google Drive API.
• Erstelle einen Service-Account und lade dessen JSON-Key-Datei herunter.
• Teile deine Ziel-Tabelle mit der E-Mail-Adresse des Service-Accounts (sie endet auf iam.gserviceaccount.com), genau wie beim Teilen mit einem Kollegen.

import gspread

gc = gspread.service_account(filename="service-account.json")
ws = gc.open("Keyboard price tracker").sheet1
ws.clear()
ws.update([df.columns.tolist()] + df.fillna("").values.tolist())

Alle, die das Sheet geöffnet haben, sehen die neuen Daten beim nächsten Refresh — kein Datei-Herummailen.

Fazit: rund fünfzehn Minuten Setup, danach die langlebigste Option auf dieser Seite: bewältigt JS-lastige und geschützte Seiten über die API, übersteht Redesigns, lebt in der Versionsverwaltung und skaliert mit einer Schleife von einem Keyword auf tausend.

Aktuell halten: den Refresh planen

Eine Tabelle, die letzten Monat korrekt war, ist der Weg zu schlechten Entscheidungen. Alle drei Methoden können aktualisieren, aber nur das Skript aktualisiert unbeaufsichtigt:

• cron (macOS/Linux): 0 6 * * * /usr/bin/python3 /home/you/refresh.py führt das Skript jeden Morgen um 06:00 neu aus.
• Task Scheduler (Windows): erstelle eine Basic Task, Trigger Daily, Aktion Start a program, die auf python.exe zeigt, mit deinem Skript-Pfad als Argument.
• GitHub Actions — die schönste Option, weil sie keine Maschine braucht, die anbleibt:

name: refresh-sheet
on:
  schedule:
    - cron: "0 6 * * *"  # daily at 06:00 UTC
jobs:
  refresh:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - run: pip install requests pandas openpyxl gspread
      - run: python refresh.py
        env:
          CRAWLORA_API_KEY: ${{ secrets.CRAWLORA_API_KEY }}

Bewahre den API-Key in den Actions-Secrets des Repos auf, niemals im Skript. Wenn du die aktualisierte .xlsx als Build-Artefakt pushst oder per gspread in Google Sheets schreibst, aktualisiert sich die Tabelle jeden Tag selbst — egal, ob dein Laptop offen ist oder nicht. Eine Höflichkeitsnotiz für jedes geplante Scraping: halte den Takt verhältnismäßig — ein täglicher Abruf ist etwas anderes, als einen Endpoint jede Minute zu hämmern, und rate limits gibt es auch bei APIs.

(Power Query kann automatisch aktualisieren, solange eine Arbeitsmappe geöffnet ist, und Sheets-Import-Formeln rechnen von selbst grob stündlich neu — für Gelegenheitsnutzung okay, aber keines von beiden läuft bei geschlossener Datei, und keines wiederholt einen Fehlversuch.)

Welche Methode solltest du nutzen?

Entscheidungshilfe, je nachdem, wer du bist:

• Analyst mit statischer Tabelle und Deadline: Power Query oder IMPORTHTML. In fünf Minuten fertig; nicht überdenken.
• Marketer oder Ops-Person, die ein oder zwei dynamische Seiten beobachtet, ganz ohne Code: ein No-Code-Tool verdient sich sein Abo. Plane Zeit ein, um Robots nach Redesigns neu zu trainieren.
• Alle, die viele Quellen, geschützte Seiten oder eine geplante Pipeline brauchen, die das Team pflegen kann: das Python-+-API-Skript. Es ist die einzige Option hier, die gleichzeitig günstig, langlebig und Ende-zu-Ende automatisierbar ist.
• Junior-Dev, der überlegt, den Scraper selbst zu bauen: lies zuerst web scraping with Python — DIY ist ein großartiger Skill, aber für Produktions-Tabellen nimmt dir der API-Weg die Proxy-, Rendering- und Parser-Wartung ab, die die Zeit frisst.

• Stecken die Daten im initialen HTML? Wenn ja, reicht Power Query / IMPORTHTML.
• Ist die Seite JavaScript-gerendert oder bot-geschützt? Dann brauchst du ein No-Code-Tool oder eine API.
• Muss es unbeaufsichtigt aktualisieren? Skript + cron/Actions ist der zuverlässige Weg.
• Mehr als ein paar Websites, oder Teamkollegen, die es pflegen müssen? Dann lieber Code statt GUI-Robots.
• Scrape nur öffentliche Daten, halte den Takt höflich und prüfe die Bedingungen der Website.

Verwandle jede unterstützte Website in eine Tabelle

Ein GET-Request liefert normalisiertes JSON — pandas und to_excel() erledigen den Rest. 2,000 kostenlose Credits pro Monat, ohne Karte, und pay-on-success: berechnet werden nur erfolgreiche 2xx-Antworten.

Try it in the PlaygroundSee the Web Scraping API

Weiterlesen: der Pillar-Artikel web scraping with Python für das komplette DIY-Toolkit, das BeautifulSoup tutorial, wenn du HTML selbst parsen willst, und web scraping vs API dazu, wann welcher Ansatz gewinnt.