Crawlbase Web MCP ServerDonnées web en temps réel pour les LLMs

Les grands modèles de langage excellent à raisonner sur du texte et peinent à savoir ce qui s'est passé il y a cinq minutes. Leurs connaissances sont figées au moment de l'entraînement, ils s'exécutent dans des environnements sandboxés sans accès web sortant, et ce ne sont pas des navigateurs. Dès que votre question dépend d'une page en direct, d'un prix actuel ou d'une actualité parue ce matin, le modèle devine, et une supposition confiante sur des données périmées n'est qu'une hallucination bien formulée.

Le serveur Crawlbase Web MCP comble ce fossé. C'est un serveur MCP pour le scraping par IA qui donne à un client LLM un ensemble d'outils pour crawler et lire des pages web en direct, renvoyant des données structurées propres sur lesquelles le modèle peut raisonner dans le même tour. Ce guide explique ce qu'est le Model Context Protocol, ce qu'expose le Crawlbase Web MCP, comment le connecter à un client MCP-compatible, et pourquoi l'accès web en temps réel change ce que vos agents peuvent réellement faire.

Le problème : les LLMs sont déconnectés du web en direct

Chaque modèle à usage général, de Claude aux autres, repose sur un large corpus d'entraînement statique. Cet entraînement permet au modèle de raisonner, de résumer et de prédire, mais il ne peut pas observer. Quelques contraintes le rendent concret :

• Les connaissances sont figées. Tout ce qui a changé après la date limite d'entraînement est invisible jusqu'au prochain réentraînement.
• Le runtime est sandboxé. Les modèles s'exécutent dans des environnements qui restreignent l'accès réseau sortant par conception, ils ne peuvent donc pas simplement aller chercher une page.
• Les modèles ne sont pas des navigateurs. Même avec une URL en main, un modèle brut n'a pas de moteur pour rendre JavaScript, suivre les redirections ou contourner les défenses anti-bot.

Les contournements que les développeurs utilisent sont tous mauvais à leur façon : copier-coller manuellement des résultats crawlés dans le prompt, accepter les hallucinations quand le contexte manque, ou construire des agents qui s'effondrent dès que les données sous-jacentes se mettent à jour. Rien de tout cela ne passe à l'échelle, et tout cela procède de la même cause racine : le modèle n'a pas de connexion en direct au web.

Ce qu'est le Model Context Protocol (MCP)

Le Model Context Protocol est un standard ouvert qui définit une façon cohérente pour les modèles d'IA de communiquer avec des outils et des sources de données externes. Au lieu que chaque intégration soit une solution sur mesure ponctuelle, MCP donne au modèle une interface uniforme : il peut lister les outils qu'un serveur propose, en appeler un avec des arguments et obtenir un résultat structuré dans sa fenêtre de contexte.

Pensez-y comme USB pour l'IA. USB a permis à n'importe quel appareil de se brancher à n'importe quel ordinateur via un port standard unique ; MCP permet à n'importe quel outil ou source de données de se brancher à n'importe quel client MCP-compatible via un protocole standard unique. Un client MCP (Claude Desktop, Cursor, Windsurf et une liste croissante d'autres) parle le protocole ; un serveur MCP expose des capacités à travers lui. Le Crawlbase Web MCP est l'un de ces serveurs, et la capacité qu'il expose est le web en direct.

Ce qu'expose le serveur Crawlbase Web MCP

Le serveur Crawlbase MCP est le tissu conjonctif entre un client LLM et le web en temps réel. Il est construit sur la même infrastructure de crawling qui sert déjà une large base de développeurs, donc un agent l'utilisant bénéficie du rendu JavaScript, de la rotation de proxies côté serveur et de la gestion anti-bot sans savoir que tout cela se passe. Pour le modèle, ce ne sont que quelques outils qui transforment une URL en données.

Les outils exposés par le serveur effectuent la récupération et le nettoyage pour que le modèle reçoive du contenu qu'il peut réellement utiliser :

• crawl récupère une URL et renvoie le HTML de la page, rendu si la page nécessite JavaScript pour se peupler.
• crawl_markdown récupère une URL et renvoie du Markdown propre, débarrassé de la navigation et du contenu générique, qui est le format que les modèles lisent le plus fiablement.
• crawl_screenshot capture une capture d'écran visuelle d'une page pour les cas où la mise en page ou une image importe plus que le texte.

Sous le capot, chacun d'eux effectue le même crawl robuste que la Crawling API réalise : un vrai navigateur rend la page derrière une IP résidentielle de confiance, de sorte que les sites rendus côté client reviennent entièrement peuplés et que la requête est perçue comme un vrai visiteur plutôt qu'un bot signalé. Le modèle ne voit jamais cette machinerie. Il demande une URL et récupère du contenu fini et structuré.

Comment connecter le Crawlbase Web MCP à un client

Connecter le serveur consiste en trois mêmes actions dans n'importe quel client MCP : obtenir vos tokens, déposer un petit bloc JSON dans la configuration du client et redémarrer. Voici le chemin complet.

Étape 1 : Obtenir vos tokens Crawlbase

Créez un compte Crawlbase, qui commence avec jusqu'à 20 000 requêtes gratuites : 1 000 à l'inscription, et davantage à mesure que vous complétez les étapes d'onboarding. Dans le tableau de bord, ouvrez la documentation de votre compte et copiez deux tokens : le token normal pour les pages statiques et le token JavaScript pour les pages qui se rendent côté client. Le serveur MCP utilise les deux, choisissant le bon par requête.

Étape 2 : Ajouter le serveur à la configuration de votre client

Les clients MCP lisent une configuration JSON qui liste les serveurs qu'ils doivent lancer. L'entrée Crawlbase indique au client d'exécuter le serveur via stdio avec npx et lui transmet vos tokens comme variables d'environnement. Le même bloc fonctionne dans Claude Desktop, Cursor et Windsurf ; seul le fichier dans lequel il réside diffère selon le client.

{
  "mcpServers": {
    "crawlbase": {
      "type": "stdio",
      "command": "npx",
      "args": ["@crawlbase/mcp@latest"],
      "env": {
        "CRAWLBASE_TOKEN": "your_token_here",
        "CRAWLBASE_JS_TOKEN": "your_js_token_here"
      }
    }
  }
}

Remplacez your_token_here et your_js_token_here par vos tokens normal et JavaScript réels. L'emplacement de ce bloc dépend du client :

• Claude Desktop : Fichier, puis Paramètres, puis Développeur, puis Modifier la configuration, ce qui ouvre claude_desktop_config.json.
• Cursor : Paramètres Cursor, puis Outils et intégrations, puis Ajouter un MCP personnalisé, ce qui modifie mcp.json.
• Windsurf : Paramètres Windsurf, puis Serveurs MCP, puis Gérer les MCP, puis Afficher la configuration brute, ce qui modifie mcp_config.json.

Étape 3 : Redémarrer et vérifier

Enregistrez la configuration et redémarrez (ou actualisez) le client. Crawlbase devrait maintenant apparaître dans la liste des serveurs MCP connectés du client, avec ses outils disponibles. S'il n'apparaît pas, redémarrez une fois de plus, car certains clients ne prennent en compte les changements de serveur qu'au démarrage propre.

Étape 4 : L'utiliser depuis un prompt

Vous pilotez les outils en langage courant. Le modèle décide quel outil appeler et avec quelle URL. Un premier prompt pour confirmer que le câblage fonctionne ressemble à l'exemple ci-dessous ; le client vous demandera généralement d'approuver l'appel d'outil la première fois, accordez donc la permission quand vous y êtes invité.

Crawl https://www.nytimes.com and return the page as markdown

Derrière cette phrase, le client invoque l'outil crawl_markdown avec l'URL comme argument. Conceptuellement, l'appel que le client effectue ressemble à ceci :

{
  "tool": "crawl_markdown",
  "arguments": {
    "url": "https://www.nytimes.com"
  }
}

Le serveur rend la page, la nettoie et renvoie du Markdown dans le contexte du modèle, et le modèle répond à partir de ce contenu en direct au lieu de sa mémoire. Dans un IDE comme Cursor ou Windsurf, le même flux peut écrire le résultat directement dans un fichier, donc un prompt pour crawler une page et la sauvegarder en Markdown produit un fichier Markdown sur disque avec le contenu en direct.

Pourquoi l'accès web en temps réel est important pour les agents

Un agent capable de lire le web en direct est une catégorie d'outil différente de celui qui ne le peut pas. La différence apparaît dès qu'une tâche dépend de quelque chose que le modèle n'aurait pas pu mémoriser :

• Des recherches réellement actuelles. Le modèle peut récupérer l'article d'aujourd'hui, la page de tarification ou la note de version et raisonner dessus, au lieu d'approximer à partir de données d'entraînement potentiellement vieilles d'un an.
• Des assistants de code conscients du runtime. Un agent IDE peut lire la documentation actuelle d'une version de bibliothèque plutôt que de suggérer une API supprimée depuis deux versions.
• Des agents qui ne se cassent pas lors des mises à jour. Parce que les données sont récupérées fraîches à chaque exécution, un workflow continue de fonctionner quand la page source change, au lieu de servir silencieusement un instantané en cache.
• Une entrée structurée, pas du screen-scraping. Un Markdown propre et du HTML signifient que le modèle consacre son contexte au contenu, pas à l'analyse du bruit de mise en page.

C'est le même changement qui rend un proxy géré plus utile à un agent qu'une liste d'IPs brutes. Si vous voulez le tableau d'ensemble sur la façon dont l'outillage IA consomme le web, ce qu'est un proxy IA et les cas d'usage des proxies IA couvrent la couche d'accès, et comment fonctionne l'extraction de données par IA couvre ce qui arrive aux données une fois arrivées.

Comment le MCP s'intègre avec le reste de Crawlbase

Le Web MCP n'est pas un moteur de scraping séparé ; c'est une porte d'entrée au format MCP vers une infrastructure que vous pouvez aussi atteindre directement. Le même rendu et déblocage que les outils MCP utilisent est disponible via la Crawling API pour les crawls pilotés par code, via le Smart AI Proxy quand vous voulez un point d'accès proxy IA par lequel router des requêtes normales, et via la Crawling API quand vous voulez des champs analysés automatiquement depuis des types de pages courants.

La conclusion pratique : utilisez le Web MCP quand le consommateur est un client LLM et que vous voulez que le modèle récupère des données en direct de façon conversationnelle, et optez pour les produits API ou proxy quand le consommateur est votre propre code. Ils partagent le même backend, donc le comportement est cohérent entre tous.

Foire aux questions

Qu'est-ce que le serveur Crawlbase Web MCP ?

C'est un serveur MCP pour le scraping par IA qui donne à un client LLM des outils pour crawler et lire des pages web en direct. Il expose crawl, crawl_markdown et crawl_screenshot via le Model Context Protocol, pour qu'un modèle puisse récupérer une URL et recevoir du HTML rendu, du Markdown propre ou une capture d'écran directement dans son contexte. Le crawling, le rendu et le déblocage se produisent sur l'infrastructure Crawlbase, donc le modèle ne voit que des données finies.

Qu'est-ce que le Model Context Protocol (MCP) ?

MCP est un standard ouvert qui définit une façon cohérente pour les modèles d'IA de communiquer avec des outils et des sources de données externes. Un client MCP (comme Claude Desktop, Cursor ou Windsurf) se connecte à des serveurs MCP, liste leurs outils, les appelle avec des arguments et récupère des résultats structurés. Il est souvent décrit comme USB pour l'IA car un seul protocole permet à n'importe quel outil compatible de se brancher à n'importe quel client compatible.

Quels clients peuvent se connecter au Crawlbase Web MCP ?

N'importe quel client MCP-compatible. La configuration dans ce guide couvre Claude Desktop, Cursor et Windsurf, qui lisent une configuration JSON qui lance le serveur via stdio. Le même bloc de configuration fonctionne pour eux ; seul le fichier dans lequel il réside diffère selon le client. À mesure que d'autres outils adoptent MCP, le même serveur fonctionne avec eux aussi.

Ai-je besoin d'un token normal ou d'un token JavaScript ?

Vous fournissez les deux dans la configuration. Le serveur utilise le token normal pour les pages statiques et le token JavaScript pour les pages qui se rendent côté client et nécessitent un vrai navigateur pour se peupler. Fournir les deux permet au serveur de choisir le bon par requête, de sorte que les pages rendues côté client reviennent entièrement chargées au lieu d'être une coquille vide.

En quoi le Web MCP diffère-t-il de la Crawling API ?

Ils partagent le même backend ; la différence réside dans qui les appelle. Le Web MCP est pour les clients LLM, permettant à un modèle de récupérer des données en direct de façon conversationnelle via des outils MCP. La Crawling API est pour votre propre code, appelée directement via HTTP. Utilisez le MCP quand un client IA est le consommateur et l'API quand c'est votre application.

Pourquoi les agents IA ont-ils besoin d'un accès web en temps réel ?

Parce que les données d'entraînement d'un modèle sont figées et que son runtime ne peut pas atteindre le web par lui-même, toute tâche dépendant d'informations actuelles (actualités d'aujourd'hui, tarification en direct, documentation la plus récente) n'est qu'une supposition sans outil. L'accès en temps réel permet à l'agent de récupérer du contenu frais et structuré et de raisonner dessus dans le même tour, ce qui maintient les recherches actuelles et empêche les workflows de se casser quand les pages sources changent.

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é.