Web scraping avec Perplexity AI en PythonRécupérer, puis interpréter

Transformer une page web en données propres et structurées est un travail en deux temps, pas un seul. D'abord, il faut obtenir la page, ce qui semble trivial jusqu'à ce que la cible vous serve un CAPTCHA ou une coquille vide. Ensuite, il faut lire le balisage et en extraire les champs qui vous intéressent, ce qui exige traditionnellement d'écrire des parseurs fragiles spécifiques à chaque site. Ce guide associe deux outils qui gèrent chacun une moitié du travail : la Crawlbase Crawling API collecte la page, et Perplexity AI l'interprète en JSON.

Le résultat est un petit script Python exécutable pour le web scraping Python avec Perplexity AI : récupérez le HTML via la Crawling API, réduisez-le à la partie qui compte, convertissez-le en Markdown pour économiser des tokens, puis transmettez-le à l'API Perplexity avec un prompt qui indique exactement ce qu'il faut extraire. L'important est de bien comprendre la division du travail. Perplexity ne crawle pas le site dans ce flux. Il lit le texte que vous lui donnez. La récupération, le rendu et l'évitement des blocages se produisent tous dans l'étape Crawling API.

Pourquoi utiliser Perplexity AI pour le web scraping

Le scraping Python classique s'appuie sur requests et BeautifulSoup : vous récupérez le HTML, puis écrivez des sélecteurs qui parcourent le DOM jusqu'aux champs souhaités. Cela fonctionne bien sur des pages propres et stables. Cela s'effondre quand le balisage est profondément imbriqué, inconsistant entre les annonces, ou réécrit toutes les quelques semaines, car chaque changement signifie réécrire des sélecteurs.

Un LLM comme Perplexity change la seconde moitié de cette équation. Au lieu de lui indiquer où se trouve le prix dans le DOM, vous lui dites ce que vous voulez ("le titre du produit, le prix et un résumé en une ligne") et il lit le contenu comme une personne le ferait. Il excelle à extraire de la structure d'un texte désordonné et à la retourner en JSON, ce qui est exactement la forme souhaitée pour un pipeline. C'est la même idée que l'extraction de données par IA en général, et les modèles Sonar de Perplexity ajoutent un ancrage web par-dessus.

Ce que Perplexity fait et ne fait pas ici

L'API de Perplexity est compatible OpenAI, vous lui parlez donc avec le même client openai et une URL de base différente. Dans ce scraper, il joue exactement un rôle : lire le texte de la page que nous avons collecté et retourner des champs structurés. Ce n'est pas votre crawler, ce n'est pas lui qui évite les blocages, et ce n'est pas votre proxy. Gardez cette frontière claire et l'architecture reste simple : Crawlbase obtient les octets, Perplexity leur donne du sens.

Configurer votre environnement Python

Vous avez besoin de Python 3.8 ou plus récent. Créez un environnement virtuel pour que les dépendances de ce projet restent isolées, puis activez-le.

python -m venv perplexity_env

# Windows
perplexity_env\Scripts\activate

# macOS / Linux
source perplexity_env/bin/activate

Installez maintenant les quatre bibliothèques utilisées par le script.

pip install crawlbase beautifulsoup4 markdownify openai

• crawlbase : le client pour la Crawling API, qui récupère et rend la page.
• beautifulsoup4 : réduit le HTML à la section pertinente avant de dépenser des tokens dessus.
• markdownify : convertit cette section en Markdown pour que le modèle reçoive du texte propre, pas une soupe de balises.
• openai : le client compatible OpenAI qu'utilise l'API Perplexity.

Vous avez aussi besoin de deux clés. Obtenez un token Crawlbase depuis le tableau de bord après inscription, et une clé API Perplexity depuis les paramètres de votre compte Perplexity. Gardez les deux hors du contrôle de source, dans des variables d'environnement ou un fichier de secrets, et ne les collez jamais dans du code partagé.

Étape 1 : Récupérer la page avec la Crawling API

C'est l'étape de collecte, et c'est là que les blocages sont gérés. Vous envoyez à la Crawling API une URL ; elle achemine la requête via des IPs résidentielles tournantes, rend optionnellement le JavaScript, gère les CAPTCHAs et les défis qui bloqueraient un simple requests.get, et retourne le HTML finalisé. Vous ne touchez jamais vous-même à un pool de proxys ou à un navigateur headless.

Sauvegardez ceci sous crawl.py. Nous utilisons une page de produit Amazon comme exemple de cible.

from crawlbase import CrawlingAPI

api = CrawlingAPI({'token': 'YOUR_CRAWLBASE_JS_TOKEN'})

def crawl(url: str) -> str:
    response = api.get(url, {'ajax_wait': 'true', 'page_wait': 3000})
    if response['status_code'] != 200:
        raise RuntimeError(f'Crawl failed: {response["status_code"]}')
    return response['body'].decode('utf-8')

if __name__ == '__main__':
    url = 'https://www.amazon.com/Art-War-DELUXE-Sun-Tzu/dp/9388369696'
    html = crawl(url)
    with open('output.html', 'w', encoding='utf-8') as f:
        f.write(html)
    print('Saved output.html')

Exécutez-le avec python crawl.py. Vous obtenez un output.html avec le vrai balisage du produit, pas la page bloquée ou vide qu'une requête directe retourne souvent. Les options ajax_wait et page_wait indiquent au moteur d'attendre le contenu asynchrone ; augmentez page_wait si les résultats reviennent insuffisants. C'est tout l'intérêt d'utiliser la Crawling API ici : c'est la couche qui vous procure une page utilisable en premier lieu, ce qui rend également possible l'étape IA.

Étape 2 : Réduire le HTML et le convertir en Markdown

Une page de produit complète représente des centaines de kilo-octets de barres de navigation, scripts et pieds de page. Envoyer tout cela à Perplexity est lent et gaspilleur, puisque la tarification des LLM est par token et la plupart de ces tokens sont du bruit. Deux étapes simples y remédient : utilisez BeautifulSoup pour saisir uniquement la section qui vous intéresse, puis convertissez cette section en Markdown pour que le modèle lise de la prose propre plutôt que des balises.

Sauvegardez ceci sous parse.py.

from bs4 import BeautifulSoup
from markdownify import markdownify as md

def html_to_markdown(html: str) -> str:
    soup = BeautifulSoup(html, 'html.parser')
    element = soup.find(id='centerCol') or soup.body
    if element is None:
        raise ValueError('Could not find content section in HTML')
    return md(str(element))

L'id centerCol est la colonne principale du produit sur cette page Amazon ; pour un site différent, inspectez la page en direct dans les outils de développement de votre navigateur et ciblez le conteneur qui détient les champs souhaités. Le repli or soup.body empêche le script de planter si cet id est absent. Les sélecteurs évoluent dans le temps, traitez donc le conteneur cible comme quelque chose que vous revisiterez, pas comme un contrat permanent.

Étape 3 : Écrire le prompt d'extraction

Le prompt est l'endroit où vous indiquez à Perplexity ce qu'il faut extraire et comment le mettre en forme. Soyez précis sur les champs et demandez uniquement du JSON pour que la réponse soit facile à analyser en aval. Un message système définit le rôle ; le message utilisateur porte les instructions plus le Markdown.

def build_prompt(markdown: str) -> list:
    return [
        {
            'role': 'system',
            'content': 'You extract structured data from product pages. Reply with JSON only, no prose.',
        },
        {
            'role': 'user',
            'content': (
                'Extract these fields from the Markdown:\n'
                '- title\n'
                '- price\n'
                '- rating\n'
                '- one_sentence_summary\n\n'
                f'Markdown:\n{markdown}\n\n'
                'Respond with a single JSON object.'
            ),
        },
    ]

Des noms de champs clairs et une instruction explicite "JSON uniquement" font l'essentiel du travail. Si vous avez besoin d'une forme stricte, nommez chaque clé attendue et le modèle la suivra fidèlement.

Étape 4 : Appeler Perplexity et assembler le scraper

Assemblez maintenant le tout. Le client openai pointe vers https://api.perplexity.ai, vous envoyez le prompt à un modèle Sonar, et vous analysez le JSON retourné. Sauvegardez ceci sous scraper.py.

import json
from openai import OpenAI
from crawl import crawl
from parse import html_to_markdown
from build_prompt import build_prompt

URL = 'https://www.amazon.com/Art-War-DELUXE-Sun-Tzu/dp/9388369696'

client = OpenAI(
    api_key='YOUR_PERPLEXITY_API_KEY',
    base_url='https://api.perplexity.ai',
)

def scrape(url: str) -> dict:
    html = crawl(url)
    markdown = html_to_markdown(html)
    messages = build_prompt(markdown)

    response = client.chat.completions.create(
        model='sonar-pro',
        messages=messages,
    )
    content = response.choices[0].message.content
    return json.loads(content)

if __name__ == '__main__':
    data = scrape(URL)
    print(json.dumps(data, indent=2))

Exécutez-le avec python scraper.py après avoir inséré vos deux clés. Le modèle sonar-pro est le niveau Sonar plus puissant de Perplexity ; sonar est moins coûteux et suffisant pour une extraction simple. Les deux utilisent le format chat-completions compatible OpenAI, donc changer de modèle est une modification d'une seule ligne.

À quoi ressemble le résultat

Le résultat est un objet JSON propre que vous pouvez écrire dans une base de données, un CSV ou l'étape suivante d'un pipeline.

{
  "title": "The Art of War (Deluxe Hardbound Edition)",
  "price": "$15.80",
  "rating": "4.7 out of 5",
  "one_sentence_summary": "An ancient Chinese treatise by Sun Tzu on strategy, planning, and adapting tactics to win conflicts."
}

Notez une particularité à gérer en production : les modèles Sonar de Perplexity sont ancrés sur le web et ajoutent parfois des marqueurs de citation comme [1] au texte, ou enveloppent le JSON dans un bloc de code. Si json.loads lève une exception, retirez un éventuel délimiteur initial et final avant d'analyser, ou demandez plus fermement au modèle de retourner du JSON brut. Une courte étape de nettoyage garde le parseur heureux.

Défis et limites à garder à l'esprit

Associer un LLM à un crawler est puissant, mais non sans compromis. Le coût évolue avec les tokens, donc l'étape de réduction en Markdown compte davantage à mesure que vous montez en volume ; n'envoyez pas des pages entières. La latence est plus élevée qu'avec un parseur manuel, car vous attendez un aller-retour vers un modèle par page, ce qui convient pour des centaines de pages et mérite réflexion pour des millions. Et les LLM peuvent occasionnellement mal étiqueter un champ ou halluciner une valeur, alors validez les champs critiques (convertissez les prix en nombres, vérifiez les clés requises) plutôt que de faire confiance aveuglément au résultat.

Pour les tâches à très haut volume et à schéma fixe où vous connaissez déjà les champs exacts, un parseur déterministe, ou la propre Crawling API de Crawlbase avec ses parseurs prêts à l'emploi, peut être moins coûteux et plus rapide qu'un LLM. L'approche IA justifie son existence quand les pages sont variées, désordonnées ou changent souvent. Si vous souhaitez comparer des fournisseurs d'IA pour ce type de travail, leveraging Gemini AI for web scraping suit le même pattern avec un modèle différent.

Maintenir la couche de collecte débloquée

Tout ce qui précède suppose que l'étape 1 retourne réellement une vraie page. Sur des cibles commerciales difficiles, c'est là que les scrapers échouent, donc quelques habitudes maintiennent la couche de collecte en bonne santé.

• Utilisez le token JS quand la page est rendue côté client. Le token normal retourne la coquille pré-rendu sur ces sites, et il n'y a alors rien que Perplexity puisse lire.
• Appuyez-vous sur la rotation. La Crawling API et le Smart AI Proxy acheminent les requêtes via des IPs résidentielles tournantes pour qu'aucune adresse ne déclenche une limite de débit. Si vous construisez votre propre stack, c'est la partie sur laquelle investir.
• Espacez vos requêtes et lisez les codes d'état. Étalez les requêtes, variez les paramètres, et traitez un taux croissant de défis comme un signal de ralentissement, pas d'accélération.

Pour le guide complet sur ce sujet, consultez how to scrape websites without getting blocked. En résumé : laissez la Crawling API gérer la collecte et l'évitement des blocages, et laissez Perplexity gérer l'interprétation. Gardez ces deux responsabilités séparées et le système est facile à raisonner.

Foire aux questions

Perplexity AI scrape-t-il lui-même le site web ?

Non, pas dans ce flux de travail. Perplexity lit le texte que vous lui donnez et retourne des données structurées ; il ne récupère pas la page cible, ne rend pas JavaScript et ne gère pas les blocages. La Crawling API effectue toute la collecte, y compris la rotation des IPs résidentielles et le rendu, puis vous transmettez son HTML ou Markdown à Perplexity pour interprétation. Garder cette frontière claire est la clé pour comprendre l'architecture.

Pourquoi convertir le HTML en Markdown avant de l'envoyer à Perplexity ?

Deux raisons : le coût et la qualité. Une page HTML complète est principalement de la navigation, des scripts et du style qui gaspillent des tokens, et la tarification des LLM est par token. Réduire à la section pertinente avec BeautifulSoup et convertir en Markdown donne au modèle de la prose propre à lire, ce qui réduit à la fois le coût et améliore la précision de l'extraction car il y a moins de bruit à traverser.

Quel modèle Perplexity utiliser, sonar ou sonar-pro ?

Commencez avec sonar pour des pages simples et bien structurées ; il est moins coûteux et généralement assez précis. Passez à sonar-pro quand la qualité d'extraction est importante ou quand le contenu est dense et varié. Les deux utilisent le format chat-completions compatible OpenAI, donc changer est une modification d'une seule ligne dans l'argument model.

Ai-je besoin du token Crawlbase normal ou du token JS ?

Cela dépend de la cible. Utilisez le token normal pour les pages rendues côté serveur où le HTML contient déjà les données. Utilisez le token JS quand le site construit son contenu côté client, ce qui est le cas de la plupart des boutiques et applications modernes, car le token normal retournerait la coquille pré-rendu vide et laisserait Perplexity sans rien à extraire.

L'analyse JSON échoue constamment. Qu'est-ce qui ne va pas ?

Les modèles Sonar de Perplexity sont ancrés sur le web et peuvent envelopper la sortie dans un bloc de code ou ajouter des marqueurs de citation comme [1], ce qui casse json.loads. Retirez les délimiteurs initiaux et finals avant d'analyser, resserrez le prompt pour exiger du JSON brut sans texte supplémentaire, et validez l'objet analysé avant de l'utiliser. Une petite étape de nettoyage rend le pipeline fiable.

Puis-je utiliser Perplexity AI et Crawlbase ensemble à grande échelle ?

Oui, et ils se complètent bien. Crawlbase gère la collecte et l'évitement des blocages pour que vos requêtes continuent d'aboutir, et Perplexity transforme chaque page en données structurées. Pour un très grand volume avec un schéma fixe, évaluez le coût LLM par page par rapport à un parseur déterministe ou à la Scraper API ; l'approche IA excelle quand les pages sont désordonnées ou changent souvent, tandis que les tâches à schéma fixe peuvent être moins coûteuses sans LLM.

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.