Construire un outil de moteur de recherche avec le Smart AI Proxyrequête, routage, parsing, répétition

Récupérer une poignée de pages de résultats de recherche est trivial. En récupérer des milliers par heure, chaque heure, sans être bloqué est un problème entièrement différent. Les moteurs de recherche sont calibrés pour les visiteurs humains, donc le trafic automatisé se remarque vite : les requêtes depuis une seule adresse commencent à déclencher des CAPTCHA, des pages vides ou des interdictions pures, et les résultats varient en fonction de l'endroit d'où semble provenir la requête. La difficulté d'un outil de moteur de recherche ne réside jamais dans le parsing. C'est de maintenir l'accès aux pages sources actif à mesure que le volume croît.

Ce guide vous montre comment construire un outil de moteur de recherche qui reste fiable à grande échelle en acheminant chaque requête sortante via le Crawlbase Smart AI Proxy. Vous pointez un client HTTP standard vers un endpoint, et le proxy gère la rotation des adresses IP, le ciblage géographique et l'atténuation anti-bots pour vous. Votre code possède la logique de requête et le produit ; Crawlbase possède la fiabilité au niveau réseau. Nous passerons d'abord en revue les contraintes, puis construirons un outil Python fonctionnel qui interroge un moteur de recherche, parse les résultats et renvoie des enregistrements structurés.

Pourquoi le scraping de résultats de recherche à grande échelle est si difficile

Il est utile d'être précis sur ce qui se casse, car chaque mode d'échec pointe vers l'infrastructure que vous devriez sinon construire et entretenir vous-même.

Blocage et interdiction d'adresses IP

Lorsque de nombreuses requêtes proviennent de la même adresse, elles semblent suspectes. Franchissez un seuil et les réponses basculent vers des erreurs, des pages vides ou des invites de vérification. Une seule instance cloud peut très bien fonctionner lors des tests, puis tomber en panne dès que le vrai trafic arrive, car le volume qui convenait à une démonstration est exactement ce qui fait déclencher les limites.

Restrictions géographiques et résultats localisés

Les résultats de recherche ne sont pas universels. Une requête depuis Londres peut renvoyer des classements différents et des annonces locales différents de la même requête depuis New York ou Berlin. Si votre produit dépend de données spécifiques à une région, vos requêtes doivent sembler provenir de ces régions, ce qui implique de contrôler l'emplacement de sortie de chaque requête.

CAPTCHA et défenses anti-bots

Les plateformes de recherche modernes superposent leurs défenses. Même lorsqu'une requête réussit techniquement avec un 200, la page renvoyée peut être un défi plutôt que les résultats réels. Gérer cela de manière fiable nécessite une infrastructure qui s'adapte au fur et à mesure que les systèmes de détection évoluent, pas un correctif ponctuel.

Limites de débit et throttling

Le trafic à haute fréquence depuis une source identifiable est bridé ou bloqué. Sans distribuer les requêtes sur de nombreuses routes, le débit tombe finalement à zéro peu importe l'efficacité de votre code. Construire tout cela en interne signifie faire tourner des pools de proxies, surveiller les défaillances, faire tourner les adresses et réagir aux changements de détection. Pour la plupart des équipes, c'est une charge opérationnelle, pas une fonctionnalité.

Pourquoi la rotation des proxies est la bonne solution

Le Smart AI Proxy se place entre votre application et le moteur de recherche. Vous le configurez comme un proxy ordinaire, envoyez des requêtes normalement et recevez des réponses comme si vous vous étiez connecté directement. La différence est que chaque requête est acheminée via une infrastructure spécifiquement conçue pour la collecte de données automatisée, de sorte que les modes d'échec ci-dessus cessent d'être votre problème.

Les caractéristiques qui comptent pour un outil de recherche :

• Les requêtes sont distribuées sur un grand pool d'adresses IP plutôt qu'une seule adresse.
• Les modèles de trafic sont ajustés pour éviter les déclencheurs courants qui font bloquer les scrapers.
• Le ciblage géographique peut être appliqué par requête lorsque vous avez besoin de résultats régionaux.
• Aucune bibliothèque client spéciale n'est requise, donc tout langage capable d'HTTP fonctionne.

Le comportement optionnel est contrôlé via un en-tête de requête, CrawlbaseAPI-Parameters. C'est ainsi que vous activez le parsing structuré pour Google, par exemple, sans modifier votre logique de requête. Les détails de connexion dont vous avez besoin sont courts :

• HTTPS (recommandé) : https://smartproxy.crawlbase.com:8013
• HTTP : http://smartproxy.crawlbase.com:8012
• Authentification : votre token Crawlbase comme nom d'utilisateur proxy.

Ce que fait concrètement l'outil

Un outil de moteur de recherche comporte plusieurs parties, mais une seule d'entre elles communique avec un moteur de recherche externe. Le Smart AI Proxy se situe à cette frontière comme couche de collecte de données sortantes, ce qui isole le reste de votre système des blocages. Le flux est court :

1. Un utilisateur soumet une requête.
2. Votre application construit l'URL de recherche correspondante.
3. La requête sort via le Smart AI Proxy.
4. Les résultats reviennent du moteur de recherche.
5. Les données sont normalisées, puis stockées ou affichées.

Comme chaque requête sortante passe par le proxy, monter en charge affecte principalement le coût et la capacité de traitement plutôt que la fiabilité. La partie fragile, maintenir l'accès à la source, est gérée une fois à cette frontière et cesse ensuite d'évoluer à mesure que vous grandissez.

Mettre en place l'environnement

Vous avez besoin de Python 3.8 ou version ultérieure et d'une seule dépendance. Confirmez votre version, créez un environnement virtuel pour que l'installation reste isolée, puis ajoutez requests.

python --version

python -m venv serp_env
source serp_env/bin/activate

pip install requests

Sur Windows, activez l'environnement avec serp_env\Scripts\activate au lieu de la ligne source. Vous avez également besoin de votre token Crawlbase, qui sert aussi de clé d'authentification proxy. Récupérez-le depuis votre tableau de bord après l'inscription et gardez-le hors du contrôle de source en le lisant depuis une variable d'environnement.

export CRAWLBASE_TOKEN=your_crawlbase_token_here

Étape 1 : accepter et normaliser la requête

Les moteurs de recherche attendent des paramètres correctement encodés. La saisie brute d'un utilisateur comme best coffee shops Paris doit devenir une chaîne de requête valide avant de pouvoir être intégrée à une URL. Les espaces, les caractères spéciaux et le texte non ASCII cassent la requête si vous les passez tels quels, il faut donc les encoder d'abord. En Python, c'est quote_plus, qui transforme la chaîne brute en best+coffee+shops+Paris. Centraliser cela à un endroit porte ses fruits plus tard, car chaque moteur de recherche que vous supportez a besoin de la même étape.

Étape 2 : construire l'URL SERP cible

Construisez l'URL de façon programmatique plutôt que de coller des chaînes manuellement au site d'appel. Pour une requête Google basique, seul le paramètre q est requis, mais les systèmes en production finissent généralement par supporter la pagination, les indicateurs de langue, les paramètres de recherche sécurisée, les variantes d'appareils et le ciblage régional. Centraliser la construction de l'URL signifie qu'ajouter l'un de ces éléments ultérieurement est un changement dans une seule fonction, pas une recherche dans la base de code.

Étape 3 : acheminer la requête via le Smart AI Proxy

Les requêtes directes vers les moteurs de recherche échouent rapidement sous charge, donc vous configurez votre client HTTP pour utiliser le Smart AI Proxy comme passerelle sortante. Les éléments sont l'endpoint proxy, l'authentification avec votre token Crawlbase et la configuration proxy standard que votre bibliothèque HTTP supporte déjà. Du point de vue de votre application, cela se comporte comme n'importe quel proxy d'entreprise. La différence est que les requêtes sont acheminées de façon transparente via une infrastructure adaptée aux charges de scraping, elles passent donc là où une requête directe ne passerait pas.

Étape 4 : demander des résultats structurés

Le Smart AI Proxy peut parser le HTML pour vous. Passez autoparse=true dans l'en-tête CrawlbaseAPI-Parameters et la réponse revient en JSON au lieu de balisage brut. Pour Google, ce JSON inclut les résultats organiques, les annonces, le pack local et les questions connexes, ainsi que des champs de statut. Dans la plupart des cas, cela supprime entièrement le parsing HTML manuel, ce qui est une chose fragile de moins à maintenir quand le moteur de recherche ajuste sa mise en page.

Étape 5 : valider la réponse avant de l'utiliser

Le code en production doit confirmer qu'une requête a réussi avant de toucher la charge utile. Les vérifications habituelles sont le code de statut HTTP, l'indicateur de statut proxy, la présence des champs attendus et la logique de retry pour les échecs transitoires. L'exemple ci-dessous fait la version basique avec raise_for_status(), qui transforme une réponse HTTP échouée en exception que vous pouvez attraper plutôt qu'un mauvais parsing silencieux en aval.

Étape 6 : construire le fetcher de bout en bout

Voici un fetcher minimal de SERP Google qui utilise le Smart AI Proxy comme seul chemin vers Google. Il configure le proxy avec votre token, envoie une requête GET vers une URL de recherche Google et passe autoparse=true afin que la réponse soit du JSON structuré. Vous récupérez original_status, cb_status (legacy pc_status), l'url demandée et un corps contenant les résultats parsés. Nous omettons le paramètre de pays pour que l'extrait fonctionne sur le plan standard sans ciblage géographique.

import json
import os
import requests
from urllib.parse import quote_plus
from urllib3.exceptions import InsecureRequestWarning

requests.packages.urllib3.disable_warnings(category=InsecureRequestWarning)

def fetch_google_serp(token, query):
    proxy = f"https://{token}:@smartproxy.crawlbase.com:8013"
    proxies = {"http": proxy, "https": proxy}
    url = f"https://www.google.com/search?q={quote_plus(query)}"
    headers = {"CrawlbaseAPI-Parameters": "autoparse=true"}
    response = requests.get(url, headers=headers, proxies=proxies, verify=False, timeout=30)
    response.raise_for_status()
    return json.loads(response.text)

if __name__ == "__main__":
    token = os.environ.get("CRAWLBASE_TOKEN", "YOUR_CRAWLBASE_TOKEN")
    data = fetch_google_serp(token, "best coffee shops Paris")
    print(f"Returned keys: {list(data.keys())}")

Cette fonction est la colonne vertébrale de collecte de données de tout le système. Elle peut fonctionner derrière un endpoint API, dans une file d'attente de workers ou selon un calendrier, et renvoie la même forme structurée à chaque fois. L'appel quote_plus est la normalisation de l'étape 1, l'URL est la construction de l'étape 2, le dict proxies est le routage de l'étape 3, l'en-tête est le parsing structuré de l'étape 4, et raise_for_status est la validation de l'étape 5. Six étapes, une fonction.

Étape 7 : transformer le JSON en enregistrements structurés

La charge utile autoparse est riche, mais votre produit en a rarement besoin de tout. L'étape suivante consiste à extraire le corps et à le remodeler en les enregistrements allégés que votre code de stockage et de classement attend. La fonction ci-dessous extrait les résultats organiques en une liste prévisible de dictionnaires avec rang, titre, URL et extrait, en se rabattant gracieusement quand un champ est manquant pour qu'un résultat étrange ne casse pas le lot.

def to_records(serp, query):
    body = serp.get("body", {})
    results = body.get("searchResults", [])
    records = []
    for rank, item in enumerate(results, start=1):
        records.append({
            "query": query,
            "rank": rank,
            "title": item.get("title", ""),
            "url": item.get("url", ""),
            "snippet": item.get("description", ""),
        })
    return records

if __name__ == "__main__":
    token = os.environ.get("CRAWLBASE_TOKEN", "YOUR_CRAWLBASE_TOKEN")
    query = "best coffee shops Paris"
    serp = fetch_google_serp(token, query)
    rows = to_records(serp, query)
    print(json.dumps(rows[:3], indent=2))

La sortie est un schéma propre et cohérent que vous pouvez écrire directement dans une base de données, alimenter dans une étape de classement ou renvoyer depuis votre propre API. Normaliser tôt dans une forme comme celle-ci est ce qui vous permet de changer ou d'ajouter des moteurs de recherche ultérieurement sans tout réécrire en aval.

[
  {
    "query": "best coffee shops Paris",
    "rank": 1,
    "title": "The 10 Best Coffee Shops in Paris",
    "url": "https://example.com/paris-coffee",
    "snippet": "Our guide to the best specialty coffee in the city..."
  }
]

Étape 8 : l'intégrer dans votre application

Avec un fetcher et un normaliseur en main, les données alimentent ce que vous construisez : une interface de recherche personnalisée, un outil d'analyse concurrentielle, un tableau de bord de surveillance SEO, un jeu de données pour la recherche de marché, ou des données d'entraînement pour un modèle. La plupart des systèmes normalisent dans un schéma cohérent avant le stockage, exactement ce que l'étape 7 a produit, afin que l'analyse et le classement disposent d'une forme stable. L'essentiel est que le reste de votre application ne traite jamais de proxies, de CAPTCHA ou de changements de mise en page. Il traite des enregistrements.

Faire monter en charge l'outil sans le casser

Faire monter en charge un outil SERP est un problème de coordination sur quatre axes, et la couche proxy rend chacun d'eux gérable.

Concurrence. Faites tourner une file d'attente de jobs avec plusieurs workers émettant tous des requêtes via le même endpoint proxy. La rotation répartit ce trafic sur des routes indépendantes, de sorte que la concurrence augmente le débit au lieu d'augmenter votre taux de blocage. Pour la version approfondie, consultez comment faire tourner des proxies pour scraper les résultats de recherche Google.

Variation géographique et d'appareils. Lorsque vous avez besoin de données régionales, variez les paramètres de localisation entre les requêtes. La même requête peut renvoyer des résultats très différents selon l'endroit d'où elle semble provenir, ce qui est une fonctionnalité à exploiter plutôt qu'un problème à contourner.

Contrôle du débit et des coûts. Même avec une couche proxy, un trafic illimité crée des échecs ou des dépenses inutiles. Un simple throttling côté client règle généralement cela, vous maintenant dans des limites raisonnables sans coordination complexe.

Résilience. Attendez-vous à l'occasional erreur transitoire. Réessayez avec backoff et surveillez les codes de statut pour qu'un accroc temporaire ne se transforme pas en échec plus important. Le manuel anti-blocage plus large se trouve dans comment scraper des sites web sans être bloqué.

Limites à connaître avant de déployer

Cette approche est une valeur par défaut solide, mais ce n'est pas une solution miracle. Gardez quelques points à l'esprit.

L'autoparse couvre les moteurs courants, pas toutes les pages. Le parsing structuré est excellent pour Google et les SERP similaires, mais si vous scrapez une page de résultats de niche ou inhabituelle, vous devrez peut-être parser le HTML vous-même. C'est très bien, il suffit d'acheminer la récupération brute via le même proxy et de parser localement.

Le rendu lourd nécessite un navigateur. Si une cible cache les résultats derrière un rendu côté client ou un défi plus sévère, le HTML brut ne suffira pas. C'est à ce moment-là que vous déplacez cette requête vers la Crawling API pour un rendu en vrai navigateur tout en gardant le reste de votre outil inchangé.

Le coût évolue avec le volume. La fiabilité est constante, mais les requêtes ne sont pas gratuites. Throttlez, mettez en cache les requêtes répétées et ne gardez que les champs dont votre produit a besoin pour ne pas payer à récupérer et stocker des données que vous n'utiliserez jamais. Pour les cas limites spécifiques aux CAPTCHA sur Google, contourner les CAPTCHA lors du scraping de Google va plus loin.

Foire aux questions

Quelle est la façon la plus simple de construire un outil de moteur de recherche qui ne se fait pas bloquer ?

Acheminez chaque requête sortante via un proxy rotatif au lieu de frapper directement les moteurs de recherche. Le Smart AI Proxy vous donne cela comme un endpoint prêt à l'emploi : vous configurez votre client HTTP pour l'utiliser, envoyez des requêtes GET normales, et il distribue le trafic sur de nombreuses adresses IP tout en absorbant les défenses anti-bots. Votre code reste concentré sur la logique de requête et les fonctionnalités produit plutôt que sur la maintenance des proxies.

Dois-je parser le HTML moi-même ?

Généralement pas pour les moteurs de recherche courants. Passez autoparse=true dans l'en-tête CrawlbaseAPI-Parameters et le Smart AI Proxy renvoie du JSON structuré avec les résultats organiques, les annonces, le pack local et les questions connexes déjà décomposés. Vous ne revenez au parsing manuel que pour les pages de résultats inhabituelles où aucun parseur n'existe, et même là vous acheminez la récupération brute via le même proxy.

Pourquoi la vérification SSL est-elle désactivée lors de l'utilisation du Smart AI Proxy ?

Le proxy doit inspecter le trafic pour appliquer sa logique de routage et le traitement des réponses, donc la vérification SSL pour la destination est généralement désactivée. En Python, cela signifie définir verify=False sur la requête. Cela s'applique uniquement au trafic passant par le proxy, pas aux autres connexions de votre application, et l'avertissement que Python affiche peut être réduit au silence comme le montre l'exemple.

Quand dois-je utiliser la Crawling API plutôt que le Smart AI Proxy ?

Utilisez le Smart AI Proxy par défaut pour la récupération SERP à fort volume avec un client HTTP standard. Utilisez la Crawling API lorsqu'une cible rend ses résultats côté client ou les protège derrière des défis plus lourds, car elle rend la page dans un vrai navigateur et renvoie du HTML ou du markdown fini. De nombreux outils utilisent le proxy pour la plupart des requêtes et la Crawling API pour les quelques cibles récalcitrantes.

Comment obtenir des résultats de recherche spécifiques à une région ?

Les résultats de recherche varient selon la localisation, donc pour obtenir des données régionales, vous variez le ciblage géographique par requête. La même requête émise depuis différentes régions renvoie des classements et des annonces locales différents, ce que vous pouvez utiliser délibérément pour des produits localisés. Le ciblage géographique est une capacité premium, donc l'exemple basique ici omet le paramètre de pays pour rester exécutable sur le plan standard.

Puis-je utiliser un autre langage que Python ?

Oui. Le Smart AI Proxy fonctionne avec tout langage capable d'envoyer des requêtes HTTP standard, car c'est un endpoint proxy normal sans bibliothèque client requise. Python est utilisé ici parce qu'il est facile à exécuter localement, mais le même schéma, configurer le proxy, envoyer la requête, parser le JSON, s'applique directement en Node.js, Go, Java, C# et autres.

IK

Ian Kalvin

Ingénieur support technique · Crawlbase

Ingénieur support technique chez Crawlbase, il écrit depuis la première ligne de ce qui casse réellement en production, sur les configurations de scraping et de proxys.

NZ

Neil Zamora

Architecte senior · Crawlbase

Architecte senior chez Crawlbase, axé sur les systèmes derrière le crawling à grande échelle : rotation de proxys, résilience anti-bot et les API qui masquent cette complexité.