Comment extraire TechCrunch avec Pythontitres et métadonnées

TechCrunch publie des dizaines d'articles par jour sur les startups, les levées de fonds, les lancements de produits et les personnalités qui font bouger l'industrie technologique. Chaque article porte un ensemble compact de métadonnées publiques qu'un outil de veille tendancielle, un tableau de bord de recherche de marché ou un moniteur de salle de presse veut vraiment : le titre, l'auteur, la date de publication, la catégorie et les tags, l'URL de l'article et un court extrait. Le problème est que TechCrunch tourne sur une pile WordPress durcie qui détecte le trafic automatisé rapidement, de sorte qu'un scraper naïf se voit challengé ou bloqué avant d'avoir collecté quoi que ce soit d'utile.

Ce guide vous montre comment scraper TechCrunch avec Python de façon fiable. Vous construisez un petit scraper fonctionnel qui récupère une page de listing via la Crawling API, analyse chaque carte d'article avec BeautifulSoup et affiche une sortie structurée propre. L'ensemble du tutoriel reste limité aux métadonnées publiques des articles, jamais aux corps complets, et la section juridique vers la fin n'est pas du remplissage. Lisez-la avant de pointer ce scraper vers un volume réel.

Ce que vous allez construire

Un script Python qui prend une URL de listing public TechCrunch, récupère le HTML via la Crawling API et extrait un enregistrement structuré pour chaque article de la page. Nous utiliserons le fil de la page d'accueil de TechCrunch comme exemple fil conducteur et extrairons ces champs de chaque carte :

• Headline le titre de l'article tel qu'il apparaît dans le listing.
• Article URL le lien vers le story individuel.
• Author la byline créditée sur la carte.
• Publish date l'horodatage lisible par machine depuis l'attribut datetime.
• Category and tags la section ou le sujet sous lequel l'article est classé.
• Excerpt le court résumé affiché sous le titre.

Pourquoi une requête simple échoue sur TechCrunch

Vous pouvez pointer Python's requests vers une URL TechCrunch et parfois récupérer du HTML, mais une vraie session de scraping reste rarement aussi facile. TechCrunch se trouve derrière une couche edge qui surveille le trafic à l'allure d'un scraper, et deux choses jouent contre vous. Premièrement, les IPs de datacenter et les patterns de requêtes qui ne ressemblent pas à un vrai navigateur sont soumis à une limite de débit ou reçoivent un challenge après les premières requêtes, et les hits répétés depuis une seule adresse franchissent rapidement ce seuil. Deuxièmement, certaines vues de listing et de fil remplissent leur contenu avec JavaScript, de sorte que le HTML brut que vous récupérez peut ne pas contenir les cartes que vous cherchiez.

Un scraper TechCrunch fiable a donc besoin de deux choses en une seule requête : une IP que la plateforme lit comme un vrai visiteur et, quand la vue est rendue côté client, un navigateur qui exécute réellement les scripts de la page. Vous pouvez assembler cela vous-même avec un pool d'IPs rotatives et un navigateur sans interface graphique, mais les assembler et les maintenir en bonne santé représente l'essentiel du travail. La Crawling API regroupe les deux en un seul appel : vous lui envoyez l'URL, elle récupère la page derrière une IP de confiance rotative, rend optionnellement le JavaScript et vous retourne le HTML finalisé à analyser.

Prérequis

Vous avez besoin de quelques éléments en place avant d'écrire du code. Aucun ne prend longtemps.

Python de base. Vous devez être à l'aise pour écrire et exécuter un script Python et installer des paquets avec pip. Si BeautifulSoup est nouveau pour vous, notre guide d'utilisation de BeautifulSoup en Python couvre les bases d'analyse que ce tutoriel suppose.

Python 3.8 ou version ultérieure. Confirmez votre version avec python --version. Si vous ne l'avez pas, installez-le depuis python.org ou via une distribution comme Anaconda.

Un compte Crawlbase et un token. Inscrivez-vous, ouvrez votre tableau de bord et copiez votre token normal depuis la page de documentation du compte. Traitez le token comme un mot de passe : il authentifie vos requêtes, donc gardez-le hors du contrôle de version.

Configurer le projet

Créez un environnement virtuel pour que les dépendances du projet restent isolées, puis installez les bibliothèques dont le scraper a besoin.

python --version

python -m venv techcrunch_env
source techcrunch_env/bin/activate

pip install crawlbase beautifulsoup4 pandas

Sous Windows, activez l'environnement avec techcrunch_env\Scripts\activate à la place de la ligne source. Trois dépendances font le travail : crawlbase est le client officiel pour la Crawling API, beautifulsoup4 analyse le HTML retourné pour que vous puissiez extraire les champs individuels par sélecteur CSS, et pandas facilite l'écriture des enregistrements en CSV à la fin.

Étape 1 : Récupérer la page de listing

Commencez par obtenir la page. Importez la classe CrawlingAPI, initialisez-la avec votre token et demandez l'URL de listing. Vérifier le statut avant d'analyser garde les échecs apparents plutôt que silencieux.

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")

L'option country ancre la requête à une IP de sortie US, ce qui est important parce que TechCrunch peut servir un contenu différent selon la région. Exécutez le script avec python scraper.py et vous devriez voir de vrais balises d'article dans les 500 premiers caractères, pas une page de blocage ou une coquille vide. Cela confirme que la récupération fonctionne derrière une IP de confiance avant d'écrire un seul sélecteur. Si les cartes reviennent vides, relancez avec un token JS pour rendre la page, comme le décrit l'encadré ci-dessus.

Étape 2 : Analyser les cartes d'articles avec BeautifulSoup

HTML en main, chargez-le dans BeautifulSoup et extrayez chaque article par son sélecteur. TechCrunch présente ses listings sous forme de bloc répété, donc vous sélectionnez tous les conteneurs d'articles en une fois et lisez ensuite les mêmes champs de chacun. Sur le balisage WordPress, chaque article se trouve à l'intérieur d'un conteneur avec la classe wp-block-tc23-post-picker, qui est l'ancre sur laquelle vous itérez. Inspectez la page en direct dans les outils de développement de votre navigateur pour confirmer les noms de classes actuels, puisque ce balisage évolue dans le temps.

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

Deux patterns rendent ceci résilient. L'aide text_of retourne une chaîne vide plutôt que de lever une exception quand un sélecteur manque sa cible, de sorte qu'une carte mal formée ne plante jamais l'exécution. Et lire la date de publication depuis l'attribut datetime de la balise <time> vous donne un horodatage ISO propre plutôt que le texte lisible par l'humain affiché sur la carte, ce qui est bien plus facile à trier et filtrer en aval. Le sélecteur de catégorie cible le petit lien de sujet au-dessus de chaque titre ; une carte sans catégorie retourne une chaîne vide.

Étape 3 : Assembler le script complet

Combinez maintenant la récupération et l'analyseur dans un seul fichier exécutable, pointez-le vers le fil de la page d'accueil et écrivez les enregistrements sur le disque. La fonction main assemble les pièces et sauvegarde un CSV avec pandas pour que la sortie tombe directement dans une feuille de calcul ou un notebook.

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()

C'est le scraper complet. Il récupère le fil de la page d'accueil, analyse chaque carte en un enregistrement avec les six champs publics, affiche les trois premiers en JSON et écrit l'ensemble dans techcrunch_listing.csv. Remplacez le page_url par n'importe quel listing public, comme un fil de catégorie ou de tag, et le même analyseur le gère.

À quoi ressemble le résultat

Exécutez le script complet avec python scraper.py et vous obtenez un enregistrement structuré propre pour chaque article, prêt à être écrit en JSON, CSV ou dans une base de données.

[
  {
    "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."
  }
]

Notez que l'extrait est un court résumé, pas le corps complet de l'article. C'est délibéré. La carte de listing expose un teaser, et les champs de métadonnées qui l'entourent sont exactement les signaux publics que vous voulez pour la veille tendancielle, sans copier le texte éditorial lui-même.

Boucler sur les pages et cadencer les requêtes

Un seul listing est une démonstration ; un vrai job s'exécute sur de nombreuses pages. TechCrunch pagine ses fils avec un pattern d'URL simple, de sorte que la page d'accueil est https://techcrunch.com et les pages suivantes sont https://techcrunch.com/page/2/, https://techcrunch.com/page/3/, et ainsi de suite. La forme reste la même : construisez chaque URL de page, récupérez-la via la Crawling API, analysez-la avec la même fonction et collectez les lignes. Cadencer les requêtes maintient une longue exécution en bonne santé.

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

L'appel time.sleep espace les requêtes pour que vous ne marteliez pas TechCrunch dans une boucle serrée. Parce que chaque page partage la même structure de carte, l'analyseur que vous avez déjà écrit fonctionne sur toutes sans modifications, et vous alimentez la liste combinée dans le même appel pandas to_csv du script complet.

Rester non bloqué

Même avec une IP de confiance qui gère la récupération, TechCrunch surveille le trafic à l'allure d'un scraper. Quelques habitudes maintiennent une exécution en bonne santé, et elles s'appliquent à n'importe quelle cible durcie.

• Cadencez vos requêtes. Marteler des pages de listing dans une boucle serrée est le moyen le plus rapide d'être throttlé. Espacez les requêtes et variez vos cibles plutôt que de crawler un seul fil à pleine vitesse.
• Misez sur la rotation. Un pool d'IPs résidentielles répartit les requêtes sur de nombreuses adresses d'utilisateurs réels pour qu'aucune ne déclenche une limite de débit. La Crawling API gère cela pour vous ; si vous montez votre propre pile, c'est la partie à soigner.
• Lisez les codes de statut. Une exécution qui commence à renvoyer des challenges ou des erreurs vous indique que le débit actuel ou le niveau d'IP n'est plus suffisant. Traitez cela comme un signal pour lever le pied, pas comme du bruit à ignorer.

Pour le guide plus large, voir comment scraper des sites web sans être bloqué et l'analyse approfondie de comment contourner les captchas en scraping web. Si un fil particulier est rendu côté client, notre guide sur le scraping de pages JavaScript avec Python explique pourquoi le rendu est important. Et si vous préférez router votre propre trafic via un pool rotatif plutôt qu'utiliser l'API gérée, le Smart AI Proxy (aussi appelé AI Proxy) vous offre la même rotation d'IP résidentielles comme endpoint proxy drop-in.

Est-il légal de scraper TechCrunch ?

La légalité du scraping de TechCrunch dépend des conditions d'utilisation de TechCrunch, de votre juridiction et de ce que vous faites des données. Les conditions de TechCrunch imposent des limites à l'accès automatisé, et son contenu est une oeuvre éditoriale protégée par le droit d'auteur, de sorte que le tableau juridique est plus restreint ici que sur un site d'annonces publiques. Aucun code présenté dans ce guide ne change cela ; il fait simplement fonctionner la partie technique. Lisez les conditions d'utilisation de TechCrunch et son robots.txt, et traitez les deux comme la frontière de ce que vous collectez.

La ligne qui rend cela défendable est la différence entre métadonnées et articles eux-mêmes. Collecter des métadonnées publiques, le titre, l'auteur, la date de publication, la catégorie et les tags, l'URL de l'article et le court extrait, pour la recherche ou l'analyse tendancielle est un usage bien moins lourd que de copier les corps complets des articles. Ne republiez pas et ne redistribuez pas le texte éditorial que TechCrunch produit ; il s'agit de médias protégés par le droit d'auteur, et le republier tombe directement sous le coup des conditions et de la loi sur le droit d'auteur. Si vous avez besoin des articles sous-jacents à grande échelle, la bonne voie est une licence de contenu ou un accord officiel, pas un scraper plus astucieux.

Il est également utile de savoir que TechCrunch tourne sur WordPress, ce qui signifie qu'il existe une voie officielle plus légère pour une grande partie de ces données. TechCrunch publie des fils RSS et expose une WordPress REST API à /wp-json/wp/v2/posts qui retourne les articles récents sous forme de JSON structuré, incluant les titres, les liens, les dates et les extraits, sans scraper la page rendue. Préférez ces endpoints quand ils couvrent vos besoins, et respectez les limites de débit qu'ils annoncent. Ce guide reste limité aux pages de listing publiques et aux métadonnées ; il ne couvre rien derrière une connexion, les données personnelles ou la redistribution de texte intégral.

Foire aux questions

Pourquoi une requête simple est-elle bloquée sur TechCrunch ?

TechCrunch se trouve derrière une couche edge qui signale le trafic automatisé. Les IPs de datacenter et les patterns de requêtes qui ne ressemblent pas à un vrai navigateur sont soumis à une limite de débit ou reçoivent un challenge après quelques requêtes, de sorte qu'une boucle requests brute cesse rapidement de fonctionner. Faire la récupération via la Crawling API achemine la requête par une IP résidentielle que la plateforme lit comme un vrai visiteur, ce qui est ce qui maintient l'exécution.

Ai-je besoin du token normal ou du token JS pour TechCrunch ?

Généralement le token normal. Les listings TechCrunch sont largement un balisage WordPress rendu côté serveur, de sorte que le HTML statique que retourne le token normal contient déjà les cartes d'articles. Si un fil particulier revient avec des cartes vides, passez au token JS, qui rend la page dans un vrai navigateur avant de retourner le HTML.

Quels champs puis-je extraire d'un listing TechCrunch ?

Les métadonnées publiques de chaque carte : le titre, l'URL de l'article, la byline de l'auteur, la date de publication depuis l'attribut datetime de la balise <time>, la catégorie ou le tag sous lequel l'article est classé, et le court extrait affiché sous le titre. Ce guide reste limité à ces métadonnées et n'extrait pas les corps complets des articles, qui sont protégés par le droit d'auteur.

Existe-t-il une API officielle plutôt que le scraping ?

Oui. TechCrunch tourne sur WordPress, donc il publie des fils RSS et expose une WordPress REST API à /wp-json/wp/v2/posts qui retourne les articles récents sous forme de JSON structuré avec les titres, les liens, les dates et les extraits. Préférez ces endpoints quand ils couvrent vos besoins, car ils sont la voie officielle et plus légère et ne nécessitent aucun rendu.

Mes sélecteurs retournent des valeurs vides pour chaque carte. Qu'est-ce qui a changé ?

Presque certainement le balisage de TechCrunch. Les noms de classes WordPress Block comme wp-block-tc23-post-picker changent sans préavis, donc les sélecteurs qui fonctionnaient le mois dernier peuvent casser. Ré-inspectez un article en direct dans les outils de développement de votre navigateur et mettez à jour les sélecteurs. La maintenance périodique des sélecteurs est normale pour tout scraper en production.

Comment éviter d'être bloqué en scrapant TechCrunch ?

Gardez votre taux de requêtes par IP bas, variez vos cibles plutôt que de boucler sur un seul fil, et routez via des IPs résidentielles rotatives pour qu'aucune adresse unique ne déclenche une limite de débit. La Crawling API gère la rotation et un pool d'IPs de confiance pour vous ; si vous construisez votre propre pile, c'est la partie sur laquelle investir. Surveillez les codes de statut et levez le pied quand vous commencez à voir des challenges.

HR

Hassan Rehan

Ingénieur logiciel · Crawlbase

Ingénieur logiciel chez Crawlbase, il rédige des guides pratiques sur les proxys rotatifs, le scraping et les détails concrets de l'intégration de proxys dans du vrai code.