TechCrunch mit Python scrapenSchlagzeilen und Metadaten

TechCrunch veröffentlicht täglich Dutzende von Berichten über Startups, Finanzierungsrunden, Produkteinführungen und die Menschen, die die Technologiebranche bewegen. Jeder Artikel trägt einen übersichtlichen Satz öffentlicher Metadaten, den ein Trendtracker, ein Marktforschungs-Dashboard oder ein Newsroom-Monitor tatsächlich benötigt: die Schlagzeile, wer sie geschrieben hat, wann sie online ging, in welcher Kategorie und unter welchen Tags sie eingeordnet ist, die Artikel-URL und eine kurze Zusammenfassung. Der Haken ist, dass TechCrunch auf einem gehärteten WordPress-Stack läuft, der automatisierten Traffic schnell erkennt, sodass ein naiver Scraper blockiert wird, lange bevor er etwas Nützliches gesammelt hat.

Dieser Leitfaden zeigt, wie man TechCrunch mit Python zuverlässig scrapt. Es wird ein kleines, lauffähiges Scraper-Skript erstellt, das eine Listingseite über die Crawling API abruft, jede Artikelkarte mit BeautifulSoup parst und saubere strukturierte Ausgaben druckt. Der gesamte Walkthrough bleibt auf öffentliche Artikel-Metadaten beschränkt, nie auf vollständige Artikeltexte, und der Abschnitt zur Rechtslage gegen Ende ist kein Boilerplate. Vor dem Einsatz auf echtem Volumen lesen.

Was du bauen wirst

Ein Python-Skript, das eine öffentliche TechCrunch-Listing-URL nimmt, das HTML über die Crawling API abruft und für jeden Artikel auf der Seite einen strukturierten Datensatz extrahiert. Als laufendes Beispiel dient der TechCrunch-Homepage-Feed, und folgende Felder werden aus jeder Karte gezogen:

• Schlagzeile der Artikeltitel, wie er im Listing erscheint.
• Artikel-URL der Link zur einzelnen Geschichte.
• Autor die auf der Karte zugeschriebene Byline.
• Veröffentlichungsdatum der maschinenlesbare Zeitstempel aus dem datetime-Attribut.
• Kategorie und Tags die Rubrik oder das Thema, unter dem der Artikel eingeordnet ist.
• Zusammenfassung die kurze Zusammenfassung unterhalb der Schlagzeile.

Warum eine einfache Anfrage bei TechCrunch scheitert

Man kann Pythons requests auf eine TechCrunch-URL richten und manchmal HTML zurückbekommen, aber ein echter Scraping-Lauf bleibt selten so einfach. TechCrunch sitzt hinter einer Edge-Schicht, die Scraper-artigen Traffic beobachtet, und zwei Dinge spielen dagegen. Erstens werden Rechenzentrum-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, nach den ersten paar Anfragen ratenbegrenzt oder erhalten eine Challenge-Seite, und wiederholte Treffer von einer Adresse überschreiten diese Schwelle schnell. Zweitens können manche Listing- und Feed-Ansichten Inhalte mit JavaScript befüllen, sodass das abgerufene rohe HTML die gesuchten Karten vermissen lässt.

Ein verlässlicher TechCrunch-Scraper benötigt daher zwei Dinge in einer Anfrage: eine IP, die die Plattform als echten Besucher einstuft, und, wo die Ansicht clientseitig gerendert wird, einen Browser, der tatsächlich die Skripte der Seite ausführt. Das kann man selbst mit einem Pool aus rotierenden IPs und einem Headless-Browser zusammenstellen, aber diese zu verbinden und am Laufen zu halten, ist der Großteil der Arbeit. Die Crawling API bündelt beides in einem einzigen Aufruf: Man sendet ihr die URL, sie ruft die Seite hinter einer vertrauenswürdigen, rotierenden IP ab, rendert optional JavaScript und gibt fertiges HTML zum Parsen zurück.

Voraussetzungen

Vor dem Schreiben von Code müssen einige Dinge bereitstehen. Keines davon dauert lange.

Python-Grundkenntnisse. Man sollte in der Lage sein, ein Python-Skript zu schreiben, auszuführen und Pakete mit pip zu installieren. Wer mit BeautifulSoup noch nicht vertraut ist, findet in unserem Leitfaden zur Verwendung von BeautifulSoup in Python die Parsing-Grundlagen, die dieses Tutorial voraussetzt.

Python 3.8 oder neuer. Die Version mit python --version prüfen. Falls nicht vorhanden, unter python.org oder über eine Distribution wie Anaconda installieren.

Ein Crawlbase-Konto und Token. Anmelden, das Dashboard öffnen und den normalen Token von der Account-Docs-Seite kopieren. Den Token wie ein Passwort behandeln: er authentifiziert die Anfragen, also aus der Versionskontrolle heraushalten.

Das Projekt einrichten

Eine virtuelle Umgebung erstellen, damit Projektabhängigkeiten isoliert bleiben, dann die Bibliotheken installieren, die der Scraper benötigt.

python --version

python -m venv techcrunch_env
source techcrunch_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Unter Windows die Umgebung statt mit der source-Zeile mit techcrunch_env\Scripts\activate aktivieren. Drei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Client für die Crawling API, beautifulsoup4 parst das zurückgegebene HTML, damit man einzelne Felder per CSS-Selektor extrahieren kann, und pandas macht es einfach, die Datensätze am Ende als CSV zu schreiben.

Schritt 1: Die Listingseite abrufen

Zunächst die Seite abrufen. Die Klasse CrawlingAPI importieren, sie mit dem Token initialisieren und die Listing-URL anfordern. Den Status vor dem Parsen zu prüfen, hält Fehler laut statt still.

from crawlbase import CrawlingAPI

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

def crawl(page_url):
    options = {"country": "US"}
    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://techcrunch.com"
    html = crawl(page_url)
    print(html[:500] if html else "No HTML returned")

Die country-Option bindet die Anfrage an eine US-Ausgangs-IP, was wichtig ist, weil TechCrunch je nach Region unterschiedliche Inhalte ausliefern kann. Das Skript mit python scraper.py ausführen, und es sollte echtes Artikel-Markup in den ersten 500 Zeichen zu sehen sein, keine Block-Seite oder leere Hülle. Das bestätigt, dass der Abruf hinter einer vertrauenswürdigen IP funktioniert, bevor ein einziger Selektor geschrieben wird. Wenn die Karten leer zurückkommen, mit einem JS-Token erneut ausführen, um die Seite zu rendern, wie der Callout oben beschreibt.

Schritt 2: Artikelkarten mit BeautifulSoup parsen

Mit dem HTML in der Hand lädt man es in BeautifulSoup und zieht jeden Artikel per Selektor heraus. TechCrunch legt seine Listings als wiederholten Block aus, also werden alle Artikel-Container einmal ausgewählt und dann dieselben Felder aus jedem gelesen. Im WordPress-Markup sitzt jeder Artikel innerhalb eines Containers mit der Klasse wp-block-tc23-post-picker, der der Ankerpunkt für die Schleife ist. Die Live-Seite in den Browser-DevTools untersuchen, um die aktuellen Klassennamen zu bestätigen, da sich dieses Markup im Laufe der Zeit verschiebt.

from bs4 import BeautifulSoup

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

def parse_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div.wp-block-tc23-post-picker")
    articles = []

    for card in cards:
        title_el = card.select_one("h2.wp-block-post-title")
        link_el = title_el.select_one("a") if title_el else None
        time_el = card.select_one("time")
        articles.append({
            "headline": title_el.get_text(strip=True) if title_el else "",
            "url": link_el["href"] if link_el else "",
            "author": text_of(card, "div.wp-block-tc23-author-card-name"),
            "publish_date": time_el["datetime"] if time_el else "",
            "category": text_of(card, "div.wp-block-tc23-post-picker__category a"),
            "excerpt": text_of(card, "p.wp-block-post-excerpt__excerpt"),
        })

    return articles

Zwei Muster sorgen für Robustheit. Der Helfer text_of gibt einen leeren String statt einer Ausnahme zurück, wenn ein Selektor fehlt, damit eine fehlerhafte Karte nie den gesamten Lauf zum Absturz bringt. Und das Veröffentlichungsdatum aus dem datetime-Attribut des <time>-Tags zu lesen, liefert einen sauberen ISO-Zeitstempel statt des benutzerfreundlichen Textes, den die Karte anzeigt, was das nachgelagerte Sortieren und Filtern erheblich erleichtert. Der Kategorie-Selektor zielt auf den kleinen Topic-Link über jeder Schlagzeile; eine Karte ohne Kategorie ergibt einen leeren String.

Schritt 3: Das vollständige Skript zusammensetzen

Jetzt das Abrufen und den Parser in eine lauffähige Datei kombinieren, auf den Homepage-Feed richten und die Datensätze auf Datenträger schreiben. Die main-Funktion verbindet die Teile und speichert eine CSV mit pandas, damit die Ausgabe direkt in eine Tabellenkalkulation oder ein Notebook fällt.

import json
import pandas as pd
from bs4 import BeautifulSoup
from crawlbase import CrawlingAPI

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

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

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

def parse_listings(html):
    soup = BeautifulSoup(html, "html.parser")
    cards = soup.select("div.wp-block-tc23-post-picker")
    articles = []
    for card in cards:
        title_el = card.select_one("h2.wp-block-post-title")
        link_el = title_el.select_one("a") if title_el else None
        time_el = card.select_one("time")
        articles.append({
            "headline": title_el.get_text(strip=True) if title_el else "",
            "url": link_el["href"] if link_el else "",
            "author": text_of(card, "div.wp-block-tc23-author-card-name"),
            "publish_date": time_el["datetime"] if time_el else "",
            "category": text_of(card, "div.wp-block-tc23-post-picker__category a"),
            "excerpt": text_of(card, "p.wp-block-post-excerpt__excerpt"),
        })
    return articles

def main():
    page_url = "https://techcrunch.com"
    html = crawl(page_url)
    if not html:
        return
    articles = parse_listings(html)
    print(json.dumps(articles[:3], indent=2))
    pd.DataFrame(articles).to_csv("techcrunch_listing.csv", index=False)
    print(f"Saved {len(articles)} articles")

if __name__ == "__main__":
    main()

Das ist der vollständige Scraper. Er ruft den Homepage-Feed ab, parst jede Karte in einen Datensatz mit den sechs öffentlichen Feldern, druckt die ersten drei als JSON und schreibt den vollständigen Satz in techcrunch_listing.csv. Die page_url auf eine beliebige öffentliche Listing-URL, z. B. einen Kategorie- oder Tag-Feed, austauschen, und derselbe Parser verarbeitet sie.

Wie die Ausgabe aussieht

Das vollständige Skript mit python scraper.py ausführen und man erhält einen sauberen strukturierten Datensatz für jeden Artikel, bereit zum Schreiben in JSON, CSV oder eine Datenbank.

[
  {
    "headline": "Open source tools to boost your productivity",
    "url": "https://techcrunch.com/2024/08/11/a-not-quite-definitive-guide-to-open-source-alternative-software/",
    "author": "Paul Sawers",
    "publish_date": "2024-08-11T09:00:00-07:00",
    "category": "Apps",
    "excerpt": "TechCrunch has pulled together some open-source alternatives to popular productivity apps."
  },
  {
    "headline": "Oyo valuation crashes over 75% in new funding",
    "url": "https://techcrunch.com/2024/08/11/oyo-valuation-crashes-over-75-in-new-funding/",
    "author": "Manish Singh",
    "publish_date": "2024-08-11T06:07:12-07:00",
    "category": "Fintech",
    "excerpt": "The valuation of Oyo, once India's second-most valuable startup at $10 billion, has dipped to $2.4 billion."
  }
]

Zu beachten: Die Zusammenfassung ist eine kurze Inhaltsangabe, nicht der vollständige Artikeltext. Das ist beabsichtigt. Die Listingkarte gibt einen Teaser aus, und die Metadatenfelder darum herum sind genau die öffentlichen Signale, die man für das Trend-Tracking benötigt, ohne den redaktionellen Text selbst zu kopieren.

Seiten durchschleifen und Anfragen verteilen

Ein Listing ist eine Demo; ein echter Job läuft über viele Seiten. TechCrunch paginiert seine Feeds mit einem einfachen URL-Muster: Die Homepage ist https://techcrunch.com und die nächsten Seiten sind https://techcrunch.com/page/2/, https://techcrunch.com/page/3/ usw. Die Form bleibt gleich: jede Seiten-URL aufbauen, sie über die Crawling API abrufen, mit derselben Funktion parsen und die Zeilen sammeln. Anfragen zwischen Seiten zu verteilen, hält einen langen Lauf gesund.

import time

def scrape_pages(num_pages=5):
    results = []
    for page in range(1, num_pages + 1):
        url = "https://techcrunch.com" if page == 1 else f"https://techcrunch.com/page/{page}/"
        print(f"Scraping page {page}")
        html = crawl(url)
        if html:
            results.extend(parse_listings(html))
        time.sleep(3)
    return results

Der time.sleep-Aufruf verteilt Anfragen, damit TechCrunch nicht in einer engen Schleife bombardiert wird. Da jede Seite dieselbe Kartenstruktur teilt, funktioniert der bereits geschriebene Parser auf allen ohne Änderungen, und man speist die kombinierte Liste in denselben pandas-to_csv-Aufruf aus dem vollständigen Skript ein.

Entsperrt bleiben

Selbst mit einer vertrauenswürdigen IP für den Abruf beobachtet TechCrunch Scraper-artigen Traffic. Einige Gewohnheiten halten einen Lauf gesund, und sie gelten für jedes gehärtete Ziel.

• Anfragen verteilen. Listing-Seiten in einer engen Schleife zu bombardieren, ist der schnellste Weg zum Drosseln. Anfragen aufteilen und Ziele variieren statt einen Feed mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool aus Residential-IPs verteilt Anfragen über viele echte Nutzeradressen, damit keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt das; wer seinen eigenen Stack aufbaut, sollte hier besonders sorgfältig vorgehen.
• Statuscodes beachten. Ein Lauf, der beginnt, Challenges oder Fehler zurückzugeben, signalisiert, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Das als Signal zum Zurückrudern, nicht als zu ignorierendes Rauschen behandeln.

Das umfassendere Playbook findet sich unter wie man Websites scrapt, ohne blockiert zu werden und im tieferen Einblick zum Umgehen von CAPTCHAs beim Web-Scraping. Wenn ein bestimmter Feed clientseitig gerendert ist, erklärt unser Leitfaden zum Scrapen von JavaScript-Seiten mit Python, warum Rendering wichtig ist. Und wenn man den eigenen Traffic lieber über einen rotierenden Pool statt über die verwaltete API leiten möchte, gibt der Smart AI Proxy (auch AI Proxy genannt) dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist es legal, TechCrunch zu scrapen?

Ob das Scrapen von TechCrunch erlaubt ist, hängt von TechCrunchs Nutzungsbedingungen, der jeweiligen Rechtsordnung und dem Verwendungszweck der Daten ab. TechCrunchs Bedingungen setzen der automatisierten Nutzung Grenzen, und sein Inhalt ist urheberrechtlich geschütztes redaktionelles Material, sodass die rechtliche Lage hier enger ist als bei einer öffentlichen Listingseite. Keiner der Codes in diesem Leitfaden ändert das; er lässt nur den technischen Teil funktionieren. Die TechCrunch-Nutzungsbedingungen und die robots.txt lesen und beide als Grenze für das Sammeln behandeln.

Die Grenze, die das verteidigbar macht, ist der Unterschied zwischen Metadaten und den Artikeln selbst. Das Sammeln öffentlicher Metadaten (Schlagzeile, Autor, Veröffentlichungsdatum, Kategorie und Tags, Artikel-URL und die kurze Zusammenfassung) für Recherche oder Trendanalyse ist eine weitaus leichtere Nutzung als das Kopieren vollständiger Artikeltexte. Den von TechCrunch produzierten redaktionellen Text nicht weiterveröffentlichen oder verbreiten; das ist urheberrechtlich geschütztes Material, und seine Weiterveröffentlichung verstößt direkt sowohl gegen die Bedingungen als auch gegen das Urheberrecht. Wer die zugrunde liegenden Geschichten in großem Umfang benötigt, muss eine Inhaltslizenz oder eine offizielle Vereinbarung einholen, keinen clevereren Scraper.

Es lohnt sich auch zu wissen, dass TechCrunch auf WordPress läuft, was bedeutet, dass es für einen Großteil dieser Daten einen leichteren offiziellen Weg gibt. TechCrunch veröffentlicht RSS-Feeds und stellt eine WordPress-REST-API unter /wp-json/wp/v2/posts bereit, die aktuelle Beiträge als strukturiertes JSON zurückgibt, einschließlich Titeln, Links, Daten und Zusammenfassungen, ohne die gerenderte Seite zu scrapen. Diese Endpunkte bevorzugen, wenn sie den Bedarf abdecken, und alle beworbenen Rate-Limits respektieren. Dieser Leitfaden beschränkt sich auf öffentliche Listingseiten und Metadaten; er deckt nichts hinter einem Login, personenbezogene Daten oder die Weiterverbreitung von Volltexten ab.

Häufig gestellte Fragen

Warum wird eine einfache Anfrage bei TechCrunch blockiert?

TechCrunch sitzt hinter einer Edge-Schicht, die automatisierten Traffic erkennt. Rechenzentrum-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden nach wenigen Anfragen ratenbegrenzt oder erhalten eine Challenge, sodass eine einfache requests-Schleife schnell aufhört zu funktionieren. Das Abrufen über die Crawling API leitet die Anfrage über eine Residential-IP, die die Plattform als echten Besucher einstuft, was den Lauf am Laufen hält.

Brauche ich den normalen Token oder den JS-Token für TechCrunch?

Normalerweise den normalen Token. TechCrunch-Listings sind weitgehend serverseitig gerendertes WordPress-Markup, daher enthalten die Artikelkarten bereits das statische HTML, das der normale Token zurückgibt. Wenn ein bestimmter Feed mit leeren Karten zurückkommt, zum JS-Token wechseln, der die Seite in einem echten Browser rendert, bevor das HTML übergeben wird.

Welche Felder kann ich aus einem TechCrunch-Listing extrahieren?

Die öffentlichen Metadaten auf jeder Karte: Schlagzeile, Artikel-URL, Autor-Byline, Veröffentlichungsdatum aus dem datetime-Attribut des <time>-Tags, die Kategorie oder der Tag, unter dem der Artikel eingeordnet ist, und die kurze Zusammenfassung unterhalb der Schlagzeile. Dieser Leitfaden beschränkt sich auf diese Metadaten und extrahiert keine vollständigen Artikeltexte, die urheberrechtlich geschützt sind.

Gibt es stattdessen eine offizielle API?

Ja. TechCrunch läuft auf WordPress, daher veröffentlicht es RSS-Feeds und stellt eine WordPress-REST-API unter /wp-json/wp/v2/posts bereit, die aktuelle Beiträge als strukturiertes JSON mit Titeln, Links, Daten und Zusammenfassungen zurückgibt. Diese Endpunkte bevorzugen, wenn sie den Bedarf abdecken, da sie der leichtere, offizielle Weg sind und kein Rendering erfordern.

Meine Selektoren geben für jede Karte leere Werte zurück. Was hat sich geändert?

Mit großer Wahrscheinlichkeit das Markup von TechCrunch. WordPress-Block-Klassennamen wie wp-block-tc23-post-picker ändern sich ohne Vorankündigung, sodass Selektoren, die letzten Monat funktionierten, brechen können. Eine Live-Seite in den Browser-DevTools erneut untersuchen und die Selektoren aktualisieren. Periodische Selektor-Wartung ist bei jedem produktiven Scraper normal.

Wie vermeidet man Blockierungen beim Scrapen von TechCrunch?

Die Anfragerate pro IP niedrig halten, Ziele variieren statt einen Feed in der Schleife zu durchlaufen, und über rotierende Residential-IPs leiten, damit keine einzelne Adresse ein Rate-Limit auslöst. Die Crawling API verwaltet Rotation und einen vertrauenswürdigen IP-Pool; wer seinen eigenen Stack aufbaut, sollte dort investieren. Die Statuscodes beobachten und zurückrudern, wenn Challenges auftreten.

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.