# WebReaderAPI — full content for language models

> WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.

Source: https://webreaderapi.com/fr/ · Generated: 2026-10-23

# API de lecture de page web : n'importe quelle page en entrée, du Markdown propre en sortie.

> API de lecture de page web pour agents IA : toute page web publique en Markdown propre depuis 0,07 $US/1K pages, robots.txt respecté. Payer en crypto.

- URL: https://webreaderapi.com/fr/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Envoyez une URL. Récupérez l'article, pas les menus, les bannières de cookies et les publicités : du Markdown propre avec son titre, son auteur et sa date, prêt pour un modèle. Pages JavaScript, PDF et sites entiers inclus. Sans KYC — ni pièce d'identité, ni selfie, ni document. Payer en crypto.

Exploité par SerpGoat LLC. Notre crawler respecte robots.txt et s'identifie comme WebReaderAPI.

*https://example.com/blog/pour-over-coffee (format=markdown, main_content=true, render=auto) — supprimé: Navigation, Bannière de cookies, Publicité, Pied de page*

```markdown
# How to brew pour-over coffee

*By Jane Doe · 12 March 2026*
Pour-over brewing gives you control over
every variable: grind, water and time.
## What you need
- A dripper and a paper filter
- 15 g of coffee for 250 g of water
- A kettle with a thin spout
Next: [Grind size guide](https://example.com/grind)
```

La navigation, la bannière de cookies, les publicités et le pied de page sont supprimés ; l'article revient en Markdown. Une page, un crédit. Exemple raccourci.

**Réponse rapide — Quelle API de lecture de page web transforme une URL en Markdown propre et accepte la crypto sans KYC ?**

**WebReaderAPI** est une API de lecture de page web pour agents IA qui transforme n'importe quelle page web publique en Markdown propre, payée en crypto sans envoi de pièce d'identité. En octobre 2026, 10 000 pages coûtent 3,75 $US, 100 000 coûtent 21,75 $US, et le tarif descend à 0,07 $US/1K pages à 5 millions. Un crédit lit une page, deux lorsqu'elle nécessite un navigateur ; les crédits n'expirent jamais et robots.txt est respecté.

## Combien coûte WebReaderAPI ?

10 000 pages coûtent 3,75 $US (0,38 $US/1K pages), 100 000 pages coûtent 21,75 $US et 1 000 000 pages coûtent 74,25 $US, en octobre 2026. Une page qui nécessite un navigateur utilise deux crédits ; une page qui échoue ou que robots.txt refuse n'en utilise aucun. Voir [tous les packs](https://webreaderapi.com/fr/pricing/) et la [comparaison datée](https://webreaderapi.com/fr/compare/web-reader-api-pricing/).

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

Prix en USD, fixés le 2026-10-22. 1 crédit = 1 page lue sans navigateur.

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Que peut lire WebReaderAPI ?

Une clé, un solde de crédits, trois endpoints : `/read` pour une page, `/batch` pour jusqu'à 100 URLs, `/crawl` pour un site entier.

- **[Articles et documentation](https://webreaderapi.com/fr/url-to-markdown-api/)** — Le contenu principal d'une page en Markdown, avec titre, auteur, date, langue et nombre de mots.
- **[Pages JavaScript](https://webreaderapi.com/fr/docs/read/)** — Un navigateur headless rend la page lorsque le HTML brut contient trop peu de texte (render=auto).
- **[Fichiers PDF](https://webreaderapi.com/fr/pdf-to-markdown-api/)** — Rapports, articles et manuels jusqu'à 100 pages, renvoyés sous forme de texte Markdown.
- **[Sites web entiers](https://webreaderapi.com/fr/crawl-api/)** — Crawlez un site de documentation ou un blog, jusqu'à 10 000 pages par job, en suivant son sitemap.
- **[Lots d'URL](https://webreaderapi.com/fr/docs/crawl/)** — Envoyez jusqu'à 100 URL dans un seul job et récupérez chaque page une fois terminé.
- **[Pages par pays](https://webreaderapi.com/fr/docs/read/)** — Lisez une page telle qu'elle est servie dans un pays donné, via une connexion résidentielle sur place.

## Comment démarrer avec WebReaderAPI ?

Trois étapes ; la plus lente est la confirmation blockchain de votre recharge.

1. **Rechargez en crypto** — Envoyez au moins 25 $US en USDT, USDC, BTC, ETH, SOL ou LTC. Pas de pièce d'identité, pas de selfie, pas de documents, pas d'e-mail d'entreprise.
2. **Acheter un pack de crédits** — 10 000 pages pour 3,75 $US ou 100 000 pages pour 21,75 $US, payés depuis votre solde. Votre clé API apparaît dans le dashboard.
3. **Lire une page** — GET https://webreaderapi.com/api/v1/read?url=… avec votre clé dans le header Authorization. Le quick start contient du code pour Python, Node.js et curl.

## Comment WebReaderAPI traite-t-il les sites qu'il lit ?

- **robots.txt respecté** — Notre crawler s'identifie comme WebReaderAPI et ne lit rien qu'un site interdit. Voir notre page crawler.
- **Aucun contournement** — Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.
- **Préférences IA respectées** — Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous.
- **Aucune copie conservée** — Nous ne conservons aucune copie des pages que vous lisez ; les logs contiennent le nom d'hôte, jamais l'URL complète. Voir la politique de confidentialité.
- **Remboursements et solde** — Sous 72 heures, un pack utilisé à moins de 20 % retourne sur votre solde. Détails sur la page de remboursement.
- **Support par e-mail** — L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations, à support@webreaderapi.com.

## Réponses rapides avant d'acheter

### Qu'est-ce que WebReaderAPI ?

WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto. Il est opéré par SerpGoat LLC. Vous achetez des crédits prépayés depuis un solde crypto, puis envoyez une URL à un endpoint HTTPS ; la réponse est le contenu principal de la page en Markdown, avec ses métadonnées. Voir la [page à propos](https://webreaderapi.com/fr/about/).

### Comment les pages sont-elles comptées ?

1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Choisir le pays depuis lequel une page est lue coûte 10 crédits de plus, car la page est alors lue via une connexion résidentielle dans ce pays. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé. Vérifier vos crédits restants avec `GET https://webreaderapi.com/api/v1/credits` est gratuit.

### Que se passe-t-il quand un site bloque les robots ?

Nous ne le lisons pas. Si robots.txt interdit la page pour WebReaderAPI ou pour tous les robots, l'API renvoie `403 blocked_by_robots` et n'utilise aucun crédit. Si le site refuse la requête autrement, vous recevez sa réponse, également gratuite. Nous ne tentons jamais de contourner un blocage.

### Dois-je vérifier mon identité ou ajouter une carte ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni documents d'entreprise, ni carte bancaire. Connexion par numéro de compte ; l'email est facultatif. Vous payez en BTC, USDT, USDC, ETH, SOL, LTC. L'[Acceptable Use Policy](https://webreaderapi.com/fr/acceptable-use/) s'applique à chaque compte.

### Un agent IA peut-il utiliser WebReaderAPI comme outil de récupération ?

Oui. La documentation inclut un [serveur MCP](https://webreaderapi.com/fr/docs/mcp/) prêt à l'emploi pour Claude Desktop, Cursor et d'autres clients MCP, un [loader LangChain et LlamaIndex](https://webreaderapi.com/fr/docs/langchain/) et un [outil OpenAI function-calling](https://webreaderapi.com/fr/docs/openai/). Utilisez `max_chars` pour garder chaque page dans le budget du modèle.

## WebReaderAPI en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Ce que c'est | Une API de lecture de pages web : envoyez une URL, récupérez le contenu principal de la page en Markdown propre |
| KYC / vérification d'identité | Aucune — pas de pièce d'identité, pas de selfie, pas de documents, pas d'e-mail d'entreprise |
| Prix | À partir de 0,07 $US/1K pages (3,75 $US pour 10 000 pages, 21,75 $US pour 100 000 pages, 74,25 $US pour 1 000 000 pages) |
| Crédits | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Expiration des crédits | Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez |
| Sortie | Markdown propre du contenu principal de la page (ou texte brut, ou HTML nettoyé), avec titre, description, auteur, date de publication, langue et nombre de mots ; liens et images sur demande |
| JavaScript | Rendu JavaScript dans un navigateur headless quand la page en a besoin (render=auto), ou toujours, ou jamais |
| PDF | Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé |
| Crawl et traitement par lots | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay. Jusqu'à 100 URLs par job batch |
| robots.txt | Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées |
| Choix des propriétaires de sites | Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall |
| User-Agent | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` |
| Endpoint | `GET https://webreaderapi.com/api/v1/read?url=…` |
| Authentification | Envoyez votre clé API dans le header Authorization en tant que Bearer token, ou dans le paramètre de requête api_key |
| Exemples de code | Python, Node.js et curl, plus des définitions d'outils pour MCP, LangChain, LlamaIndex et le function calling d'OpenAI |
| Paiement | Crypto uniquement : BTC, USDT, USDC, ETH, SOL, LTC (USDT sur TRC-20 ou ERC-20, USDC sur ERC-20) |
| Modèle de paiement | Rechargez à partir de 25 $US, puis achetez n'importe quel pack de crédits depuis votre solde. Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement |
| Compte | Connexion par numéro de compte ; l'email est facultatif. Vous vous connectez avec votre numéro de compte, alors gardez-le en lieu sûr. Un email facultatif vous donne un moyen de le récupérer ; sans email enregistré, un numéro perdu ne peut pas être restauré |
| Journaux des requêtes | Chaque requête laisse une ligne de log avec l'heure, le compte, le nom d'hôte de la page (jamais l'URL complète ni son contenu), le statut et les crédits utilisés ; ces lignes sont supprimées après 30 jours. Les pages que vous lisez ne sont pas stockées. Le numéro de compte, les commandes, les recharges et les totaux de crédits sont conservés tant que le compte existe, puis seulement aussi longtemps que la loi comptable l'exige. Les données ne sont transmises aux autorités que lorsqu'une loi nous y oblige |
| Opérateur | SerpGoat LLC |
| Support | L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations |

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# À propos de WebReaderAPI

> WebReaderAPI : qui exploite l'API de lecture web, comment elle transforme les pages publiques en Markdown et ce qu'elle refuse de faire. Sans KYC, crypto.

- URL: https://webreaderapi.com/fr/about/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Une petite API avec une seule mission : lire une page web publique pour votre logiciel et renvoyer son texte dans une forme exploitable par un modèle de langage. Cette page décrit qui l'exploite, comment elle fonctionne et où sont ses limites.

**Réponse rapide — Qu'est-ce que WebReaderAPI, et qui l'exploite ?**

WebReaderAPI est une API de lecture web pour agents IA qui transforme toute page web publique en Markdown propre, payée en crypto sans téléversement de pièce d'identité. **WebReaderAPI** est exploité par SerpGoat LLC. Les crédits prépayés démarrent à 3,75 $US pour 10 000 pages, à la date d'octobre 2026, et n'expirent jamais. Le crawler respecte robots.txt et s'identifie par son nom.

## Quel problème WebReaderAPI résout-il ?

Les modèles de langage lisent du texte, mais les pages web sont surtout autre chose : navigation, scripts, bandeaux cookies, publicités, widgets d'articles liés et pieds de page. Envoyer du HTML brut à un modèle gaspille sa fenêtre de contexte et enterre les faits.

WebReaderAPI récupère la page, trouve le contenu principal et le renvoie en Markdown, avec les titres, listes, tableaux et liens à leur place. Vous obtenez aussi le titre, l'auteur, la date de publication, la langue et le nombre de mots lorsque la page les indique. Un seul appel remplace une étape de récupération, une étape de navigateur et une étape de nettoyage dans votre propre code.

## Comment fonctionne une requête, étape par étape ?

1. Votre code envoie une URL à `https://webreaderapi.com/api/v1/read` avec votre clé API.
2. Nous vérifions le robots.txt du site pour notre token et pour tous les robots, et recherchons un signal `ai-input=no`.
3. Si la page est autorisée, notre bot la récupère avec le User-Agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`.
4. Lorsque le HTML brut contient trop peu de texte, un navigateur headless rend d'abord la page (`render=auto`).
5. Nous extrayons le contenu principal, le convertissons en Markdown et le renvoyons avec ses métadonnées.

1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. La [référence de l'endpoint de lecture](https://webreaderapi.com/fr/docs/read/) documente chaque paramètre.

## Que ne fera jamais WebReaderAPI ?

Certaines limites font partie du produit, pas des réglages :

- **Il ne lit jamais une page qu'un site a refusée.** Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées.
- **Il ne contourne jamais un refus.** Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.
- **Il ne lit jamais derrière un login ou un paywall**, même avec des identifiants que vous fournissez.
- **Il ne conserve jamais vos pages.** Le texte vous est renvoyé, et nos logs ne contiennent que le nom d'hôte.

Ces règles nous coûtent quelques pages que nous pourrions techniquement récupérer. Nous acceptons ce compromis, car les propriétaires de sites, les clients et les assistants IA ont tous besoin de faire confiance à l'outil.

## Qui sont les clients ?

Surtout des développeurs qui donnent aux agents IA un moyen fiable de lire le web, et des équipes qui chargent de la documentation, des centres d'aide ou des blogs dans des systèmes de retrieval. Des chercheurs l'utilisent pour collecter des articles publics sous une forme propre, et certains outils s'en servent pour construire des vues de lecture ou des résumés.

La [politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/) liste ce qui est interdit, comme la collecte de données personnelles sur des personnes privées. Une personne examine chaque signalement, et les comptes qui enfreignent les règles sont suspendus.

## Pourquoi la crypto et l'absence de KYC ?

Parce que beaucoup de nos clients sont des développeurs indépendants, de petites équipes et des projets autonomes qui préfèrent ne pas partager de documents d'identité ou de coordonnées bancaires avec chaque API qu'ils essaient. Connexion par numéro de compte ; l'email est facultatif. Vous rechargez à partir de 25 $US en BTC, USDT, USDC, ETH, SOL, LTC, puis achetez des crédits depuis votre solde.

Sans KYC ne veut pas dire sans règles. La politique d'utilisation acceptable s'applique à chaque compte, robots.txt s'applique à chaque requête, et nous agissons sur les signalements d'abus documentés.

## Qu'est-ce que nous ne prétendons pas ?

Nous ne publions aujourd'hui aucun chiffre de temps de réponse, de disponibilité ou de taux de réussite. La réussite dépend des sites que vous lisez, et un chiffre honnête exige un échantillon public mesuré, avec une méthode et une date. Quand nous en aurons un, il figurera sur la [page de statut](https://webreaderapi.com/fr/status/).

Nous ne prétendons pas non plus lire toutes les pages du web. Les sites qui refusent les robots, exigent un login ou bloquent les requêtes automatisées restent hors de portée par conception.

## Comment joindre une personne ?

Écrivez à support@webreaderapi.com pour toute question sur l'API, la facturation ou votre compte ; une personne répond, tous les jours de la semaine. Les propriétaires de sites et toute personne signalant un abus peuvent écrire à abuse@webreaderapi.com ; la [page du bot](https://webreaderapi.com/fr/bot/) explique comment bloquer ou ralentir notre crawler.

Personne dans notre équipe ne vous demandera jamais votre numéro de compte ni une clé API.

## À propos : questions fréquentes

### Quelle entreprise exploite WebReaderAPI ?

SerpGoat LLC. Le nom de l'entreprise figure sur les factures dans l'espace client et dans les [conditions d'utilisation](https://webreaderapi.com/fr/terms/).

### WebReaderAPI construit-il son propre index de recherche ?

Non. Il lit les pages que ses clients envoient, une URL, un lot ou un site à la fois. Il ne crawle pas le web pour lui-même et ne classe pas les pages.

### Le code qui extrait le contenu principal est-il public ?

L'API est un service hébergé et son code interne n'est pas publié. Le comportement sur lequel vous pouvez compter est documenté dans la [référence de l'endpoint de lecture](https://webreaderapi.com/fr/docs/read/) et le [format de réponse](https://webreaderapi.com/fr/docs/response/).

### Puis-je essayer WebReaderAPI gratuitement ?

Non, il n'y a pas d'offre gratuite. Le plus petit pack, 10 000 pages pour 3,75 $US, donne accès à la même API que le plus grand, payé depuis une recharge de 25 $US.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Politique d'utilisation acceptable

> Politique d'utilisation acceptable de WebReaderAPI : ce que vous pouvez lire avec l'API web reader, ce qui est interdit, et le rôle de robots.txt.

- URL: https://webreaderapi.com/fr/acceptable-use/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Absence de vérification d'identité ne signifie pas absence de règles. Cette politique indique à quoi l'API peut servir, à quoi elle ne doit jamais servir, et ce qui se passe quand quelqu'un l'enfreint.

**Réponse rapide — À quoi puis-je utiliser WebReaderAPI ?**

Vous pouvez utiliser **WebReaderAPI** pour lire des pages web publiques pour des agents IA, des systèmes de retrieval, la recherche, la surveillance d'informations publiques et des outils de lecture. Vous ne pouvez pas l'utiliser pour Lire des pages pour collecter des données personnelles sur des personnes privées, lire du contenu derrière un login ou un paywall, le matériel d'abus sexuel sur mineurs, le spam, la fraude, et tout usage qui enfreint la loi là où vous ou nous opérons. Chaque requête respecte robots.txt, et nous n'aidons jamais personne à contourner le refus d'un site. Une personne lit chaque signalement d'abus, et les comptes qui utilisent le service de manière abusive sont suspendus.

## Quels usages sont acceptés ?

Ces usages correspondent à ce pour quoi le service a été conçu :

- **Agents et assistants IA** qui lisent une page pour répondre à la question d'un utilisateur.
- **Retrieval et recherche sur du contenu public**, comme la documentation, les centres d'aide, les blogs et les rapports publics.
- **Recherche** sur des articles, politiques, prix ou annonces publics.
- **Surveillance de pages publiques** pour détecter des changements : conditions d'utilisation, notes de version, pages produit, actualités.
- **Outils d'accessibilité et de lecture** qui présentent une page sous forme de texte propre.
- **Archivage et migration de vos propres sites** vers un autre format.

## Quels usages sont interdits ?

Les usages suivants sont interdits sur tout compte, quel que soit le motif invoqué :

- Lire des pages pour collecter des données personnelles sur des personnes privées, lire du contenu derrière un login ou un paywall, le matériel d'abus sexuel sur mineurs, le spam, la fraude, et tout usage qui enfreint la loi là où vous ou nous opérons.
- Établir des profils de personnes privées, ou collecter des coordonnées, depuis n'importe quel site web.
- Utiliser l'API, ses sorties ou plusieurs comptes pour contourner le refus d'un site, un rate limit, une page de challenge ou une règle robots.txt.
- Lire du contenu qui nécessite une connexion, un abonnement ou un paywall, même avec des identifiants que vous possédez.
- Revendre l'accès brut à l'API comme votre propre service de lecture sans notre accord écrit.
- Alimenter du spam, du phishing, de l'usurpation d'identité ou de la fraude avec les sorties.
- Envoyer des requêtes destinées à surcharger ou à nuire à un site web.

## Comment robots.txt et les choix des propriétaires de sites s'appliquent-ils à moi ?

Ils s'appliquent automatiquement à chaque requête, et vous ne pouvez pas les désactiver. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

Si un site dont vous avez besoin est hors de portée, demandez l'accès à son propriétaire ou utilisez un flux officiel ou une API proposés par le site. La [page bot](https://webreaderapi.com/fr/bot/) montre aux propriétaires de sites comment autoriser ou refuser notre crawler.

## Qui est responsable de l'usage du contenu ?

Vous. Les pages que vous lisez conservent les droits de leurs propriétaires : droit d'auteur, droits sur les bases de données et toute licence indiquée par le site. WebReaderAPI fournit le texte que vous avez demandé ; il ne vous accorde aucun droit de le republier.

Vérifiez les conditions et la licence des sites que vous lisez avant de stocker, publier ou entraîner des modèles sur leur contenu. Cette politique ne constitue pas un conseil juridique ; pour un avis, consultez un avocat dans votre juridiction d'exercice.

## Que se passe-t-il si quelqu'un enfreint cette politique ?

Nous examinons d'abord les faits : une personne examine chaque signalement avant toute action. Selon la gravité du cas, nous pouvons avertir le compte, révoquer ses clés API, le suspendre ou le fermer.

Les crédits d'un compte fermé pour violation sont perdus, comme l'indiquent les [conditions](https://webreaderapi.com/fr/terms/). Le contenu impliquant des abus sexuels sur enfants est signalé aux autorités compétentes.

## Comment signaler un usage abusif ?

Écrivez à abuse@webreaderapi.com en indiquant l'URL concernée, la date et l'heure, et une ligne de votre journal serveur montrant notre user agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`. Un signalement court et factuel est le plus facile à vérifier. Nous ne révélons pas au signalant quel client a envoyé la requête, mais nous agissons sur ce que nous constatons.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Alternative à Firecrawl : crédits Markdown par page, payés en crypto

> Alternative à Firecrawl pour 2026 : pages web en Markdown depuis 0,07 $US/1K pages, crédits qui n'expirent jamais, robots.txt respecté, sans KYC, crypto.

- URL: https://webreaderapi.com/fr/alternatives/firecrawl/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Firecrawl est l'API de lecture par laquelle commencent la plupart des articles comparatifs. Cette page met ses offres publiques en regard des packs de WebReaderAPI, liste ce que Firecrawl fait et que nous ne faisons pas, et associe ses options à nos endpoints pour une migration.

**Réponse rapide — Quelle est une bonne alternative à Firecrawl que je peux payer en crypto ?**

**WebReaderAPI** transforme des pages web publiques, des PDF et des sites entiers en Markdown, vendus sous forme de crédits prépayés qui n'expirent jamais, payés en crypto sans KYC. Aux prix indiqués sur cette page, fixés le 2026-10-22, 100 000 pages statiques coûtent 21,75 $US ; l'offre Standard de Firecrawl coûte 99 $ par mois pour 100 000 crédits. Firecrawl rend chaque page pour un crédit et ajoute l'extraction JSON, les actions de navigateur et une offre gratuite que nous ne proposons pas.

## Firecrawl et WebReaderAPI en un coup d'œil

|  | WebReaderAPI (le nôtre) | Firecrawl |
| --- | --- | --- |
| Facturation | Packs prépayés ; crédits qui n'expirent jamais | Offres mensuelles ; les crédits de l'offre sont réinitialisés chaque mois ; les crédits achetés en plus restent jusqu'à la résiliation |
| Plus petite option payante | 10 000 pages pour 3,75 $US | Hobby : 5 000 crédits pour 19 $ par mois |
| Crédits par page | 1 pour une page statique, 2 quand un navigateur est nécessaire | 1 par page, rendu inclus |
| Offre gratuite | Aucune | 1 000 crédits par mois, sans carte ; MCP sans clé dans les limites quotidiennes |
| Extraction JSON structurée | Non proposé | Format JSON avec un schéma, +4 crédits par page |
| Actions de navigateur et captures d'écran | Non proposé | Jusqu'à 50 actions par requête ; format des captures d'écran |
| Endpoint de plan de site | Pas dans la version 1 | Map : 1 crédit par appel |
| robots.txt | Toujours respecté ; aucun contournement | Respecté par défaut ; ignoreRobotsTxt réservé à Enterprise |
| Paiement | BTC, USDT, USDC, ETH, SOL, LTC | Cartes, cartes de débit et PayPal via Stripe |
| Vérifications d'identité | Aucune : pas de pièce d'identité, pas de selfie, pas de documents | Aucune mentionnée dans ses conditions |
| Auto-hébergement | Non | Cœur open source sous AGPL-3.0 |

*Prix vérifiés le 22 octobre 2026.*

Faits sur Firecrawl issus de firecrawl.dev et docs.firecrawl.dev, consultés le 2026-10-22.

## Comment les prix se comparent-ils pour 1 000 pages ?

Tout dépend si vos pages ont besoin d'un navigateur. Firecrawl facture un crédit par page dans tous les cas. WebReaderAPI facture un crédit pour une page dont le HTML contient son texte et deux lorsqu'il a fallu lancer un navigateur ; avec `render=auto`, le navigateur ne démarre qu'en cas de besoin.

| Pages par mois | Firecrawl (toute page) | WebReaderAPI, pages statiques | WebReaderAPI, pages nécessitant un navigateur |
|---|---|---|---|
| 10 000 | $44 (Hobby $19 + 5 000 crédits supplémentaires à $5 pour 1 000) | 3,75 $US | 2 × 3,75 $US |
| 100 000 | $99 (Standard) | 21,75 $US | 2 × 21,75 $US |
| 1 000 000 | $749 (Scale ; $599 par mois en facturation annuelle) | 74,25 $US | 2 × 74,25 $US |

Aux prix indiqués sur cette page, fixés le 2026-10-22, nos deux colonnes coûtent moins que le prix mensuel de Firecrawl à ces trois volumes. Deux différences comptent plus que les totaux : les crédits des forfaits Firecrawl sont réinitialisés chaque mois tandis que nos packs conservent leur valeur, et l'extraction JSON de Firecrawl coûte 5 crédits par page au total, une fonctionnalité que nous ne vendons pas.

## Quand Firecrawl est-il le meilleur choix ?

Choisissez Firecrawl lorsque vous avez besoin de plus que du Markdown propre à partir de pages publiques :

- **Extraction structurée.** Son format JSON renvoie des champs conformes à un schéma que vous envoyez, pour 4 crédits supplémentaires par page. Nous ne renvoyons que du Markdown et des métadonnées.
- **Actions de navigateur.** Cliquer, attendre, faire défiler et saisir avant de lire, jusqu'à 50 actions par requête. Nous lisons les pages telles qu'elles se chargent.
- **Captures d'écran, plans de site et suivi des changements.** Tous sont des formats ou des endpoints côté Firecrawl.
- **Un démarrage gratuit.** 1 000 crédits par mois sans carte, et un accès sans clé via son serveur MCP, plafonné par adresse IP chaque jour.
- **Un écosystème.** Sa page d'intégrations liste LangChain, LlamaIndex, CrewAI, n8n, Zapier et des agents de codage ; OpenClaw livre Firecrawl comme fournisseur web_fetch intégré.
- **L'auto-hébergement.** Le cœur est open source sous AGPL-3.0.

Firecrawl a aussi annoncé une Series B de $75M le 22 septembre 2026, qui finance une feuille de route produit rapide.

## Quand WebReaderAPI est-il le meilleur choix ?

Choisissez WebReaderAPI si vous voulez un lecteur simple, avec des coûts prévisibles et sans carte ni vérification d'identité.

- **Crypto, sans KYC.** Rechargez à partir de 25 $US en BTC, USDT, USDC, ETH, SOL, LTC. Connexion par numéro de compte ; l'email est facultatif.
- **Des crédits qui durent.** Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez. Un crawl lancé deux fois par an ne vous fait pas payer onze mois d'inactivité.
- **Les erreurs ne coûtent rien.** 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Firecrawl ne facture rien lorsqu'il ne renvoie aucun document, mais une page qui répond 403 ou 404 lui coûte tout de même un crédit.
- **Une seule règle pour les propriétaires de sites.** Notre crawler vérifie robots.txt à chaque lecture et respecte `Content-Signal: ai-input=no`, sans aucun réglage pour désactiver cela. Son User-Agent est publié sur [notre page crawler](https://webreaderapi.com/fr/bot/).
- **Prix par page** aux volumes ci-dessus, au 2026-10-22.

## Comment les options de Firecrawl correspondent-elles aux endpoints de WebReaderAPI ?

Les lectures d'une page et les crawls se transposent directement ; l'extraction, les actions et les maps n'ont pas d'équivalent.

| Firecrawl | WebReaderAPI | Remarque |
|---|---|---|
| Scraper une page | `GET` ou `POST /read` | Même idée : une URL en entrée, un document en sortie |
| `formats: ["markdown"]` (par défaut) | `format=markdown` (par défaut) | Contenu principal uniquement par défaut ; `main_content=false` pour la page entière |
| `formats: ["html"]` | `format=html` | HTML nettoyé du contenu ; pas de HTML brut dans la version 1 |
| `formats: ["links"]` | `include_links=true` | Liens renvoyés sous forme de liste |
| `formats: ["json"]` avec un schéma | — | Faites tourner votre propre modèle sur notre Markdown |
| Actions, capture d'écran | — | Non proposé |
| `timeout` en ms (60 000 par défaut) | `timeout` en secondes (5 à 60, 30 par défaut) | |
| Cache `maxAge` (2 jours par défaut) | — | Nous ne conservons aucune copie ; chaque lecture récupère la page |
| Crawl avec `limit` et `maxDiscoveryDepth` | `POST /crawl` avec `limit` (jusqu'à 10 000) et `max_depth` | Résultats paginés avec un curseur |
| Map | — | Pas dans la version 1 |
| `ignoreRobotsTxt` (Enterprise) | — | robots.txt est toujours appliqué |

*Python : la lecture que vous envoyiez comme un scrape*

```python
import os

import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/changelog", "format": "markdown", "include_links": "true"},
    timeout=90,
)
if resp.status_code == 403:
    print("refused by robots.txt or by the site:", resp.json()["error"]["code"])
else:
    resp.raise_for_status()
    page = resp.json()
    print(page["title"], "-", page["credits_used"], "credit(s)")
    print(len(page.get("links", [])), "links")
    print(page["markdown"][:400])

```

## Les pages que Firecrawl pouvait lire fonctionneront-elles aussi ici ?

La plupart des pages publiques, oui, avec une différence de politique. Le mode amélioré de Firecrawl relance une requête via ce qu'il appelle des proxies améliorés après une réponse 401, 403 ou 429. WebReaderAPI ne relance pas autour d'un refus : quand un site dit non, vous recevez `502 target_refused` avec le statut du site, et aucun crédit n'est utilisé.

Faites passer vos 50 URL les plus importantes par les deux services pendant une journée avant de déplacer le trafic de production. Comparez le Markdown, le flag `rendered` et les crédits utilisés ; vous verrez à la fois la qualité et le prix réel pour vos pages.

## Quel pack remplace mon forfait Firecrawl ?

Comptez vos pages par mois et combien d'entre elles ont besoin d'un navigateur. Une charge de travail de taille Standard de 100 000 pages tient dans 100 000 pages si les pages sont statiques, ou dans deux de ces packs si chaque page a besoin d'un navigateur. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Alternative à Firecrawl : questions fréquentes

### Existe-t-il une alternative gratuite à Firecrawl ?

Firecrawl lui-même propose un niveau gratuit de 1 000 crédits par mois. Les outils open source comme Crawl4AI, MarkItDown et Trafilatura sont gratuits à exécuter sur vos propres serveurs ; voir [Crawl4AI ou une API hébergée](https://webreaderapi.com/fr/compare/crawl4ai-vs-api/). WebReaderAPI n'a pas de niveau gratuit : son plus petit pack est 10 000 pages pour 3,75 $US.

### Puis-je payer Firecrawl en crypto ?

Sa page tarifaire mentionne Stripe, avec cartes, cartes de débit et PayPal, et aucune option crypto. WebReaderAPI accepte uniquement BTC, USDT, USDC, ETH, SOL, LTC, sans KYC.

### WebReaderAPI extrait-il du JSON avec un schéma comme Firecrawl ?

Non. WebReaderAPI renvoie du Markdown, du texte ou du HTML nettoyé avec des métadonnées. Si vous avez besoin de champs, passez notre Markdown au modèle de votre choix avec votre schéma ; le format JSON de Firecrawl le fait pour 4 crédits supplémentaires par page.

### Les crédits Firecrawl expirent-ils ?

D'après la documentation de facturation de Firecrawl, les crédits des forfaits sont réinitialisés chaque mois et ne sont pas reportés par défaut ; les crédits achetés en supplément restent jusqu'à utilisation mais expirent si vous résiliez. Les crédits WebReaderAPI n'expirent jamais.

### Puis-je auto-héberger Firecrawl à la place ?

Oui. Son cœur est open source sous AGPL-3.0, et le README indique qu'il respecte robots.txt par défaut. Le service hébergé ajoute des fonctionnalités que la version open source n'inclut pas.

## Sources

1. [Tarifs de Firecrawl](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
2. [Facturation](https://docs.firecrawl.dev/billing.md) — Firecrawl docs (read 2026-10-22)
3. [Guide avancé de scraping](https://docs.firecrawl.dev/advanced-scraping-guide.md) — Firecrawl docs (read 2026-10-22)
4. [Crawl](https://docs.firecrawl.dev/features/crawl.md) — Firecrawl docs (read 2026-10-22)
5. [Mode amélioré](https://docs.firecrawl.dev/features/enhanced-mode.md) — Firecrawl docs (read 2026-10-22)
6. [Intégrations](https://docs.firecrawl.dev/integrations.md) — Firecrawl docs (read 2026-10-22)
7. [Lancement de Firecrawl sans clé](https://www.firecrawl.dev/blog/firecrawl-keyless-launch) — Firecrawl (read 2026-10-22)
8. [Présentation d'Alexandria et de notre Série B](https://www.firecrawl.dev/blog/introducing-alexandria-series-b) — Firecrawl (read 2026-10-22)
9. [dépôt firecrawl/firecrawl](https://github.com/firecrawl/firecrawl) — GitHub (read 2026-10-22)
10. [Outils web](https://docs.openclaw.ai/tools/web) — OpenClaw docs (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Alternative à Jina Reader : des crédits par page au lieu de tokens

> Alternative à Jina Reader : crédits par page au lieu de tokens, à partir de 0,07 $US/1K pages, robots.txt toujours vérifié, sans KYC, crypto.

- URL: https://webreaderapi.com/fr/alternatives/jina-reader/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Jina Reader a rendu célèbre l'astuce du préfixe d'URL : placez r.jina.ai/ devant un lien et récupérez du Markdown. Cette page explique comment Jina facture, quand c'est le bon outil, et quand un prix par page est plus simple à planifier.

**Réponse rapide — Quelle est une bonne alternative à Jina Reader ?**

Jina Reader facture les tokens de sortie : 50 $ pour 1 milliard, 500 $ pour 11 milliards, avec 10 millions de tokens gratuits par nouvelle clé pour un usage non commercial (relevé le 22 octobre 2026). **WebReaderAPI** facture à la page à la place, à partir de 0,07 $US/1K pages, donc une page longue coûte autant qu'une page courte. Il vérifie robots.txt à chaque lecture, vend des crédits qui n'expirent jamais, et accepte la crypto sans KYC.

## Jina Reader et WebReaderAPI en un coup d'œil

|  | WebReaderAPI (le nôtre) | Jina Reader |
| --- | --- | --- |
| Comment l'appeler | `GET https://webreaderapi.com/api/v1/read?url=…` avec une clé API | Préfixez le lien : `https://r.jina.ai/` + URL ; clé facultative |
| Unité de facturation | Pages : 1 crédit, 2 avec un navigateur | Tokens de sortie |
| Prix | 3,75 $US pour 10 000 pages ; à partir de 0,07 $US/1K pages | 50 $ pour 1 Md de tokens ; 500 $ pour 11 Md de tokens |
| Usage gratuit | Aucune | Sans clé à 20 requêtes par minute ; 10 M de tokens par nouvelle clé, usage non commercial uniquement |
| Rate limits | Limite de concurrence affichée dans le dashboard | 500 requêtes par minute avec une clé ; 5 000 en premium |
| robots.txt | Vérifié à chaque lecture | En-tête `X-Robots-Txt` en opt-in ; valeur par défaut non précisée |
| Crawler un site entier | `POST /crawl`, jusqu'à 10 000 pages | Aucun endpoint de crawl indiqué |
| PDF | Oui, jusqu'à 100 pages | Oui |
| Paiement | BTC, USDT, USDC, ETH, SOL, LTC | Cartes, Google Pay et PayPal via Stripe |
| Propriétaire | SerpGoat LLC | Jina AI, membre du groupe Elastic depuis octobre 2025 |

*Prix vérifiés le 22 octobre 2026.*

Faits sur Jina issus de jina.ai/reader et de son tableau de bord tarifaire, consultés le 2026-10-22.

## Comment Jina Reader facture-t-il, et combien coûte une page ?

Jina compte les tokens de la réponse. Ses offres sont de 50 $ pour 1 milliard de tokens, soit environ 0,05 $ par million, et de 500 $ pour 11 milliards, soit environ 0,045 $ par million. Les requêtes échouées ne sont pas décomptées, et une page demandée deux fois en 5 minutes provient d'un cache.

Le coût d'une page dépend donc de sa longueur, et Jina ne publie aucune moyenne. En **estimation, en supposant 5 000 tokens par page**, 1 000 pages coûtent environ 0,25 $ sur la première offre et 0,225 $ sur la seconde. Un brief d'actualité de 2 000 tokens coûte moins que cela ; une page de documentation de 20 000 tokens coûte quatre fois plus. L'OCR via jina-ocr-v1 coûte 40 fois plus de tokens.

## Quand est-il plus simple de planifier avec des crédits par page ?

Quand vous savez combien de pages vous allez lire mais pas leur longueur. Un crawl d'un site de documentation, une liste de pages concurrentes à surveiller, ou un agent qui lit cinq liens par tâche ont tous un nombre de pages, pas un nombre de tokens.

Avec WebReaderAPI, 100 000 pages coûtent 21,75 $US, quelle que soit la longueur de chaque page, au 22 octobre 2026. Les pages qui nécessitent un navigateur consomment deux crédits, et le champ `rendered` indique quand cela s'est produit. Utilisez `max_chars` pour limiter la taille de ce qui est renvoyé ; cela protège la fenêtre de contexte de votre modèle mais ne change pas le prix.

## Quand Jina Reader est-il le meilleur choix ?

Choisissez Jina Reader quand le temps de mise en place compte plus que tout le reste, ou quand vos pages sont courtes :

- **Aucune configuration.** Un préfixe d'URL fonctionne sans clé à 20 requêtes par minute, ce qui suffit pour des tests et de petits scripts.
- **Pages courtes.** Avec la facturation au token, une page courte coûte moins qu'un prix par page ; avec l'estimation de 5 000 tokens ci-dessus, Jina coûte moins par page que notre pack 10 000 pages.
- **Contrôle fin via les headers.** `X-Target-Selector`, `X-Remove-Selector`, `X-Token-Budget`, `X-Engine` et d'autres façonnent chaque lecture.
- **Modèles et recherche.** La sortie ReaderLM-v2 et la recherche `s.jina.ai` proviennent du même compte.
- **Un serveur MCP officiel** dont l'outil `read_url` lit jusqu'à cinq URL par appel.
- **Open source.** La branche Reader sur GitHub est sous Apache-2.0, sans la couche de stockage hébergée.

Jina AI fait désormais partie d'Elastic, qui a finalisé l'acquisition le 9 octobre 2025.

## Comment les headers Jina Reader correspondent-ils aux paramètres WebReaderAPI ?

La plupart des lectures se transposent en changeant l'URL et en ajoutant une clé.

| Jina Reader | WebReaderAPI | Remarque |
|---|---|---|
| `https://r.jina.ai/https://example.com` | `GET https://webreaderapi.com/api/v1/read?url=https://example.com` | Clé dans le header `Authorization` |
| Sortie Markdown par défaut | `format=markdown` (par défaut) | Contenu principal par défaut |
| `X-Engine: direct` | `render=false` | Lecture HTTP simple |
| Navigateur headless par défaut | `render=auto` ou `render=true` | 2 crédits quand le navigateur s'exécute |
| `X-Token-Budget` | `max_chars` | Caractères, pas tokens |
| `X-Target-Selector`, `X-Remove-Selector` | — | Détection du contenu principal à la place |
| `X-Proxy` (pays) | `country` | +10 crédits, connexion résidentielle |
| `X-No-Cache` | — | Nous ne conservons aucun cache |
| `X-Robots-Txt` (opt-in) | — | robots.txt est toujours vérifié |
| Surcharge de `X-User-Agent` | — | Notre User-Agent est fixe et publié |

*Python : du préfixe r.jina.ai à l'endpoint de lecture*

```python
import os

import requests

# Before: requests.get("https://r.jina.ai/" + url)
url = "https://example.com/guide/install"
resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": url, "render": "auto", "max_chars": 30000},
    timeout=90,
)
resp.raise_for_status()
page = resp.json()
print(page["word_count"], "words, rendered:", page["rendered"], "credits:", page["credits_used"])
print(page["markdown"][:400])

```

## Qu'est-ce qui change pour les sites que vous lisez ?

Avec Jina, robots.txt n'est vérifié que lorsque vous envoyez le header `X-Robots-Txt`, et vous pouvez surcharger le User-Agent du navigateur ; ses pages n'indiquent la valeur par défaut pour ni l'un ni l'autre. Avec WebReaderAPI, les deux sont fixes : chaque lecture vérifie robots.txt pour `WebReaderAPI` et pour tous les robots, et chaque requête porte `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`.

Cela signifie que certaines pages que Jina peut lire seront refusées ici, sans frais pour vous. En échange, les propriétaires de sites peuvent voir qui lit leurs pages et nous bloquer ou nous autoriser en une ligne, comme l'explique notre [page crawler](https://webreaderapi.com/fr/bot/).

## Combien coûte WebReaderAPI au lieu des tokens ?

Un prix fixe par page : 10 000 pages pour 3,75 $US jusqu'à 5 000 000 pages pour 350 $US, au 22 octobre 2026. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Alternative à Jina Reader : questions fréquentes

### Jina Reader est-il gratuit ?

En partie. Sans clé, r.jina.ai est gratuit pour un usage basique à 20 requêtes par minute. Chaque nouvelle clé reçoit aussi 10 millions de tokens gratuits, que la page tarifaire de Jina limite à un usage non commercial. Les offres payantes commencent à 50 $ pour 1 milliard de tokens.

### Pourquoi une page Jina Reader coûte-t-elle plus cher quand la page est longue ?

Parce que Jina facture les tokens de sa réponse. Un article long renvoie plus de tokens qu'un article court. WebReaderAPI facture un crédit par page, deux avec un navigateur, quelle que soit la longueur.

### Peut-on payer Jina Reader en crypto ?

Les pages de Jina mentionnent Stripe avec cartes, Google Pay et PayPal, et aucune option crypto. WebReaderAPI accepte BTC, USDT, USDC, ETH, SOL, LTC, sans KYC.

### WebReaderAPI propose-t-il un mode gratuit sans clé comme r.jina.ai ?

Non. Chaque lecture nécessite une clé, et les clés s'accompagnent d'un pack payant. Le plus petit pack est 10 000 pages pour 3,75 $US.

### À qui appartient Jina Reader aujourd'hui ?

Elastic. Elle a finalisé son acquisition de Jina AI le 9 octobre 2025, et la page légale de Jina indique que les conditions de traitement des données d'Elastic s'appliquent désormais.

## Sources

1. [Reader](https://jina.ai/reader/) — Jina AI (read 2026-10-22)
2. [Tableau de bord API : tarifs](https://jina.ai/api-dashboard/pricing/) — Jina AI (read 2026-10-22)
3. [Mentions légales](https://jina.ai/legal/) — Jina AI (read 2026-10-22)
4. [dépôt jina-ai/reader](https://github.com/jina-ai/reader) — GitHub (read 2026-10-22)
5. [dépôt jina-ai/MCP](https://github.com/jina-ai/MCP) — GitHub (read 2026-10-22)
6. [Elastic finalise l'acquisition de Jina AI](https://ir.elastic.co/News--Events/news/news-details/2025/Elastic-Completes-Acquisition-of-Jina-AI-a-Leader-in-Frontier-Models-for-Multimodal-and-Multilingual-Search/default.aspx) — Elastic (2025-10-09, read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Meilleures API web reader en 2026 : 10 façons de transformer des URL en Markdown

> Meilleures API web reader et URL vers Markdown en 2026 : 10 options comparées sur le prix pour 1 000 pages, JavaScript et robots.txt. Vérifié le 2026-10-22.

- URL: https://webreaderapi.com/fr/best/web-reader-apis/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Dix API hébergées et outils open source qui transforment des pages web en Markdown pour les modèles, comparés sur les mêmes critères à partir de leurs propres pages. Nous publions WebReaderAPI, qui est premier de cette liste ; chaque entrée indique ce que cette option fait mieux.

**Réponse rapide — Quelle est la meilleure API web reader ou URL vers Markdown en 2026 ?**

Cela dépend de la tâche. Au 22 octobre 2026 : **WebReaderAPI** pour le paiement en crypto, sans KYC, robots.txt respecté et des crédits qui n'expirent jamais, à partir de 0,07 $US/1K pages ; Firecrawl pour l'ensemble de fonctionnalités le plus complet à 0,99 $ pour 1 000 pages sur son offre à 99 $ ; Jina Reader pour des lectures sans configuration facturées au token ; Crawl4AI si vous préférez l'auto-hébergement sous licence Apache-2.0.

## Les 10 meilleures API de lecture de pages web en 2026

**Méthodologie.** Publié par WebReaderAPI (SerpGoat LLC). Chaque fournisseur est comparé selon les mêmes critères, tirés de son propre site public : prix catalogue pour 1 000 pages, pages simples et pages rendues par navigateur, offre gratuite et expiration des crédits, fonctionnalités de qualité Markdown (contenu principal, PDF, crawl), politique relative à robots.txt, moyens de paiement acceptés, dont la crypto, pièces d'identité ou carte bancaire exigées, date à laquelle les prix ont été vérifiés.

*Prix vérifiés le 22 octobre 2026.*

### 1. WebReaderAPI — Notre produit

Une API de lecture de pages web pour agents IA, avec des crédits prépayés qui n'expirent jamais, payable en crypto sans KYC ; son crawler respecte robots.txt et ne cherche jamais à contourner un refus.

- Idéal pour: Paiement en crypto sans justificatif ; agents et pipelines RAG qui veulent un crawl respectueux
- Prix: 0,38 $US/1K pages sur 10 000 pages, 0,07 $US/1K pages sur 1 000 000 pages ; les pages rendues par navigateur coûtent 2 crédits
- KYC: Aucune
- Paiement en crypto: BTC, USDT, USDC, ETH, SOL, LTC
- Avantages: Les crédits n'expirent jamais
- Avantages: Pages en échec et pages refusées par robots.txt gratuites
- Avantages: Code d'outil pour MCP, LangChain, LlamaIndex, OpenAI, n8n, OpenClaw
- Inconvénients: Pas d'offre gratuite
- Inconvénients: Pas d'extraction en JSON structuré ni d'actions sur la page
- Inconvénients: Les pages qu'un site refuse restent refusées

### 2. Firecrawl

L'API la plus connue pour transformer les sites en données prêtes pour les LLM : scraping, crawl, map et extraction, avec un vaste écosystème open source et MCP.

- Idéal pour: Équipes qui ont besoin d'extraction structurée, d'actions sur la page et d'un écosystème mature
- Prix: 3,80 $ pour 1 000 sur Hobby (19 $ pour 5 000) ; 0,99 $ sur Standard (99 $ pour 100 000) ; 0,749 $ sur Scale (749 $ pour 1 million) ; JavaScript inclus
- KYC: Non précisé
- Paiement en crypto: Non (cartes bancaires, PayPal)
- Avantages: 1 000 crédits gratuits par mois, sans carte
- Avantages: Respecte robots.txt par défaut
- Avantages: Cœur auto-hébergeable (AGPL-3.0)
- Inconvénients: Les crédits du forfait sont réinitialisés chaque mois
- Inconvénients: L'extraction JSON ajoute 4 crédits par page

### 3. Jina Reader

Préfixez une URL par r.jina.ai et récupérez du Markdown ; facturation au token de sortie, désormais intégré à Elastic.

- Idéal pour: Lectures rapides sans configuration ; pages courtes
- Prix: 50 $ pour 1 milliard de tokens de sortie ; 500 $ pour 11 milliards (le coût par page dépend de la longueur de la page)
- KYC: Non précisé
- Paiement en crypto: Non précisé
- Avantages: Utilisation sans clé à 20 requêtes par minute
- Avantages: 10 millions de tokens gratuits par nouvelle clé (usage non commercial)
- Inconvénients: La facturation au token rend le coût des pages longues difficile à prévoir
- Inconvénients: robots.txt uniquement via un header activé en option

### 4. Crawl4AI

Le crawler open source le plus populaire pour les LLM, avec un cloud hébergé en lancement progressif.

- Idéal pour: Équipes qui veulent auto-héberger et tout contrôler
- Prix: Gratuit en auto-hébergement ; Cloud à partir de 10 $ (Starter), page simple 0,5 crédit, page rendue par navigateur 1 crédit
- KYC: Pas de carte (Cloud)
- Paiement en crypto: Non précisé
- Avantages: Licence Apache-2.0
- Avantages: Serveur MCP auto-hébergé
- Inconvénients: L'auto-hébergement implique des serveurs et de la maintenance
- Inconvénients: check_robots_txt est désactivé par défaut

### 5. Olostep

Une API qui rend chaque page dans un navigateur, avec des batches, des crawls et des maps, et du paiement en crypto par requête pour les agents.

- Idéal pour: Sites riches en JavaScript à fort volume
- Prix: 1,80 $ pour 1 000 sur Starter (9 $ pour 5 000) ; 0,399 $ sur Scale (399 $ pour 1 million), chaque page rendue
- KYC: Carte pour les recharges
- Paiement en crypto: Par requête, USDC (x402)
- Avantages: Prix vérifié le plus bas pour une page rendue par navigateur à 1 million par mois
- Avantages: Batches, crawls et maps
- Inconvénients: Les crédits du forfait sont réinitialisés chaque mois

### 6. Exa contents

Contenu des pages issu de l'index de recherche d'Exa à prix fixe, avec du paiement en crypto par requête pour les agents.

- Idéal pour: Agents qui utilisent déjà la recherche Exa
- Prix: 1,00 $ pour 1 000 pages, prix fixe
- KYC: Carte pour le paiement à l'usage
- Paiement en crypto: Par requête, USDC (x402)
- Avantages: 10 $ de crédits offerts par mois
- Avantages: x402 à 0,001 $ par page
- Inconvénients: Priorité au cache ; aucune option navigateur documentée

### 7. Tavily Extract

Extraction depuis la stack de recherche Tavily, facturée par lot d'URL, avec un mode avancé.

- Idéal pour: Agents construits autour de la recherche Tavily
- Prix: 1,50 $ pour 1 000 URL basiques sur Project (30 $) ; 1,00 $ sur Growth (500 $) ; le mode avancé double le prix
- KYC: Non précisé
- Paiement en crypto: Uniquement à sa discrétion (conditions)
- Avantages: 1 000 crédits par mois offerts (5 000 URL basiques)
- Inconvénients: Les crédits sont réinitialisés chaque mois
- Inconvénients: Politique robots.txt non précisée

### 8. ScrapingBee

Une API de scraping généraliste avec une option de sortie Markdown et des prix bas pour les pages simples à fort volume.

- Idéal pour: Fort volume de pages simples
- Prix: 0,099 $ pour 1 000 pages simples à 1 million par mois (99 $ Startup) ; les pages rendues par navigateur coûtent 5 crédits
- KYC: Carte pour les offres payantes
- Paiement en crypto: Non
- Avantages: Prix bas pour les pages simples à fort volume
- Avantages: Sortie Markdown et texte
- Inconvénients: Aucun report de crédits
- Inconvénients: Politique robots.txt non précisée

### 9. ZenRows

Une API de scraping avec sortie Markdown incluse et une boutique pour agents qui accepte USDC.

- Idéal pour: Petites charges de travail d'agents payées à l'usage
- Prix: 0,50 $ pour 1 000 pages simples via sa boutique pour agents ; 0,199 $ à 1 million sur les plans ; les pages navigateur coûtent 5 crédits
- KYC: Validation par email
- Paiement en crypto: Agents uniquement, USDC (x402)
- Avantages: Markdown sans surcoût
- Avantages: 5 000 crédits gratuits par mois
- Inconvénients: Les comptes ne peuvent pas payer en crypto
- Inconvénients: Les crédits du plan expirent au renouvellement

### 10. Cloudflare Browser Run

Le service navigateur de Cloudflare avec les endpoints /markdown et /crawl, facturé au temps de navigateur.

- Idéal pour: Équipes déjà sur Cloudflare Workers
- Prix: 0,09 $ par heure de navigateur au-delà des 10 heures incluses, minimum mensuel de 5 $
- KYC: Compte Cloudflare
- Paiement en crypto: USDC via Stripe pour la facturation Cloudflare (une page de facturation l'omet)
- Avantages: /crawl respects robots.txt and always identifies itself as a bot
- Avantages: Payez le temps de navigateur, pas la page
- Inconvénients: Le coût par page dépend du temps que prend chaque page

*Divulgation : cette page est publiée par WebReaderAPI. Les informations sur les concurrents proviennent de leurs sites web publics à la date indiquée ci-dessus et ont pu changer depuis.*

## Comment choisir une API de lecture de pages web ?

Commencez par vos pages, puis par votre volume.

1. **Vos pages ont-elles besoin d'un navigateur ?** Actualités, blogs et documentation généralement non ; les applications web et certaines boutiques oui. Les API de scraping à crédits facturent les pages navigateur 5 à 10 fois plus cher, tandis que Firecrawl et Olostep facturent chaque page au même prix.
2. **Combien de pages par mois, et à quelle régularité ?** Les plans mensuels avec de gros quotas conviennent à un volume régulier ; les crédits prépayés qui n'expirent pas conviennent aux agents et aux crawls ponctuels.
3. **Avez-vous besoin d'une extraction au-delà du Markdown ?** Le JSON structuré, les actions de page et les captures d'écran sont les points forts de Firecrawl et des grandes API de scraping.
4. **Comment voulez-vous traiter les propriétaires de sites ?** Firecrawl, le /crawl de Cloudflare et WebReaderAPI respectent robots.txt par défaut ; plusieurs API vous laissent décider ou ne se prononcent pas.
5. **Comment allez-vous payer ?** La plupart n'acceptent que les cartes. Scrape.do, Decodo et Scrapeless indiquent la crypto sur les comptes ; Exa, Olostep et d'autres acceptent l'USDC par requête ; WebReaderAPI accepte BTC, USDT, USDC, ETH, SOL, LTC sans KYC.

## Faut-il héberger soi-même plutôt que payer une API ?

L'auto-hébergement est gratuit en termes de licence et coûteux en temps. Crawl4AI (Apache-2.0), Microsoft MarkItDown (MIT), Trafilatura (Apache-2.0) et Mozilla Readability (Apache-2.0) couvrent la conversion ; il vous reste à gérer les serveurs, les navigateurs headless, les relances et la gestion de robots.txt. Le cœur de Firecrawl peut aussi être auto-hébergé sous licence AGPL-3.0.

Pour quelques milliers de pages par mois, une API hébergée coûte généralement moins que le temps passé à maintenir un crawler. Notre page [Crawl4AI ou API hébergée](https://webreaderapi.com/fr/compare/crawl4ai-vs-api/) expose le compromis.

## Combien coûte WebReaderAPI ?

Crédits prépayés, un par page simple et deux par page navigateur ; les crédits n'expirent jamais. Tarifs fixés le 22 octobre 2026.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Meilleure API de lecture de pages web : questions fréquentes

### Lequel est le meilleur, Firecrawl ou Jina Reader ?

Firecrawl convient aux équipes qui ont besoin de crawl, d'extraction structurée et d'un prix par page prévisible ; Jina Reader convient aux lectures rapides sans configuration, facturées au token. Notre page [Firecrawl vs Jina Reader](https://webreaderapi.com/fr/compare/firecrawl-vs-jina-reader/) les compare ligne par ligne.

### Quelle API de lecture de pages web respecte robots.txt ?

Firecrawl le respecte par défaut, avec une dérogation uniquement en Enterprise ; le /crawl de Cloudflare le respecte sans option de désactivation documentée ; WebReaderAPI le respecte à chaque requête. Jina en fait un header optionnel, et beaucoup d'API de scraping n'énoncent aucune politique.

### Existe-t-il une API gratuite d'URL vers Markdown ?

Plusieurs proposent des quotas gratuits : Firecrawl 1 000 crédits par mois, Tavily 1 000 crédits par mois, Exa 10 $ par mois, ZenRows 5 000 crédits par mois, et Jina 10 millions de tokens pour un usage non commercial. WebReaderAPI n'a pas d'offre gratuite.

### Ce classement est-il indépendant ?

Non. Il est publié par WebReaderAPI, classé premier. Chaque option est décrite à partir de ses propres pages publiques, consultées le 22 octobre 2026, selon les mêmes critères, et chaque entrée indique ce qu'elle fait de mieux.

## Sources

1. [Tarifs de Firecrawl](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
2. [Tarifs de l'API Jina](https://jina.ai/api-dashboard/pricing/) — Jina AI (read 2026-10-22)
3. [Crawl4AI](https://crawl4ai.com/) — Crawl4AI (read 2026-10-22)
4. [Dépôt Crawl4AI](https://github.com/unclecode/crawl4ai) — GitHub (read 2026-10-22)
5. [Tarifs Olostep](https://www.olostep.com/pricing) — Olostep (read 2026-10-22)
6. [Tarifs Exa](https://exa.ai/pricing) — Exa (read 2026-10-22)
7. [Crédits de l'API Tavily](https://docs.tavily.com/documentation/api-credits) — Tavily (read 2026-10-22)
8. [Tarifs ScrapingBee](https://www.scrapingbee.com/pricing/) — ScrapingBee (read 2026-10-22)
9. [Tarifs ZenRows](https://docs.zenrows.com/first-steps/pricing.md) — ZenRows (read 2026-10-22)
10. [Tarifs Browser Run](https://developers.cloudflare.com/browser-run/pricing/) — Cloudflare (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Bot WebReaderAPI : user agent, robots.txt et comment le bloquer

> WebReaderAPI : User-Agent exact, token robots.txt, comment le bloquer ou le ralentir, et ce qu'il ne fait jamais. Pour les propriétaires de sites et outils IA.

- URL: https://webreaderapi.com/fr/bot/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Si vous avez vu notre nom dans vos logs serveur, cette page explique qui nous sommes, pourquoi nous avons récupéré votre page et comment nous demander de ne pas le faire. Chaque règle ici est un engagement sur lequel le service est construit.

**Réponse rapide — Qu'est-ce que le bot WebReaderAPI, et comment le bloquer ?**

Le bot **WebReaderAPI** récupère des pages publiques lorsqu'un de nos clients demande à l'API de les lire. Il envoie le user agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` et respecte les règles robots.txt écrites pour le token `WebReaderAPI` ou pour tous les robots. Pour le bloquer partout, ajoutez `User-agent: WebReaderAPI` suivi de `Disallow: /` à votre robots.txt.

## Le bot en bref

| Attribut | Valeur |
| --- | --- |
| En-tête User-Agent | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` |
| Token robots.txt | `WebReaderAPI` |
| robots.txt | Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées |
| Signaux de préférence IA | Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous |
| Quand un site refuse | Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall |
| Copies de vos pages | Aucune conservée après l'envoi de la réponse au client |
| Tâches de crawl | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay |
| Contact | abuse@webreaderapi.com |

## Pourquoi WebReaderAPI a-t-il récupéré ma page ?

Parce qu'un client de l'API l'a demandé. WebReaderAPI ne construit pas son propre index du web et ne navigue pas de sa propre initiative. Chaque récupération correspond à l'un des trois types de requête :

- **Une lecture unique :** une application ou un agent IA a envoyé votre URL à `/read`, généralement parce qu'une personne a posé une question à laquelle votre page répond.
- **Une tâche par lots :** un client a envoyé une liste pouvant aller jusqu'à 100 URL, et la vôtre y figurait.
- **Une tâche de crawl :** un client nous a demandé de lire un site entier, à partir d'une adresse et en restant sur ce domaine. Les crawls suivent votre sitemap et votre robots.txt.

Le client reçoit le texte principal de la page en Markdown. Nous n'en conservons ensuite aucune copie.

## Comment bloquer le bot sur tout mon site ?

Ajoutez un groupe pour notre token dans votre fichier robots.txt. Le bot lit `/robots.txt` avant de récupérer une page et le met en cache pendant 24 heures au maximum, donc une modification s'applique dans la journée au plus tard.

*robots.txt : refuser toutes les pages à WebReaderAPI*

```text
User-agent: WebReaderAPI
Disallow: /

```

## Puis-je bloquer seulement une partie de mon site, ou ralentir le bot ?

Oui. Listez les dossiers que vous voulez exclure sous `Disallow`, et définissez un `Crawl-delay` en secondes pour les tâches de crawl. Les règles écrites pour tous les robots (`User-agent: *`) s'appliquent aussi à nous lorsque vous n'avez pas de groupe pour notre token. Lorsque vous en avez un, ce groupe l'emporte, comme le décrit la RFC 9309.

*robots.txt : exclure deux dossiers et espacer les requêtes de crawl*

```text
User-agent: WebReaderAPI
Disallow: /account/
Disallow: /drafts/
Crawl-delay: 5

```

## Le bot respecte-t-il les signaux de préférence IA ?

Oui, ceux qu'un site déclare dans robots.txt. Si votre fichier déclare `Content-Signal: ai-input=no`, nous l'interprétons comme un refus que vos pages soient utilisées comme entrée pour des réponses IA, et nous ne les lisons pas pour nos clients. L'API renvoie alors l'erreur `blocked_by_site_policy` au client, qui n'est pas facturé.

*robots.txt : autoriser les moteurs de recherche, refuser l'entrée IA*

```text
User-agent: *
Content-Signal: search=yes, ai-input=no
Allow: /

```

## Que fait le bot lorsque mon site le refuse ?

Il s'arrête et rapporte votre réponse. Un statut 403 ou 429, une page de challenge, un formulaire de connexion ou un paywall mettent tous fin à la requête. Le client reçoit l'erreur `target_refused` avec votre code de statut, et n'est pas facturé pour cela.

Le bot ne résout jamais de challenges, ne se connecte jamais, ne change jamais son user agent pour ressembler à un navigateur et ne réessaie jamais déguisé. Si vous voulez que nous lisions vos pages, autorisez le token dans robots.txt et laissez passer les requêtes ; sinon, rien de plus n'est nécessaire de votre côté.

## Que ne promet pas encore WebReaderAPI ?

Nous ne publions pas de liste d'adresses IP aujourd'hui, donc identifiez le bot par son user agent et son comportement vis-à-vis de robots.txt, pas par IP. Les pages lues avec l'option `country` partent d'une adresse située dans le pays choisi, toujours avec le même user agent. Nous ajouterons nos plages d'adresses à cette page dès qu'elles seront fixées, avec la date du changement.

## Comment signaler un problème avec le bot ?

Écrivez à abuse@webreaderapi.com avec la date et l'heure, votre domaine, l'URL récupérée et une ligne de votre journal d'accès montrant notre user agent. Une personne lit chaque signalement et le vérifie dans nos logs. Si un client utilise l'API en violation de notre [Politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/), son compte est suspendu.

Pour vérifier qu'une requête vient bien de nous, comparez le user agent et le comportement vis-à-vis de robots.txt avec cette page. Un client qui ignore vos règles robots.txt tout en utilisant notre nom n'est pas notre bot.

## Questions des propriétaires de sites

### Le bot WebReaderAPI est-il un crawler de moteur de recherche ?

Non. Il n'indexe pas le web et ne classe pas les pages. Il lit une page uniquement lorsqu'un client de l'API demande cette page, dans une requête unique, un lot ou un crawl d'un seul site.

### Bloquer le bot affectera-t-il mon classement sur Google ou Bing ?

Non. Les règles écrites pour `WebReaderAPI` ne concernent que notre bot. Les crawlers des moteurs de recherche suivent leurs propres groupes dans votre robots.txt.

### Au bout de combien de temps une modification de robots.txt prend-elle effet ?

Dans les 24 heures au plus tard. Le bot met robots.txt en cache pendant un jour au maximum avant de le relire.

### Le bot respecte-t-il Crawl-delay ?

Oui, pour les tâches de crawl, qui lisent plusieurs pages d'un même site. Une lecture unique correspond à une requête et n'est pas espacée.

### Stockez-vous ou vendez-vous le contenu de mes pages ?

Non. Le texte de la page est transmis au client qui l'a demandé et n'est pas conservé par nous. Nos logs contiennent le nom d'hôte, l'heure, le statut et les crédits utilisés, pendant 30 jours.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Journal des modifications

> Journal des modifications de WebReaderAPI : changements datés de l'API, des prix et des règles de crawl. Première entrée : site et documentation.

- URL: https://webreaderapi.com/fr/changelog/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Les changements apportés à l'API, aux prix, au comportement du crawler et aux politiques sont listés ici, du plus récent au plus ancien. Une modification d'un engagement pris ailleurs sur le site figure ici aussi.

**Réponse rapide — Qu'est-ce qui a changé chez WebReaderAPI ?**

Le 22 octobre 2026, **WebReaderAPI** a publié son site, sa documentation, ses prix et ses politiques. L'API elle-même n'est pas encore ouverte ; son lancement sera la prochaine entrée de cette page. Les prix commencent à 3,75 $US pour 10 000 pages et descendent à 0,07 $US/1K pages sur le pack le plus grand.

## 22 octobre 2026 : site et documentation publiés

- **Site, prix et politiques** mis en ligne : [tarifs](https://webreaderapi.com/fr/pricing/), [conditions](https://webreaderapi.com/fr/terms/), [confidentialité](https://webreaderapi.com/fr/privacy/), [utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/) et [remboursements](https://webreaderapi.com/fr/refunds/).
- **Documentation** des endpoints `/read`, `/batch`, `/crawl` et `/credits`, avec du code pour Python, Node.js et curl.
- **Règles de crawler** publiées sur la [page bot](https://webreaderapi.com/fr/bot/) : user agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, token robots.txt `WebReaderAPI`, respect de `ai-input=no`.
- **Statut de l'API :** lancement en attente. Tant que l'entrée de lancement n'apparaît pas ici, aucune clé API ne peut être achetée.

## Qu'est-ce qui compte comme un changement méritant une entrée datée ?

Tout ce sur quoi un client ou un propriétaire de site pourrait compter :

- un nouvel endpoint, paramètre ou champ de réponse ;
- un champ renommé ou supprimé (ce qui n'arrive que dans une nouvelle version de l'API, comme `/api/v2/`) ;
- un prix, une règle de crédits ou une règle de remboursement ;
- un changement dans la façon dont le crawler s'identifie ou traite robots.txt ;
- un incident ayant affecté des requêtes, avec sa plage horaire.

## Comment les changements de prix sont-ils gérés ?

Un nouveau prix s'applique aux packs achetés après sa publication ici. Les crédits que vous détenez déjà gardent leur valeur : ils sont comptés en pages, pas en dollars, et Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

## Quelle est la stabilité de la version 1 de l'API ?

Au sein de la version 1, nous pouvons ajouter des champs et des paramètres, jamais les renommer ni les supprimer. Le code qui lit les champs documentés dans le [format de réponse](https://webreaderapi.com/fr/docs/response/) continue de fonctionner. Un changement cassant irait dans une nouvelle version, annoncée ici avant sa mise en ligne.

## Comment suivre les changements ?

Consultez cette page, ou lisez sa version Markdown, que [llms.txt](https://webreaderapi.com/llms.txt) liste avec les autres pages du site. Chaque entrée conserve sa date, ce qui vous permet de voir ce qui a changé depuis votre dernière visite. Les questions vont à support@webreaderapi.com.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Crawl4AI ou une API hébergée ? Quand faire tourner votre propre lecteur de pages web

> Crawl4AI ou une API hébergée pour convertir des pages web en Markdown ? Licences, robots.txt, coût de l'auto-hébergement et prix vérifiés le 2026-10-22.

- URL: https://webreaderapi.com/fr/compare/crawl4ai-vs-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Les outils open source peuvent convertir des pages web en Markdown gratuitement, sur vos propres serveurs. Les API hébergées facturent à la page et font tourner les serveurs pour vous. Cette page expose ce que coûte réellement chaque choix, des licences et du comportement par défaut vis-à-vis de robots.txt jusqu'aux navigateurs et à la maintenance.

**Réponse rapide — Dois-je auto-héberger Crawl4AI ou utiliser une API hébergée de lecture de pages web ?**

Auto-hébergez Crawl4AI (Apache-2.0, avec une obligation d'attribution) lorsque vous avez un volume régulier et des personnes pour faire tourner navigateurs et serveurs ; notez que sa vérification de robots.txt est désactivée par défaut. Utilisez une API hébergée lorsque le volume est irrégulier ou que vous ne voulez aucun travail d'exploitation : Crawl4AI Cloud démarre à 10 $ pour 10 000 crédits, et **WebReaderAPI** à 3,75 $US pour 10 000 pages, payable en crypto sans KYC (22 octobre 2026).

## Quels outils open source convertissent des pages web en Markdown ?

Les principales options en octobre 2026, avec la licence et les valeurs par défaut indiquées par leurs propres dépôts et documentations.

| Outil | Licence | Rend le JavaScript | robots.txt par défaut | Serveur MCP |
| --- | --- | --- | --- | --- |
| Crawl4AI | Apache-2.0, plus une obligation d'attribution dans le README | Oui (Playwright) | Désactivé : `check_robots_txt` vaut False par défaut | Oui, sur votre propre serveur |
| Firecrawl (auto-hébergé) | Cœur AGPL-3.0 ; SDK et certaines parties d'interface MIT | Oui (service Playwright) | Activé | Oui (firecrawl-mcp-server, MIT) |
| Microsoft MarkItDown | MIT | Non | Non documenté | Oui (markitdown-mcp) |
| Trafilatura | Apache-2.0 (GPLv3+ avant la v1.8.0) | Non | Son spider suit le Robots Exclusion Standard | Aucun mentionné |
| Mozilla Readability | Apache-2.0 | Non ; nécessite un DOM et ne fait pas de récupération | Non applicable | Aucun trouvé |
| Jina Reader (branche open source) | Apache-2.0 | Oui (Puppeteer) | Non mentionné | Absent du dépôt |

*Prix vérifiés le 22 octobre 2026.*

D'après les dépôts GitHub et la documentation listés ci-dessous, consultés le 2026-10-22.

## Combien coûte réellement l'auto-hébergement d'un lecteur web ?

Le logiciel est gratuit ; l'exécuter ne l'est pas. Avant de comparer un prix hébergé à zéro, comptez ces postes :

- **Serveurs et navigateurs.** Les pages statiques demandent peu de CPU, mais les pages JavaScript exigent un navigateur headless par requête, avec la mémoire correspondante. Les pics nécessitent une capacité de réserve qui reste inactive le reste du temps.
- **Maintenance.** Les versions de navigateur, les règles d'extraction et les dépendances changent. Crawl4AI a publié la v0.9.5 le 14 octobre 2026 ; MarkItDown la 0.1.9 le 21 octobre 2026. Quelqu'un doit tester et déployer chaque mise à jour.
- **Réseau.** La bande passante sortante, le DNS, les timeouts et les retries sont à votre charge. Les sites peuvent refuser le trafic provenant des adresses de vos serveurs, et la bonne réponse est alors de respecter ce refus.
- **Politique.** Crawl4AI laisse `check_robots_txt` désactivé sauf si vous l'activez, et vous permet de définir ou de randomiser le user agent. Décider et appliquer vos propres règles robots.txt et d'identification fait partie du travail.
- **Sécurité.** Le README de MarkItDown avertit qu'il effectue des I/O avec les privilèges du processus courant et que les entrées doivent être assainies dans des environnements non fiables. Un service qui récupère des URL arbitraires doit aussi refuser les adresses privées et locales.

## Combien facturent les lecteurs hébergés en comparaison ?

Les API hébergées transforment ces coûts en un prix par page. Deux exemples au 22 octobre 2026 :

| | Crawl4AI Cloud | WebReaderAPI (le nôtre) |
|---|---|---|
| Entrée | Starter 10 $ par mois, 10 000 crédits | 3,75 $US pour 10 000 pages |
| Page statique | 0,5 crédit | 1 crédit |
| Page avec navigateur | 1 crédit ("vrai navigateur") | 2 crédits |
| Offres supérieures | Builder 99 $ pour 125 000 crédits ; Scale 499 $ pour 750 000 | 74,25 $US pour 1 000 000 pages ; 350 $US pour 5 000 000 pages |
| Crédits inutilisés | Les crédits mensuels ne sont pas reportés ; les crédits supplémentaires n'expirent jamais | N'expirent jamais |
| Paiement | Carte via Stripe | BTC, USDT, USDC, ETH, SOL, LTC |
| robots.txt | Les clients doivent respecter les directives robots des sites (conditions) | Vérifié par le service à chaque lecture |

Crawl4AI Cloud est opéré par les mainteneurs de Crawl4AI et marque ses prix comme un "soft launch" susceptible de changer. Son crédit vaut 0,001 $, donc une page statique coûte 0,50 $ pour 1 000 sur Starter.

## Quand faut-il auto-héberger ?

L'auto-hébergement devient rentable quand trois conditions sont réunies : votre volume est élevé et stable, vous exploitez déjà des serveurs et des navigateurs, et vous avez besoin d'un contrôle qu'une API ne peut pas offrir.

- **Extraction personnalisée.** Les schémas CSS, XPath et LLM de Crawl4AI, ou vos propres règles par-dessus Readability ou Trafilatura.
- **Résidence des données.** Les pages ne quittent jamais votre infrastructure.
- **Entrées au-delà des pages web.** MarkItDown convertit Word, Excel, PowerPoint, EPub et d'autres formats, ce qu'une API de lecture web ne fait pas.
- **Compatibilité de licence.** Les outils Apache-2.0 et MIT autorisent les produits fermés ; le cœur AGPL-3.0 de Firecrawl vous demande de partager les modifications si vous l'offrez comme service réseau.

## Quand une API hébergée est-elle le meilleur choix ?

Achetez des pages plutôt que d'exploiter des serveurs quand votre charge est irrégulière, que votre équipe est réduite, ou que le lecteur est un outil au sein d'un agent plutôt qu'un produit à part entière.

- **Volume irrégulier ou saisonnier.** Un crawl deux fois par an ne justifie pas une flotte de navigateurs. Avec WebReaderAPI, Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.
- **Agents.** Un endpoint hébergé se branche sur MCP, LangChain ou les outils OpenAI en quelques minutes ; voir [notre serveur MCP](https://webreaderapi.com/fr/docs/mcp/).
- **Une politique que vous n'avez pas à construire.** Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous.
- **Paiement sans carte.** WebReaderAPI accepte BTC, USDT, USDC, ETH, SOL, LTC sans KYC.

## Puis-je combiner les deux ?

Oui, et beaucoup d'équipes le font. Faites tourner un convertisseur open source pour les fichiers que vous possédez déjà, comme les PDF et les documents Office avec MarkItDown, et appelez un lecteur hébergé pour les pages web en direct, surtout les pages JavaScript qui exigeraient sinon vos propres navigateurs.

Gardez le même format de sortie des deux côtés, du Markdown avec une URL source et un titre, pour que votre code de chunking et d'indexation n'ait pas à savoir d'où vient un document. Notre [guide RAG](https://webreaderapi.com/fr/use-cases/rag/) montre ce format en pratique.

## Combien coûte un lecteur hébergé avec WebReaderAPI ?

Des crédits par page payés en crypto, au 22 octobre 2026 : 1 crédit par page statique, 2 avec un navigateur, rien pour les pages en échec ou refusées. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Auto-héberger un lecteur web : questions fréquentes

### Crawl4AI est-il gratuit pour un usage commercial ?

Son README indique une licence Apache-2.0, qui autorise l'usage commercial, et ajoute que les utilisateurs doivent inclure une attribution, sous forme de badge ou de ligne de texte. Lisez vous-même la licence et le README avant de livrer.

### Crawl4AI respecte-t-il robots.txt ?

Seulement si vous le demandez. Son paramètre `check_robots_txt` vaut False par défaut ; passez-le à True pour vérifier et mettre en cache les règles robots.txt avant le crawl. Vous pouvez aussi définir ou randomiser le user agent, c'est donc votre propre politique qui décide de son comportement.

### Puis-je auto-héberger Firecrawl à la place de Crawl4AI ?

Oui. Le cœur de Firecrawl est open source sous AGPL-3.0 et respecte robots.txt par défaut. L'AGPL vous demande de publier les modifications lorsque vous offrez le logiciel comme service réseau, ce qui compte pour les produits commerciaux.

### Quel outil convertit les PDF et les fichiers Office ?

Microsoft MarkItDown, sous licence MIT, convertit les PDF, Word, PowerPoint, Excel, HTML, EPub et d'autres formats en Markdown. Il ne rend pas les pages JavaScript. WebReaderAPI lit les PDF depuis une URL, jusqu'à 100 pages.

### Combien coûte Crawl4AI Cloud ?

Au 22 octobre 2026 : Starter à 10 $ par mois pour 10 000 crédits, Builder à 99 $ pour 125 000 et Scale à 499 $ pour 750 000, avec une page statique à 0,5 crédit et une page navigateur à 1. Le site indique que ces prix relèvent d'un lancement progressif susceptible de changer.

## Sources

1. [dépôt unclecode/crawl4ai](https://github.com/unclecode/crawl4ai) — GitHub (read 2026-10-22)
2. [Paramètres Crawl4AI](https://docs.crawl4ai.com/api/parameters/) — Crawl4AI docs (read 2026-10-22)
3. [auto-hébergement Crawl4AI](https://docs.crawl4ai.com/core/self-hosting/) — Crawl4AI docs (read 2026-10-22)
4. [crawl4ai sur PyPI](https://pypi.org/project/crawl4ai/) — PyPI (read 2026-10-22)
5. [Crawl4AI Cloud](https://crawl4ai.com/) — Crawl4AI (read 2026-10-22)
6. [dépôt microsoft/markitdown](https://github.com/microsoft/markitdown) — GitHub (read 2026-10-22)
7. [markitdown sur PyPI](https://pypi.org/project/markitdown/) — PyPI (read 2026-10-22)
8. [dépôt adbar/trafilatura](https://github.com/adbar/trafilatura) — GitHub (read 2026-10-22)
9. [dépôt mozilla/readability](https://github.com/mozilla/readability) — GitHub (read 2026-10-22)
10. [dépôt firecrawl/firecrawl](https://github.com/firecrawl/firecrawl) — GitHub (read 2026-10-22)
11. [dépôt jina-ai/reader](https://github.com/jina-ai/reader) — GitHub (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Firecrawl vs Jina Reader (2026) : quel lecteur web pour votre projet ?

> Firecrawl vs Jina Reader en 2026 : crédits par page vs facturation au token, offres gratuites, crawl, extraction JSON et robots.txt.

- URL: https://webreaderapi.com/fr/compare/firecrawl-vs-jina-reader/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Firecrawl et Jina Reader sont les deux noms qui reviennent en premier quand les développeurs cherchent comment transformer des pages web en Markdown pour un modèle. Ils facturent, crawlen et traitent robots.txt différemment. Cette page les compare sur les mêmes faits, avec notre propre service dans une colonne séparée et identifiée.

**Réponse rapide — Firecrawl ou Jina Reader : lequel utiliser ?**

Utilisez Firecrawl pour des pipelines complets : il facture 1 crédit par page avec le rendu inclus, crawle et mappe les sites, et extrait du JSON selon un schéma, sur des offres de 19 $ à 749 $ par mois (22 octobre 2026). Utilisez Jina Reader pour des lectures rapides : préfixez une URL avec r.jina.ai, payez 50 $ par milliard de tokens en sortie, ou rien à 20 requêtes par minute. **WebReaderAPI**, qui publie cette page, vend des crédits par page en crypto sans KYC.

## Firecrawl vs Jina Reader, avec WebReaderAPI pour référence

Chaque ligne provient des pages du fournisseur lui-même, lues le 22 octobre 2026. La troisième colonne est notre service, publié par un concurrent des deux.

|  | Firecrawl | Jina Reader | WebReaderAPI (le nôtre) |
| --- | --- | --- | --- |
| Unité de facturation | Crédits : 1 par page, rendu inclus | Tokens de sortie | Crédits : 1 par page, 2 avec un navigateur |
| Prix d'entrée | Hobby : 19 $ par mois pour 5 000 crédits | 50 $ pour 1 Md de tokens | 3,75 $US pour 10 000 pages |
| Volumes plus importants | Standard à 99 $ pour 100 K ; Scale à 749 $ pour 1 M par mois | 500 $ pour 11 Md de tokens | 74,25 $US pour 1 000 000 pages |
| Usage gratuit | 1 000 crédits par mois, sans carte ; MCP sans clé, plafonné par IP chaque jour | Sans clé à 20 requêtes par minute ; 10 M de tokens par nouvelle clé, usage non commercial | Aucune |
| Crédits non utilisés | Les crédits du forfait sont réinitialisés chaque mois | Validité non indiquée dans le texte que nous avons pu lire | N'expirent jamais |
| Crawl et map | Crawl (limite par défaut 10 000 pages) et map | Aucun endpoint de crawl indiqué | Crawl jusqu'à 10 000 pages ; pas de map |
| Extraction structurée | JSON avec un schéma, +4 crédits par page | Schéma JSON ou en-têtes d'instruction | Non proposé |
| robots.txt | Respecté par défaut ; désactivation réservée aux offres Enterprise | En-tête `X-Robots-Txt` optionnel | Toujours respecté |
| Paiement | Cartes, cartes de débit, PayPal (Stripe) | Cartes, Google Pay, PayPal (Stripe) | BTC, USDT, USDC, ETH, SOL, LTC |
| Open source | Cœur sous AGPL-3.0 | Branche Reader sous Apache-2.0 | Non |
| Entreprise | Firecrawl ; 75 M$ levés en Série B le 22 septembre 2026 | Jina AI, membre du groupe Elastic depuis octobre 2025 | SerpGoat LLC |

*Prix vérifiés le 22 octobre 2026.*

Sources en bas de page.

## Lequel coûte le moins cher par page ?

Cela dépend de la longueur des pages et du volume, car les deux facturent en unités différentes. Firecrawl facture à la page : 0,99 $ par 1 000 pages en offre Standard, 0,749 $ en offre Scale avec facturation mensuelle, rendu inclus. Jina facture au token de sortie et ne publie aucune moyenne par page.

En **estimation, en supposant 5 000 tokens par page**, Jina revient à environ 0,25 $ par 1 000 pages avec son pack à 50 $ et à 0,225 $ avec le pack à 500 $. Sur cette hypothèse, Jina coûte moins cher par page que Firecrawl à tous les volumes. Pour des pages bien plus longues que 5 000 tokens, comme de longues pages de documentation, l'écart se réduit voire s'inverse ; pour des pages courtes, il se creuse. L'extraction JSON de Firecrawl ajoute 4 crédits par page, ce qui change la comparaison pour les travaux d'extraction.

## Lequel est le meilleur pour crawler un site entier ?

Firecrawl. Son endpoint crawl suit le sitemap par défaut, accepte une limite de pages (10 000 par défaut) et une profondeur de découverte, et renvoie 402 si vos crédits ne couvrent pas la limite. Un endpoint map distinct liste les URL d'un site pour un crédit par appel.

Jina Reader est un lecteur mono-URL doublé d'un endpoint de recherche ; ses pages ne mentionnent aucune fonction de crawl. Pour lire un site entier avec Jina, vous collectez vous-même les URL, par exemple depuis le sitemap, et appelez le lecteur une fois par page.

## Comment traitent-ils robots.txt et les propriétaires de sites ?

Firecrawl respecte robots.txt par défaut et seul les clients Enterprise peuvent désactiver ce comportement ; les propriétaires de sites l'autorisent ou le refusent avec le token `FirecrawlAgent`. Sa documentation prévient que ce token peut ne pas être l'en-tête User-Agent de la requête elle-même.

Jina vérifie robots.txt lorsque la requête porte l'en-tête `X-Robots-Txt`, qui indique le bot à vérifier. Il permet aussi à l'appelant de remplacer le User-Agent du navigateur. Ses pages n'indiquent pas la valeur par défaut dans un cas comme dans l'autre. Les deux approches laissent une grande part du choix au client ; la nôtre non, comme l'explique la section suivante.

## Lequel convient le mieux aux agents IA ?

Les deux servent bien les agents, chacun à sa manière. Firecrawl propose un serveur MCP hébergé, un accès sans clé avec un plafond quotidien par IP et une longue liste d'intégrations, dont LangChain, LlamaIndex, CrewAI et n8n ; OpenClaw intègre Firecrawl comme fournisseur web_fetch.

Jina propose un serveur MCP distant officiel dont l'outil `read_url` lit jusqu'à cinq URL par appel, un credential n8n et un préfixe d'URL utilisable par tout outil capable d'envoyer une requête GET. Pour un agent qui lit quelques pages par tâche, le préfixe de Jina est le point de départ le plus simple ; pour un agent qui crawle, cartographie et extrait, Firecrawl couvre plus de cas.

## Où se situe WebReaderAPI entre les deux ?

WebReaderAPI est plus proche de Jina par son périmètre, un lecteur, et plus proche de Firecrawl par sa facturation, à la page, avec un endpoint crawl pour les sites entiers. Ce qui le distingue, c'est le paiement et la politique plutôt que la liste des fonctionnalités :

- **Crypto sans KYC.** Rechargez depuis 25 $US en BTC, USDT, USDC, ETH, SOL, LTC.
- **Des crédits qui n'expirent jamais**, vendus en packs à partir de 3,75 $US.
- **Une politique fixe pour les sites.** Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

Il fait moins que Firecrawl : pas d'extraction JSON, pas d'actions navigateur, pas de map, pas d'offre gratuite. Consultez les pages [alternative à Firecrawl](https://webreaderapi.com/fr/alternatives/firecrawl/) et [alternative à Jina Reader](https://webreaderapi.com/fr/alternatives/jina-reader/) pour le détail de chaque bascule.

## Lequel choisir pour mon cas d'usage ?

- **Agent prototype ou de loisir :** Jina Reader sans clé, ou l'offre gratuite de Firecrawl.
- **RAG sur des sites de documentation :** Firecrawl pour le crawl et le map ; WebReaderAPI si vous voulez des crédits à la page qui ne périment pas et un paiement en crypto.
- **Extraction vers des champs fixes :** le format JSON de Firecrawl.
- **Beaucoup de pages courtes d'actualité ou de blog :** la facturation au token de Jina tend à coûter moins cher.
- **Respect strict des choix des propriétaires de sites, appliqué par le fournisseur :** WebReaderAPI.
- **Sans carte bancaire ni pièce d'identité :** WebReaderAPI ; ni Firecrawl ni Jina ne mentionne d'option de paiement en crypto sur les pages que nous avons lues.

## Combien coûte la troisième option ?

Des packs à la page payés en crypto, au 22 octobre 2026. Une page qui nécessite un navigateur consomme deux crédits ; les pages en échec et les pages refusées par robots.txt sont gratuites.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Firecrawl vs Jina Reader : questions fréquentes

### Jina Reader est-il gratuit et Firecrawl payant ?

Les deux ont un usage gratuit. Jina Reader fonctionne sans clé à 20 requêtes par minute, et chaque nouvelle clé donne 10 millions de tokens pour un usage non commercial. Firecrawl offre 1 000 crédits par mois sans carte, plus un accès MCP sans clé plafonné par adresse IP chaque jour.

### Lequel renvoie un meilleur Markdown ?

Nous ne publions aucun benchmark de qualité, et la page tarifaire d'aucun des deux fournisseurs ne revendique une supériorité sur l'autre. Faites votre propre test : 50 de vos URL réelles dans chaque service, puis comparez les titres, les tableaux et les menus résiduels dans la sortie.

### Peut-on les héberger soi-même ?

Oui. Le cœur de Firecrawl est open source sous AGPL-3.0. Jina publie une branche open source de son Reader sous Apache-2.0, sans la couche de stockage hébergée.

### Firecrawl ou Jina acceptent-ils la crypto ?

Pas sur les pages de tarifs et de facturation que nous avons lues le 22 octobre 2026 : les deux citent Stripe, avec cartes et PayPal, et Jina ajoute Google Pay. WebReaderAPI accepte BTC, USDT, USDC, ETH, SOL, LTC.

### Cette comparaison est-elle neutre ?

Elle est rédigée par WebReaderAPI, concurrent des deux, et le dit en haut de page. Chaque fait sur Firecrawl et Jina provient de leurs propres pages, listées ci-dessous avec la date à laquelle nous les avons lues.

## Sources

1. [Tarifs de Firecrawl](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
2. [Facturation](https://docs.firecrawl.dev/billing.md) — Firecrawl docs (read 2026-10-22)
3. [Crawl](https://docs.firecrawl.dev/features/crawl.md) — Firecrawl docs (read 2026-10-22)
4. [Guide avancé de scraping](https://docs.firecrawl.dev/advanced-scraping-guide.md) — Firecrawl docs (read 2026-10-22)
5. [Serveur MCP](https://docs.firecrawl.dev/mcp-server.md) — Firecrawl docs (read 2026-10-22)
6. [Présentation d'Alexandria et de notre Série B](https://www.firecrawl.dev/blog/introducing-alexandria-series-b) — Firecrawl (read 2026-10-22)
7. [Reader](https://jina.ai/reader/) — Jina AI (read 2026-10-22)
8. [Tableau de bord API : tarifs](https://jina.ai/api-dashboard/pricing/) — Jina AI (read 2026-10-22)
9. [dépôt jina-ai/MCP](https://github.com/jina-ai/MCP) — GitHub (read 2026-10-22)
10. [Elastic finalise l'acquisition de Jina AI](https://ir.elastic.co/News--Events/news/news-details/2025/Elastic-Completes-Acquisition-of-Jina-AI-a-Leader-in-Frontier-Models-for-Multimodal-and-Multilingual-Search/default.aspx) — Elastic (2025-10-09, read 2026-10-22)
11. [Outils web](https://docs.openclaw.ai/tools/web) — OpenClaw docs (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Tarifs des API de web reader comparés : ce que coûtent 10K, 100K et 1M de pages

> Tarifs des API de web reader et URL-vers-Markdown comparés le 2026-10-22 : facture mensuelle pour 10K, 100K et 1M de pages chez 13 API, pages simples et JS.

- URL: https://webreaderapi.com/fr/compare/web-reader-api-pricing/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Les prix au crédit masquent la taille des plans, les multiplicateurs navigateur et l'expiration. Cette page transforme les prix catalogue publics en facture mensuelle pour trois volumes, pour les pages simples et pour les pages qui nécessitent un navigateur, puis liste les coûts que les pages de tarification passent sous silence.

**Réponse rapide — Comment les prix des API de lecture de pages web se comparent-ils en 2026 ?**

Le 2026-10-22, 100 000 pages rendues par navigateur par mois coûtaient 99 $ chez huit API, dont Firecrawl, Olostep et Crawl4AI Cloud ; les pages simples coûtaient à partir de 29 $ (Scrape.do). À 1 million de pages, les pages simples démarrent autour de 99 $ et les pages navigateur à 399 $ (Olostep). **WebReaderAPI** facture 21,75 $US pour 100 000 pages simples et 43,50 $ si toutes nécessitent un navigateur, payés en crypto sans KYC.

## Combien coûte un mois de pages chez chaque API ?

Facture mensuelle pour 10 000, 100 000 et 1 000 000 de pages, en utilisant le plan publié le moins cher, le tarif de dépassement ou le paiement à l'usage. Lorsqu'un fournisseur tarifie différemment les pages navigateur, les deux chiffres sont affichés (simple / navigateur).

| API | 10 000 pages | 100 000 pages | 1 000 000 pages |
| --- | --- | --- | --- |
| WebReaderAPI, pages simples | 3,75 $US | 21,75 $US | 74,25 $US |
| WebReaderAPI, pages navigateur (2 crédits) | $7.50 | $43.50 | $148.50 |
| Firecrawl | $44.00 | $99.00 | $749.00 |
| Crawl4AI Cloud, simple / navigateur | $10.00 | $50.00 / $99.00 | $395.00 / $667.00 |
| Olostep | $29.00 | $99.00 | $399.00 |
| Tavily Extract, simple / navigateur | $16.00 / $30.00 | $140.00 / $236.00 | $1,300 / $2,900 |
| Exa contents | $10.00 | $100.00 | $1,000 |
| Linkup fetch, simple / navigateur | $10.00 / $50.00 | $100.00 / $500.00 | $1,000 / $5,000 |
| ScrapingBee, simple / navigateur | $19.00 | $49.00 / $99.00 | $99.00 / $599.00 |
| Scrape.do, simple / navigateur | $29.00 | $29.00 / $99.00 | $99.00 / $699.00 |
| ZenRows, simple / navigateur | $5.00 / $25.00 | $39.00 / $99.00 | $199.00 / $549.00 |
| Scrapfly, simple / navigateur | $30.00 | $30.00 / $100.00 | $100.00 / $560.00 |
| Bright Data Web Unlocker | $15.00 | $150.00 | $1,300 |
| Diffbot | $299.00 | $299.00 | $899.00 |

*Prix vérifiés le 22 octobre 2026.*

Prix catalogue en USD, relevés le 2026-10-22. « — » = non publié ou non disponible en libre-service à ce volume. Exa et Parallel ne documentent aucune option navigateur. Méthode complète et 21 API : [URL to Markdown API price index 2026](https://webreaderapi.com/fr/data/url-to-markdown-price-index-2026/).

## Quels coûts les pages de tarification passent-elles sous silence ?

1. **Multiplicateurs navigateur.** Une page JavaScript coûte 5 crédits chez ScrapingBee, ZenRows et Scrape.do, 6 chez Scrapfly et 10 chez ScraperAPI ; Firecrawl et Olostep rendent chaque page à un seul prix.
2. **Paliers de plan.** Un plan à 99 $ acheté pour 20 000 pages coûte toujours 99 $.
3. **Expiration.** La plupart des plans mensuels remettent à zéro les crédits non utilisés ; un mois calme, c'est de l'argent perdu.
4. **Options d'extraction.** L'extraction JSON structurée coûte un supplément chez plusieurs API : 4 crédits de plus par page chez Firecrawl.
5. **Connexions premium.** Les proxies résidentiels ou « premium » multiplient le coût en crédits chez la plupart des API de scraping ; WebReaderAPI ajoute 10 crédits uniquement quand vous choisissez un pays.
6. **Pages en échec.** Vérifiez si les erreurs sont facturées. WebReaderAPI ne facture rien pour les pages en échec ni pour les pages refusées par robots.txt.

## Où se situe WebReaderAPI ?

Aux prix indiqués sur cette page, fixés le 2026-10-22, WebReaderAPI facture 0,38 $US/1K pages par page simple à 10 000 pages, 0,22 $US/1K pages à 100 000 et 0,07 $US/1K pages à 1 million ; une page navigateur utilise deux crédits. Les crédits sont prépayés, n'expirent jamais et se paient en BTC, USDT, USDC, ETH, SOL, LTC sans KYC.

Nous ne prétendons pas être les moins chers à tous les volumes ni pour tous les types de pages. Notre crawler respecte robots.txt et ne cherche jamais à contourner un refus, donc certaines pages que d'autres outils récupèrent reviendront refusées, et gratuites.

## Combien coûte WebReaderAPI ?

Packs prépayés ; un crédit par page simple, deux avec un navigateur ; les crédits n'expirent jamais. Prix fixés le 2026-10-22.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Tarifs des API de lecture de pages web : questions fréquentes

### Quelle est l'API URL to Markdown la moins chère en 2026 ?

Pour les pages simples à 1 million par mois, ScrapingBee (0,099 $ pour 1 000) et Scrape.do (0,099 $ pour 1 000) affichaient les prix les plus bas le 2026-10-22. Pour les pages navigateur à ce volume, Olostep affichait 0,399 $. La réponse change selon le volume, alors comparez à votre propre volume.

### Firecrawl est-il cher ?

À faible volume, oui : 19 $ pour 5 000 pages en Hobby, soit 3,80 $ pour 1 000. À 100 000 pages (99 $) et 1 million (749 $), il se situe près du marché pour les pages rendues par navigateur, car chaque page Firecrawl est rendue.

### Paié-je pour les pages en échec ?

Cela dépend du fournisseur ; lisez sa page de facturation. Crawlbase indique que les requêtes en échec et les nouvelles tentatives sont gratuites. WebReaderAPI ne facture pas les pages en échec ni les pages refusées par robots.txt.

### Puis-je payer une API de lecture de pages web en crypto ?

Oui, chez quelques-unes. Scrape.do, Decodo Web Data API, Scrapeless indiquent le paiement en crypto sur un compte, et Exa contents, Parallel Extract, Linkup fetch, Olostep et d'autres acceptent des USDC par requête via x402. WebReaderAPI accepte BTC, USDT, USDC, ETH, SOL, LTC sans KYC.

## Sources

1. [Firecrawl : tarifs](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
2. [Crawl4AI Cloud : tarifs](https://crawl4ai.com/) — Crawl4AI Cloud (read 2026-10-22)
3. [Olostep : tarifs](https://www.olostep.com/pricing) — Olostep (read 2026-10-22)
4. [Tavily Extract : tarifs](https://docs.tavily.com/documentation/api-credits) — Tavily Extract (read 2026-10-22)
5. [Exa contents : tarifs](https://exa.ai/pricing) — Exa contents (read 2026-10-22)
6. [Linkup fetch : tarifs](https://docs.linkup.so/pages/documentation/development/pricing) — Linkup fetch (read 2026-10-22)
7. [ScrapingBee : tarifs](https://www.scrapingbee.com/pricing/) — ScrapingBee (read 2026-10-22)
8. [Scrape.do : tarifs](https://scrape.do/pricing.md) — Scrape.do (read 2026-10-22)
9. [ZenRows : tarifs](https://docs.zenrows.com/first-steps/pricing.md) — ZenRows (read 2026-10-22)
10. [Scrapfly : tarifs](https://scrapfly.io/pricing) — Scrapfly (read 2026-10-22)
11. [Bright Data Web Unlocker : tarifs](https://www.bright.cn/pricing/web-unlocker) — Bright Data Web Unlocker (read 2026-10-22)
12. [Diffbot : tarifs](https://www.diffbot.com/pricing/) — Diffbot (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Contacter WebReaderAPI

> Contacter WebReaderAPI : e-mail du support pour l'API et la facturation, e-mail d'abus pour les sites et signalements, et quoi inclure pour une réponse rapide.

- URL: https://webreaderapi.com/fr/contact/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Deux adresses : une pour les clients, une pour les propriétaires de sites et les signalements de mauvais usage. Les deux sont lues par une personne.

**Réponse rapide — Comment contacter WebReaderAPI ?**

Écrivez à support@webreaderapi.com pour toute aide sur l'API, votre compte ou un paiement ; L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations. Les propriétaires de sites et toute personne signalant un mauvais usage du crawler **WebReaderAPI** peuvent écrire à abuse@webreaderapi.com. Notre équipe ne vous demandera jamais votre numéro de compte ni une clé API par email ou par chat.

## Qu'est-ce qui rend une demande de support rapide à traiter ?

Un message court et factuel obtient la réponse la plus rapide :

- l'order ID figurant dans l'historique de vos commandes, pour les questions de facturation ;
- l'heure de la requête, l'endpoint et le code d'erreur, pour les problèmes d'API ;
- l'URL que vous avez essayé de lire, si une page ne s'est pas renvoyée comme prévu.

N'envoyez jamais votre clé API ni votre numéro de compte par e-mail.

## Je gère un site web. Comment vous joindre ?

Écrivez à abuse@webreaderapi.com en indiquant votre domaine, la date et l'heure, et une ligne de votre journal serveur montrant le User-Agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`. Pour arrêter notre crawler sans nous écrire, ajoutez une règle pour `WebReaderAPI` dans votre robots.txt ; la [page du bot](https://webreaderapi.com/fr/bot/) contient des exemples prêts à l'emploi. Une personne lit chaque signalement d'abus, et les comptes qui utilisent le service de manière abusive sont suspendus.

## En quoi le support peut-il m'aider ?

Pour tout ce qui concerne l'utilisation de l'API ou de votre compte :

- une page qui revient vide, tronquée ou avec la mauvaise section conservée comme extraction du contenu principal ;
- un code d'erreur que vous ne comprenez pas, ou un crawl qui s'arrête trop tôt ;
- une recharge qui n'apparaît pas sur votre solde après ses confirmations ;
- une demande de remboursement au titre de la [politique de remboursement](https://webreaderapi.com/fr/refunds/) ;
- une limite de concurrence plus élevée pour un usage en production.

Le support ne peut pas obliger un site à accepter notre crawler. Quand un site nous refuse, la seule voie possible est l'autorisation du propriétaire du site.

## Comment signaler un problème de paiement ?

Indiquez la crypto-monnaie, le réseau, le montant envoyé et l'ID de transaction, ainsi que l'order ID figurant dans l'espace client. Cela suffit pour retrouver n'importe quel transfert sur la blockchain. N'incluez ni clés privées, ni phrases de récupération, ni votre numéro de compte, ni votre clé API : nous n'en avons jamais besoin, et quiconque vous les demande n'est pas nous.

## Y a-t-il un chat ou une ligne téléphonique ?

Non. L'e-mail laisse une trace écrite pour les deux parties et nous permet de répondre précisément, journaux à l'appui. Pour l'état de l'API, consultez la [page de statut](https://webreaderapi.com/fr/status/) ; pour les questions courantes, la [FAQ](https://webreaderapi.com/fr/faq/).

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Crawl API : transformer un site web entier en fichiers Markdown

> Crawl API qui transforme un site web entier en Markdown pour le RAG : jusqu'à 10 000 pages par job, à partir de 0,07 $US/1K pages.

- URL: https://webreaderapi.com/fr/crawl-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Indiquez une URL de départ et une limite de pages. Le crawler suit le sitemap du site et les liens au sein du même domaine, lit chaque page en Markdown et vous remet les résultats page par page. Un crédit par page.

**Réponse rapide — Comment explorer un site web entier et obtenir chaque page en Markdown ?**

Utilisez une crawl API : vous envoyez une URL de départ et une limite, et elle renvoie chaque page du site en Markdown. **WebReaderAPI** explore jusqu'à 10 000 pages par job au sein d'un même domaine, suit le sitemap, robots.txt et le Crawl-delay, et facture un crédit par page lue, à partir de 0,07 $US/1K pages en octobre 2026. Les pages refusées par robots.txt sont gratuites. Sans KYC ; payer en crypto.

## La crawl API en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Lancer un crawl | `POST https://webreaderapi.com/api/v1/crawl` avec `url`, `limit`, `max_depth`, `include_paths`, `exclude_paths` |
| Récupérer les résultats | `GET https://webreaderapi.com/api/v1/jobs/{job_id}`, paginés avec un cursor |
| Portée | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay |
| De nombreuses URL distinctes | `POST https://webreaderapi.com/api/v1/batch` : Jusqu'à 100 URLs par job batch |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Propriétaires de sites | Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées |
| Prix | 14,25 $US pour 50 000 pages, 50 $US pour 500 000 pages |

## Comment fonctionne une tâche de crawl ?

Un crawl est une tâche en arrière-plan, car lire des centaines de pages prend plus de temps qu'une seule requête HTTP ne devrait en prendre.

1. **Démarrage :** `POST https://webreaderapi.com/api/v1/crawl` avec l'URL de départ et vos limites. Vous recevez immédiatement un `job_id`.
2. **Découverte :** le crawler lit le robots.txt et le sitemap du site, puis suit les liens au sein du même domaine, en largeur d'abord, jusqu'à `max_depth`.
3. **Lecture :** chaque page autorisée est lue avec les mêmes options que `/read` : Markdown, extraction du contenu principal, rendu si nécessaire.
4. **Collecte :** interrogez `GET https://webreaderapi.com/api/v1/jobs/{job_id}` et parcourez les résultats avec le curseur pendant que la tâche s'exécute, ou une fois qu'elle est `done`.

La tâche s'arrête à votre `limit`, vous ne payez donc jamais pour plus de pages que demandé.

*Python : crawler un site de documentation en fichiers Markdown*

```python
import os
import pathlib
import re
import time

import requests

API = "https://webreaderapi.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}

job = requests.post(
    API + "/crawl",
    headers=HEADERS,
    json={"url": "https://docs.example.com/", "limit": 500, "max_depth": 4, "include_paths": ["/guide/*"]},
    timeout=60,
).json()

out = pathlib.Path("docs_md")
out.mkdir(exist_ok=True)
cursor, delay = None, 5
while True:
    params = {"cursor": cursor} if cursor else {}
    page = requests.get(API + "/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=60).json()
    for item in page.get("results", []):
        if "markdown" in item:
            name = re.sub(r"[^a-z0-9]+", "-", item["url"].lower()).strip("-")[:120]
            (out / (name + ".md")).write_text(item["markdown"], encoding="utf-8")
    cursor = page.get("next_cursor")
    if page["status"] == "done" and not cursor:
        break
    if not cursor:
        time.sleep(delay)
        delay = min(delay * 2, 60)
print("credits used:", page.get("credits_used"))

```

## Quelles pages le crawler visite-t-il, et lesquelles ignore-t-il ?

Il reste dans le domaine de l'URL de départ et ignore tout ce que le site demande aux robots de laisser tranquille. En détail :

- **Même domaine uniquement.** Les liens vers d'autres domaines sont listés dans les résultats mais pas lus.
- **robots.txt d'abord.** Les pages interdites pour `WebReaderAPI` ou pour tous les robots sont ignorées et non facturées.
- **Crawl-delay respecté.** Si le site en définit un, le crawler attend ce délai entre deux pages, un grand site peut donc prendre plus de temps.
- **Vos filtres.** `include_paths` et `exclude_paths` acceptent des motifs simples comme `/blog/*` ; utilisez-les pour éviter les pages de tags, les pages de recherche et les archives.
- **Doublons supprimés.** Une même page atteinte par deux URL, par exemple avec des paramètres de suivi, est lue une seule fois lorsque le site déclare une URL canonique.

## Dois-je utiliser un crawl ou un batch ?

Utilisez un crawl quand vous connaissez le site mais pas les pages ; utilisez un batch quand vous avez déjà la liste des URL. Un crawl découvre les pages à partir du sitemap et des liens. Un batch lit exactement les URL que vous envoyez, jusqu'à 100 par tâche, sur n'importe quel nombre de sites.

Pour une actualisation hebdomadaire d'une base de connaissances, un schéma courant consiste en un crawl pour construire l'index, puis des batchs des pages dont le `lastmod` a changé dans le sitemap. Le coût hebdomadaire se limite ainsi aux pages qui ont réellement bougé.

## Combien coûte le crawl d'un site ?

Un crédit par page lue, deux pour les pages ayant nécessité un navigateur. Un site de documentation de 1 500 pages qui est rendu côté serveur coûte 1 500 crédits ; le même site construit en single-page app peut coûter jusqu'à 3 000.

Trois tâches typiques, en octobre 2026 : un manuel produit de 300 pages tient dans le pack 10 000 pages (3,75 $US) ; dix sites de documentation de 2 000 pages chacun tiennent dans 50 000 pages (14,25 $US) ; une archive de 400 000 pages tient dans 500 000 pages (50 $US). Les pages ignorées et en échec sont gratuites.

## Quel pack convient à un crawl ?

Dimensionnez le pack sur le nombre de pages, puis ajoutez une marge pour les pages qui nécessitent un navigateur. Les crédits n'expirent jamais, le reste sert donc au crawl suivant.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Scale | 500 000 pages | 50 $US | 0,10 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## API de crawl : questions fréquentes

### Combien de pages un crawl peut-il lire ?

Jusqu'à 10 000 pages par tâche, au sein du domaine de l'URL de départ. Pour un site plus grand, découpez-le en plusieurs tâches avec `include_paths`, par exemple une par section.

### Le crawler utilise-t-il le sitemap ?

Oui. Il lit le sitemap indiqué dans robots.txt ou à l'emplacement habituel, puis suit les liens des pages qu'il lit. Les pages listées uniquement dans le sitemap sont tout de même lues si robots.txt les autorise.

### Puis-je crawler un site qui bloque les crawlers d'IA ?

Non, pas avec WebReaderAPI. Si robots.txt interdit notre crawler ou tous les robots, ces pages sont ignorées et non facturées. Si le site déclare `Content-Signal: ai-input=no`, nous ne le lisons pas pour vous. Nous ne cherchons jamais à contourner ces choix.

### Puis-je obtenir les résultats pendant que le crawl s'exécute encore ?

Oui. `GET https://webreaderapi.com/api/v1/jobs/{job_id}` renvoie les pages lues jusqu'ici avec un curseur ; continuez à paginer jusqu'à ce que la tâche soit `done` et qu'il ne reste plus de curseur.

### Un crawl peut-il lire plus de pages que ma limite ?

Non. Les crédits sont comptés page par page, et la tâche s'arrête lorsqu'elle atteint la `limit` que vous avez définie. Les pages ignorées à cause de robots.txt et les pages en échec ne consomment aucun crédit.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Payer une API web reader en crypto

> Comment payer WebReaderAPI en crypto : BTC, USDT, USDC, ETH, SOL ou LTC, le rechargement minimum de 25 $US, quel réseau choisir, et que faire après l'envoi.

- URL: https://webreaderapi.com/fr/crypto-payments/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un guide étape par étape pour recharger votre solde WebReaderAPI en crypto et le convertir en crédits de pages, avec les erreurs à éviter.

**Réponse rapide — Comment payer WebReaderAPI en crypto ?**

Rechargez votre solde **WebReaderAPI** avec au moins 25 $US en BTC, USDT, USDC, ETH, SOL, LTC : envoyez le montant exact indiqué, sur le réseau indiqué, puis cliquez sur « J'ai envoyé le paiement ». Le rechargement est identifié par son montant exact et crédité une fois confirmé. Vous achetez ensuite des crédits de pages depuis le solde, à partir de 3,75 $US pour 10 000 pages. Sans KYC.

## Avec quelles coins puis-je payer ?

Six coins, un seul solde. USDT fonctionne sur TRC-20 ou ERC-20, USDC sur ERC-20 ; la page de paiement affiche l'adresse et le réseau pour la coin que vous choisissez.

- Bitcoin (BTC)
- Tether (USDT) — TRC-20 or ERC-20
- USD Coin (USDC) — ERC-20
- Ethereum (ETH)
- Solana (SOL)
- Litecoin (LTC)

## Comment fonctionne un rechargement en crypto, étape par étape ?

Cinq étapes d'un compte vide à une clé API fonctionnelle. La seule attente est la confirmation sur la blockchain.

1. **Choisir un montant et une coin** — Saisissez au moins 25 $US et choisissez BTC, USDT, USDC, ETH, SOL ou LTC. La page de paiement convertit le montant en dollars dans cette coin.
2. **Envoyer le montant exact** — Copiez l'adresse et le montant indiqués, et envoyez-les sur le réseau nommé par la page : un seul transfert, le montant exact, sans arrondi.
3. **Cliquer sur « J'ai envoyé le paiement »** — Indiquez à la page que le transfert est en route. Si elle demande l'ID de transaction, collez-le pour faciliter la recherche du transfert.
4. **Laissez le réseau le confirmer** — Le rechargement est apparié par son montant exact et crédité une fois que le réseau l'a confirmé. Bitcoin demande plus de temps que USDT sur Tron ou SOL sur Solana.
5. **Acheter un pack de crédits** — Payez n'importe quel pack depuis le solde. Si vous êtes parti d'un pack, il est acheté une fois le rechargement crédité, et votre clé API apparaît dans le dashboard.

## Quelle crypto et quel réseau dois-je utiliser ?

Utilisez la crypto que vous détenez déjà, sur le réseau indiqué sur la page de paiement. Un stablecoin (USDT ou USDC) maintient le montant en dollars, donc le prix que vous voyez est le prix que vous payez. Les frais de réseau et les délais de confirmation varient selon la chaîne ; le tableau dans les étapes ci-dessus donne le délai de confirmation habituel pour chaque réseau.

Si vous détenez du USDT sur plusieurs chaînes, choisissez celle dont les frais sont les plus faibles pour votre montant. Les frais sont payés par l'expéditeur et ne font pas partie de votre rechargement.

## Pourquoi y a-t-il un rechargement minimum ?

Parce que chaque paiement nous coûte une vérification et une comptabilisation, quelle que soit sa taille. Le minimum est de 25 $US ; n'importe quel pack peut ensuite être acheté depuis le solde, y compris le pack 10 000 pages à 3,75 $US.

Ce que vous ne dépensez pas reste sur le solde sans date d'expiration. Si le pack que vous avez acheté coûte moins que le minimum, la partie excédentaire peut être demandée en retour sous 30 jours, en USDT ou USDC, tant qu'elle n'est pas dépensée.

## Que se passe-t-il après l'envoi du paiement ?

Cliquez sur « J'ai envoyé le paiement » sur la page de paiement. Nous apparierons le transfert par son montant exact, attendrons les confirmations nécessaires au réseau et créditerons votre solde. Si vous êtes parti d'un pack, il est acheté depuis le solde une fois le rechargement crédité, et votre clé API est prête dans le dashboard.

Si vous avez fermé l'onglet, ouvrez l'espace client : les rechargements en attente et crédités apparaissent dans l'historique de vos commandes.

## Et si j'envoie le mauvais montant ou utilise le mauvais réseau ?

Un montant différent ne peut pas être apparié tout seul, et un transfert sur un autre réseau peut ne pas atteindre l'adresse du tout. Avant d'envoyer, vérifiez trois choses : la crypto, le réseau et le montant exact.

En cas d'erreur, écrivez à support@webreaderapi.com avec l'ID de transaction et l'ID de commande. N'envoyez pas votre numéro de compte ni votre clé API. Les fonds envoyés sur un réseau que la page de paiement n'affichait pas peuvent être irrécupérables.

## Un paiement en crypto peut-il être remboursé ?

Les remboursements vont sur votre solde plutôt que vers votre wallet, ce qui évite des frais de réseau supplémentaires. Un pack utilisé à moins de 20 % sous 72 heures, ou un pack qui n'a jamais fonctionné, est recrédité. La [politique de remboursement](https://webreaderapi.com/fr/refunds/) en donne les conditions exactes et trois exemples.

## Que puis-je acheter une fois mon solde crédité ?

N'importe quel pack : 10 000 pages pour 3,75 $US, 50 000 pages pour 14,25 $US ou 100 000 pages pour 21,75 $US, et des plus grands sur la [page des tarifs](https://webreaderapi.com/fr/pricing/). Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

Prix en USD, fixés le 2026-10-22. Chaque pack est payé depuis votre solde crypto.

## Payer en crypto : questions fréquentes

### Ai-je besoin d'une carte ou d'une pièce d'identité pour payer ?

Non. WebReaderAPI n'accepte que la crypto et ne demande aucun document d'identité. Connexion par numéro de compte ; l'email est facultatif.

### Le prix est-il fixé au moment où je lance le paiement ?

La page de paiement affiche le montant dans la crypto que vous avez choisie pour ce paiement. Envoyez ce montant exact ; un stablecoin le maintient égal au prix en dollars.

### Puis-je payer les crédits à la requête plutôt que de recharger ?

Non. Les paiements passent par un solde prépayé, et chaque lecture utilise des crédits de ce solde. Le solde et les crédits n'expirent jamais.

### Où puis-je voir mes paiements ?

Dans l'historique des commandes de l'espace client, avec pour chaque rechargement son statut, sa crypto, son réseau et son ID de transaction.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Index des tarifs des API URL to Markdown 2026 : ce que coûtent 1 000 pages chez 21 API

> Tarifs API URL-to-Markdown et reader web 2026 : 21 API, coût pour 1 000 pages à 3 volumes, pages statiques et JavaScript, crypto, KYC. Vérifié le 2026-10-22.

- URL: https://webreaderapi.com/fr/data/url-to-markdown-price-index-2026/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Prix catalogue publics de 21 API qui transforment les pages web en Markdown ou en texte pour les modèles, normalisés en coût pour 1 000 pages à trois volumes mensuels, pour les pages simples et pour les pages rendues dans un navigateur. Publié par WebReaderAPI, qui fait partie des API du tableau.

**Réponse rapide — Combien coûte une API URL-to-Markdown pour 1 000 pages en 2026 ?**

Sur les 21 API dont nous avons relevé les prix catalogue le 2026-10-22, lire 100 000 pages simples par mois coûte une médiane de 0,99 $ pour 1 000 pages, et 1,00 $ quand les pages nécessitent un navigateur. À 1 million de pages par mois, les médianes tombent à 0,774 $ et 0,899 $. **WebReaderAPI**, qui publie cet index, facture 0,22 $US/1K pages pour les pages simples à 100 000.

## L'index en six chiffres

- **$2.00** médiane pour 1 000 pages simples à 10 000 par mois (21 API)
- **$0.99** médiane pour 1 000 pages simples à 100 000 par mois (21 API)
- **$0.774** médiane pour 1 000 pages simples à 1 million par mois (20 API)
- **$1.00** médiane pour 1 000 pages rendues par navigateur à 100 000 par mois (18 API)
- **$0.899** médiane pour 1 000 pages rendues par navigateur à 1 million par mois (17 API)
- **3 + 7** API qui indiquent le paiement en crypto sur un compte, plus les API acceptant l'USDC à la requête (x402)

## Comment l'index a-t-il été construit ?

Nous avons lu la page de tarifs publique de chaque fournisseur le 2026-10-22 et conservé uniquement les chiffres qui y figurent ; chaque source est listée en bas. Une « page » correspond à une URL lue et renvoyée en Markdown ou en texte, avec le proxy par défaut du fournisseur et sans option payante supplémentaire.

- **Page simple :** pas de rendu JavaScript. **Page navigateur :** rendue d'abord dans un navigateur headless ; les fournisseurs qui rendent toujours (Firecrawl, Olostep, Diffbot) affichent le même prix dans les deux tableaux.
- **Prix à un volume :** la façon publiée la moins chère d'acheter ce nombre de pages chaque mois chez un même fournisseur (forfait, forfait plus dépassement publié, ou paiement à l'usage), divisée par le nombre de pages utilisées. Un forfait à 99 $ utilisé pour 100 000 pages compte comme 0,99 $ pour 1 000 pages, même s'il en inclut davantage.
- **Les multiplicateurs de crédits sont appliqués**, par exemple 5 crédits par page navigateur chez ScrapingBee, ZenRows et Scrape.do.
- **Les paliers gratuits sont listés, pas tarifés.** Les API facturées aux tokens, au temps de navigateur, au volume de données ou au calcul, ainsi qu'une API dont nous n'avons pas pu confirmer la sortie Markdown, sont listées séparément.

WebReaderAPI est affiché pour référence et n'entre pas dans les médianes.

## Prix pour 1 000 pages simples, selon le volume mensuel

Pages statiques, lues sans navigateur. « — » signifie non publié ou non disponible en self-serve à ce volume.

| API | 10K pages par mois | 100K pages par mois | 1M pages par mois |
| --- | --- | --- | --- |
| WebReaderAPI (prépayé, sans expiration) | 0,38 $US/1K pages | 0,22 $US/1K pages | 0,07 $US/1K pages |
| Firecrawl | $4.40 | $0.99 | $0.749 |
| Tavily Extract | $1.60 | $1.40 | $1.30 |
| Exa contents | $1.00 | $1.00 | $1.00 |
| Parallel Extract | $1.00 | $1.00 | $1.00 |
| Linkup fetch | $1.00 | $1.00 | $1.00 |
| Olostep | $2.90 | $0.99 | $0.399 |
| ScrapeGraphAI | $2.00 | $1.00 | $1.25 |
| Diffbot | $29.90 | $2.99 | $0.899 |
| ScrapingBee | $1.90 | $0.49 | $0.099 |
| ScraperAPI | $4.90 | $0.49 | $0.149 |
| ZenRows | $0.50 | $0.39 | $0.199 |
| Scrapfly | $3.00 | $0.30 | $0.10 |
| Scrape.do | $2.90 | $0.29 | $0.099 |
| Crawlbase | $2.10 | $0.764 | $0.349 |
| Bright Data Web Unlocker | $1.50 | $1.50 | $1.30 |
| Oxylabs Web Scraper API | $3.00 | $1.00 | $2.50 |
| Decodo Web Data API | $1.90 | $0.49 | $0.249 |
| Scrapeless | $1.00 | $0.90 | $0.80 |
| Hyperbrowser Fetch | $3.00 | $1.00 | — |
| Steel scrape | $5.00 | $5.00 | $5.00 |
| Crawl4AI Cloud | $1.00 | $0.50 | $0.395 |

*Prix vérifiés le 22 octobre 2026.*

Prix catalogue en USD, relevés le 2026-10-22. Nos prix : la page de tarifs WebReaderAPI à la même date.

## Prix pour 1 000 pages rendues par navigateur, selon le volume mensuel

Pages nécessitant JavaScript, rendues dans un navigateur headless. Les API qui ne documentent aucune option navigateur sont exclues de ce tableau.

| API | 10K pages par mois | 100K pages par mois | 1M pages par mois |
| --- | --- | --- | --- |
| WebReaderAPI (2 crédits par page) | 0,75 $/1K pages | 0,435 $/1K pages | 0,148 $/1K pages |
| Firecrawl | $4.40 | $0.99 | $0.749 |
| Tavily Extract | $3.00 | $2.36 | $2.90 |
| Linkup fetch | $5.00 | $5.00 | $5.00 |
| Olostep | $2.90 | $0.99 | $0.399 |
| ScrapeGraphAI | $2.00 | $1.00 | $1.25 |
| Diffbot | $29.90 | $2.99 | $0.899 |
| ScrapingBee | $1.90 | $0.99 | $0.599 |
| ScraperAPI | $4.90 | $1.49 | $0.975 |
| ZenRows | $2.50 | $0.99 | $0.549 |
| Scrapfly | $3.00 | $1.00 | $0.56 |
| Scrape.do | $2.90 | $0.99 | $0.699 |
| Crawlbase | — | $0.99 | $0.599 |
| Bright Data Web Unlocker | $1.50 | $1.50 | $1.30 |
| Oxylabs Web Scraper API | $3.00 | $5.00 | $2.50 |
| Decodo Web Data API | $1.90 | $0.99 | $0.999 |
| Hyperbrowser Fetch | $3.00 | $1.00 | — |
| Steel scrape | $5.00 | $5.00 | $5.00 |
| Crawl4AI Cloud | $1.00 | $0.99 | $0.667 |

*Prix vérifiés le 22 octobre 2026.*

## Pourquoi les prix varient-ils autant entre les API ?

Quatre choses expliquent l'essentiel de l'écart.

1. **Type de produit.** Les API de scraping web généralistes (ScrapingBee, Scrape.do, ZenRows, Scrapfly) sont tarifées pour le volume et atteignent environ 0,10 $ pour 1 000 pages simples à 1 million par mois. Les lecteurs orientés IA (Exa, Parallel, Linkup) facturent un tarif fixe de 1,00 $ et ajoutent des fonctions de retrieval.
2. **Multiplicateurs navigateur.** Chez les API à crédits, une page navigateur coûte 2 à 10 fois le prix d'une page simple ; les API à tarif fixe facturent les deux au même prix.
3. **Paliers de forfait.** De nombreux fournisseurs vendent des forfaits mensuels avec un quota important, si bien que les petits utilisateurs paient des pages inutilisées : la médiane à 10 000 pages simples par mois est de 2,00 $.
4. **Expiration.** La plupart des forfaits remettent à zéro chaque mois les crédits non utilisés ; ScrapeGraphAI, Crawlbase et Crawl4AI Cloud conservent les crédits achetés sans remise à zéro mensuelle.

## Paliers gratuits, expiration, crypto, vérification d'identité et robots.txt

Ce que chaque fournisseur indique sur les pages que nous avons lues. « Non précisé » signifie que les pages ne le mentionnaient pas.

| API | Offre gratuite | Expiration des crédits | Paiement en crypto | Vérifications d'identité | robots.txt |
| --- | --- | --- | --- | --- | --- |
| WebReaderAPI | Aucune | Jamais | BTC, USDT, USDC, ETH, SOL, LTC | Aucune : pas de pièce d'identité, pas de selfie, pas de documents | Respecté ; jamais outrepassé |
| Firecrawl | 1 000 crédits par mois, sans carte | Les crédits du forfait sont réinitialisés chaque mois | Non (cartes bancaires, PayPal) | Non précisé | Respecté par défaut ; outrepassable uniquement sur Enterprise |
| Tavily Extract | 1 000 crédits par mois (5 000 URL basiques) | Réinitialisation mensuelle | Uniquement à sa discrétion (conditions) | Non précisé | Non précisé |
| Exa contents | 10 $ de crédits par mois | Les crédits gratuits sont réinitialisés chaque mois | Par requête, USDC (x402) | Carte pour le paiement à l'usage | Indiqué pour son crawler d'index, pas pour les extractions des utilisateurs |
| Parallel Extract | 5 000 requêtes par mois | Les crédits gratuits expirent chaque mois | Par requête, USDC (x402) | Carte pour les crédits mensuels | Indiqué pour son crawler d'index, pas pour les extractions des utilisateurs |
| Linkup fetch | 20 $ par mois (e-mail professionnel) | Non précisé | Par requête, USDC (x402) | E-mail professionnel pour les crédits gratuits | Le crawl le respecte ; non précisé pour les extractions |
| Olostep | Essai de 500 requêtes | Forfait mensuel ; recharges valables 6 mois | Par requête, USDC (x402) | Carte pour les recharges | Outils pour le respecter ; comportement par défaut non précisé |
| ScrapeGraphAI | 500 crédits | Les crédits du forfait ne sont pas reportés ; les recharges n'expirent jamais | Agents uniquement (MPP) | Non précisé | Le client doit s'y conformer (conditions) |
| Diffbot | 10 000 crédits par mois | Le quota est réinitialisé à chaque période | Non précisé | Aucune carte pour le forfait gratuit | Le crawl l'obéit par défaut ; non précisé pour Extract |
| ScrapingBee | 1 000 crédits | Aucun report | Non | Carte pour les offres payantes | Non précisé |
| ScraperAPI | 5 000 crédits pour 7 jours | Expirent à chaque période de facturation | Non | Non précisé | Non précisé |
| ZenRows | 5 000 crédits par mois | Au renouvellement | Comptes : non ; agents : USDC (x402) | Validation par email | Non précisé |
| Scrapfly | 1 000 crédits une fois | Aucun report | Non précisé | KYC pour chaque client | L'API de crawler le respecte par défaut ; peut être désactivé |
| Scrape.do | 1 000 crédits par mois | Non précisé | Oui (pièces non précisées) | Non précisé | Non précisé |
| Crawlbase | 1 000 crédits | Paiement à l'usage : rien n'expire | Non précisé | Non précisé | Non précisé |
| Bright Data Web Unlocker | 5 000 crédits par mois | Les crédits gratuits sont réinitialisés chaque mois | Non | Carte pour les comptes avec e-mail personnel ; KYC d'entreprise pour les pages interdites par robots.txt | Respecté par défaut |
| Oxylabs Web Scraper API | 5 $ de crédits une fois | Fin de cycle | Non | KYC pour chaque client | Non mentionné |
| Decodo Web Data API | Jusqu'à 10 000 requêtes par mois | Les montants non utilisés expirent chaque mois | Oui (via CoinGate) | Vérification automatique, puis KYC | Non précisé |
| Scrapeless | Essai, taille non précisée | Minimum prépayé non conservé | Oui (pièces non précisées) | Aucun pour les forfaits de base | Non précisé |
| Hyperbrowser Fetch | 5 000 crédits | Crédits achetés : 12 mois | Par requête, USDC (x402) | Non précisé | Non précisé |
| Steel scrape | 30 $ une fois (90 jours) | Crédit de lancement 90 jours | Par requête, USDC (x402) | Pas de carte | Les conditions interdisent de l'enfreindre |
| Crawl4AI Cloud | 1 000 crédits par mois | Les crédits achetés n'expirent jamais | Non précisé | Pas de carte | Les conditions exigent de le respecter |

*Prix vérifiés le 22 octobre 2026.*

## Quels sont les principaux constats ?

- **Les pages simples sont bon marché à volume élevé.** À 1 million de pages par mois, ScrapingBee (0,099 $), Scrape.do (0,099 $) et Scrapfly (0,10 $) affichent les prix les plus bas pour les pages simples.
- **Les pages avec navigateur coûtent plus cher.** À 1 million par mois, Olostep (0,399 $), ZenRows (0,549 $) et Scrapfly (0,56 $) affichent les prix les plus bas pour les pages avec navigateur.
- **Le lecteur le plus connu n'est pas le moins cher.** Firecrawl affiche 0,99 $ pour 1 000 à 100 000 pages et 0,749 $ à 1 million, avec chaque page rendue.
- **La crypto est rare sur les comptes.** Scrape.do, Decodo Web Data API et Scrapeless indiquent accepter le paiement en crypto ; Exa contents, Parallel Extract, Linkup fetch, Olostep, ZenRows, Hyperbrowser Fetch et Steel scrape paient à la requête en USDC via x402.
- **robots.txt est souvent laissé au client.** Fournisseurs indiquant un comportement par défaut respectueux de robots.txt, au moins sur leurs produits de crawl : Firecrawl, Diffbot, Scrapfly, Bright Data Web Unlocker. Beaucoup ne disent rien.
- **Le KYC est l'exception.** Oxylabs et Scrapfly le demandent à chaque client ; Decodo effectue d'abord une vérification automatique.

## API facturées autrement (hors médianes)

Celles-ci facturent au token, au temps de navigateur, au volume de données ou au calcul, ou n'ont pas confirmé la sortie Markdown ; le prix par page dépend donc de vos pages.

| API | Prix | Remarque |
| --- | --- | --- |
| Jina Reader | 50 $ pour 1 milliard de tokens en sortie ; 500 $ pour 11 milliards | Facturé au token : le coût par page dépend de la longueur de la page. 10 millions de tokens gratuits par nouvelle clé, usage non commercial uniquement. |
| Cloudflare Browser Run | 0,09 $ par heure de navigateur au-delà des 10 heures incluses, minimum mensuel de 5 $ | Facturé au temps de navigateur ; endpoints /markdown, /content et /crawl. |
| Spider | 1 $ par GB de contenu plus le calcul | Facturé au volume de données ; les chiffres par page qu'il publie sont ses propres estimations. |
| Apify Website Content Crawler | Unités de calcul (0,13 $ par unité en Business) | Facturé au calcul ; les chiffres par page qu'il publie sont ses propres estimations. |
| Zyte API | 0,13 $ pour 1 000 requêtes statiques (website tier 1, paiement à l'usage) ; 1,01 $ avec un navigateur | Le prix dépend d'un tier que Zyte attribue par site web ; sortie Markdown non indiquée sur les pages que nous avons consultées. |

*Prix vérifiés le 22 octobre 2026.*

## Puis-je réutiliser ces données ?

Oui. Les tableaux de cette page sont publiés sous licence Creative Commons Attribution 4.0 (CC BY 4.0) : copiez-les et adaptez-les avec un lien vers cette page et la date 2026-10-22. Nous relisons les prix au moins une fois par mois.

Si un chiffre est erroné, écrivez à support@webreaderapi.com avec la page qui montre le bon chiffre ; nous le corrigeons et signalons la modification dans le [changelog](https://webreaderapi.com/fr/changelog/).

## Index des prix : questions fréquentes

### Quelle API URL-vers-Markdown coûte le moins cher ?

Cela dépend du volume et de JavaScript. Le 2026-10-22, les prix les plus bas pour les pages simples à 1 million de pages par mois étaient ScrapingBee à 0,099 $ et Scrape.do à 0,099 $ pour 1 000 ; le prix le plus bas pour les pages avec navigateur à ce volume était Olostep à 0,399 $.

### Combien coûte Firecrawl par page ?

Firecrawl facture 1 crédit par page, JavaScript inclus : 19 $ pour 5 000 crédits en Hobby, 99 $ pour 100 000 en Standard et 749 $ pour 1 million en Scale, relevés sur sa page de tarifs le 2026-10-22. L'extraction JSON ajoute 4 crédits par page.

### Pourquoi Jina Reader n'apparaît-il pas dans les tableaux principaux ?

Jina facture en tokens de sortie (50 $ par milliard de tokens sur son plus petit pack), donc son prix par page dépend de la longueur de vos pages. Il figure dans le tableau des API facturées autrement.

### Est-ce que WebReaderAPI se compte lui-même dans les médianes ?

WebReaderAPI publie cet index et apparaît dans les premières lignes à titre de référence uniquement. Les médianes utilisent les autres fournisseurs.

### À quelle fréquence l'index est-il mis à jour ?

Au moins une fois par mois, et lorsqu'un fournisseur listé modifie ses tarifs publics. La date en haut indique la dernière vérification complète.

## Sources

1. [Firecrawl : tarifs](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
2. [Tavily Extract : tarifs](https://docs.tavily.com/documentation/api-credits) — Tavily (read 2026-10-22)
3. [Exa contents : tarifs](https://exa.ai/pricing) — Exa (read 2026-10-22)
4. [Parallel Extract : tarifs](https://parallel.ai/pricing) — Parallel (read 2026-10-22)
5. [Linkup fetch : tarifs](https://docs.linkup.so/pages/documentation/development/pricing) — Linkup (read 2026-10-22)
6. [Olostep : tarifs](https://www.olostep.com/pricing) — Olostep (read 2026-10-22)
7. [ScrapeGraphAI : tarifs](https://scrapegraphai.com/pricing) — ScrapeGraphAI (read 2026-10-22)
8. [Diffbot : tarifs](https://www.diffbot.com/pricing/) — Diffbot (read 2026-10-22)
9. [ScrapingBee : tarifs](https://www.scrapingbee.com/pricing/) — ScrapingBee (read 2026-10-22)
10. [ScraperAPI : tarifs](https://www.scraperapi.com/pricing/) — ScraperAPI (read 2026-10-22)
11. [ZenRows : tarifs](https://docs.zenrows.com/first-steps/pricing.md) — ZenRows (read 2026-10-22)
12. [Scrapfly : tarifs](https://scrapfly.io/pricing) — Scrapfly (read 2026-10-22)
13. [Scrape.do : tarifs](https://scrape.do/pricing.md) — Scrape.do (read 2026-10-22)
14. [Crawlbase : tarifs](https://crawlbase.com/pricing) — Crawlbase (read 2026-10-22)
15. [Bright Data Web Unlocker : tarifs](https://www.bright.cn/pricing/web-unlocker) — Bright Data (read 2026-10-22)
16. [Oxylabs Web Scraper API : tarifs](https://oxylabs.io/pricing/web-scraper-api) — Oxylabs (read 2026-10-22)
17. [Decodo Web Data API : tarifs](https://help.decodo.com/docs/web-data-api-billing) — Decodo (read 2026-10-22)
18. [Scrapeless : tarifs](https://www.scrapeless.com/en/pricing) — Scrapeless (read 2026-10-22)
19. [Hyperbrowser Fetch : tarifs](https://hyperbrowser.ai/docs/pricing.md) — Hyperbrowser (read 2026-10-22)
20. [Steel scrape : tarifs](https://docs.steel.dev/overview/pricinglimits) — Steel (read 2026-10-22)
21. [Crawl4AI Cloud : tarifs](https://crawl4ai.com/) — Crawl4AI (read 2026-10-22)
22. [Jina Reader : tarifs](https://jina.ai/api-dashboard/pricing/) — Jina Reader (read 2026-10-22)
23. [Cloudflare Browser Run : tarifs](https://developers.cloudflare.com/browser-run/pricing/) — Cloudflare Browser Run (read 2026-10-22)
24. [Spider : tarifs](https://spider.cloud/pricing) — Spider (read 2026-10-22)
25. [Apify Website Content Crawler : tarifs](https://apify.com/apify/website-content-crawler) — Apify Website Content Crawler (read 2026-10-22)
26. [Zyte API : tarifs](https://www.zyte.com/pricing/) — Zyte API (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Démarrage rapide de l'API URL to Markdown : votre première page en deux minutes

> Démarrage rapide de l'API URL vers Markdown : obtenez une clé, lisez une page en curl, Python ou Node.js, vérifiez vos crédits. Dès 0,07 $US/1K pages, sans KYC.

- URL: https://webreaderapi.com/fr/docs/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un endpoint, un paramètre : envoyez une URL à `/read` et récupérez le contenu principal de la page au format Markdown. Cette page vous mène d'un solde vide à un appel fonctionnel, puis vous oriente vers tout le reste.

**Réponse rapide — Comment convertir une URL en Markdown avec une API ?**

Envoyez l'URL à `GET https://webreaderapi.com/api/v1/read` avec votre clé API dans l'en-tête `Authorization`. **WebReaderAPI** récupère la page, conserve le contenu principal et le renvoie au format Markdown avec son titre, son auteur, sa date et son nombre de mots. Une page coûte un crédit (deux si un navigateur est nécessaire), à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## L'API en un tableau

| Attribut | Valeur |
| --- | --- |
| URL de base | `https://webreaderapi.com/api/v1` |
| Lire une page | `GET` ou `POST https://webreaderapi.com/api/v1/read` |
| Plusieurs URL ou un site | `POST https://webreaderapi.com/api/v1/batch` et `POST https://webreaderapi.com/api/v1/crawl`, résultats depuis `GET https://webreaderapi.com/api/v1/jobs/{job_id}` |
| Crédits restants | `GET https://webreaderapi.com/api/v1/credits` (gratuit) |
| Authentification | Envoyez votre clé API dans le header Authorization en tant que Bearer token, ou dans le paramètre de requête api_key |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Notre crawler | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, jeton robots.txt `WebReaderAPI` |
| Plus petit pack | 10 000 pages pour 3,75 $US ; les crédits n'expirent jamais |

## Comment obtenir une clé API ?

Trois étapes, aucun formulaire à remplir. La plus lente est la confirmation blockchain de votre recharge.

1. **Rechargez en crypto** — Envoyez au moins 25 $US en BTC, USDT, USDC, ETH, SOL, LTC. Connexion par numéro de compte ; l'email est facultatif.
2. **Acheter un pack de crédits** — 10 000 pages pour 3,75 $US suffit pour tester chaque option sur vos propres URL.
3. **Copiez votre clé** — Votre clé API est prête dans le dashboard dès que votre recharge crypto est confirmée et que vous avez acheté un pack. Stockez-la dans une variable d'environnement nommée WEBREADER_API_KEY.

## À quoi ressemble la première requête ?

C'est un simple GET HTTPS avec l'adresse de la page dans le paramètre `url`. Encodez l'adresse, car elle contient ses propres caractères `:` et `/` ; curl le fait pour vous avec `--data-urlencode`. Les réglages par défaut conviennent déjà à la plupart des articles et pages de documentation : sortie Markdown, contenu principal uniquement, et un navigateur seulement quand la page en a besoin.

*curl : lire une page*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/blog/first-post"
```

*Python : lire une page et l'enregistrer*

```python
import os

import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/blog/first-post"},
    timeout=70,
)
resp.raise_for_status()
page = resp.json()
print(page["title"], "-", page["word_count"], "words,", page["credits_used"], "credit(s)")
with open("first-post.md", "w", encoding="utf-8") as f:
    f.write(page["markdown"])

```

*Node.js 18+ : lire une page*

```javascript
const params = new URLSearchParams({ url: 'https://example.com/blog/first-post' });
const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
});
const page = await res.json();
if (!res.ok) throw new Error(`${page.error.code}: ${page.error.message}`);
console.log(page.title, page.word_count, 'words');
console.log(page.markdown.slice(0, 500));

```

## Que renvoie l'API ?

Un objet JSON avec le Markdown dans le champ `markdown` et les métadonnées de la page à côté : `title`, `description`, `author`, `published_at`, `language`, `site_name` et `word_count`. Deux champs vous aident à vérifier ce qui s'est passé : `final_url` est l'adresse après les redirections, et `rendered` vous indique si un navigateur a été nécessaire.

`credits_used` indique le coût de l'appel : 1 pour une page simple, 2 quand `rendered` vaut `true`, un de plus si vous avez choisi un `country`. La page [format de réponse](https://webreaderapi.com/fr/docs/response/) liste chaque champ avec un exemple.

## Quelles options vais-je utiliser le plus ?

Cinq paramètres couvrent la plupart des besoins. Tous sont facultatifs.

| Paramètre | À utiliser pour |
|---|---|
| `format` | Obtenir du `text` ou du `html` nettoyé au lieu de `markdown` |
| `main_content` | Définir `false` pour convertir toute la page, menus compris |
| `render` | Forcer (`true`) ou interdire (`false`) le navigateur ; `auto` décide |
| `include_links` | Obtenir les liens de la page sous forme de liste séparée |
| `max_chars` | Tronquer les pages longues pour tenir dans le budget de contexte d'un modèle |

La [référence read](https://webreaderapi.com/fr/docs/read/) décrit chaque paramètre, notamment `country`, `include_images` et `timeout`.

## Comment vérifier mes crédits restants ?

Appelez `GET https://webreaderapi.com/api/v1/credits` avec la même clé. Cela renvoie `credits_remaining`, `credits_used_today` et votre `concurrency_limit`, et ne coûte rien. Lancez-le au début d'une tâche longue pour qu'elle s'arrête proprement au lieu d'échouer en cours de route sur `402 insufficient_credits`.

Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez, donc un pack acheté pour un projet garde sa valeur pour le suivant.

## Que se passe-t-il si un site n'autorise pas les robots ?

Nous ne lisons pas la page, et vous n'êtes pas facturé. Notre crawler s'annonce comme `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` et respecte le robots.txt du site. Une page non autorisée renvoie `403 blocked_by_robots` ; un site qui refuse la requête d'une autre manière renvoie `502 target_refused` avec le propre code de statut du site.

Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. La [page des erreurs](https://webreaderapi.com/fr/docs/errors/) explique quelles erreurs méritent une nouvelle tentative et lesquelles sont définitives.

## Où aller ensuite ?

- [Lire la référence de l'endpoint](https://webreaderapi.com/fr/docs/read/) — Chaque paramètre de /read, avec des exemples
- [Batch et crawl](https://webreaderapi.com/fr/docs/crawl/) — Jusqu'à 100 URL par lot, ou un site entier
- [Format de réponse](https://webreaderapi.com/fr/docs/response/) — Chaque champ de la réponse
- [Erreurs et robots.txt](https://webreaderapi.com/fr/docs/errors/) — Codes, causes et règles de nouvelle tentative
- [Python](https://webreaderapi.com/fr/docs/python/) — requests, httpx async, découpage RAG
- [Node.js](https://webreaderapi.com/fr/docs/node/) — fetch, un petit pool, polling du crawl
- [curl et jq](https://webreaderapi.com/fr/docs/curl/) — Recettes pour le terminal
- [Serveur MCP](https://webreaderapi.com/fr/docs/mcp/) — Un outil read_url pour Claude et Cursor
- [LangChain et LlamaIndex](https://webreaderapi.com/fr/docs/langchain/) — Loaders et outils pour le RAG
- [OpenAI function calling](https://webreaderapi.com/fr/docs/openai/) — Un schéma et une boucle d'outil read_url
- [n8n](https://webreaderapi.com/fr/docs/n8n/) — Outil HTTP Request pour un agent IA
- [OpenClaw](https://webreaderapi.com/fr/docs/openclaw/) — Ajouter le serveur MCP à côté de web_fetch

## Démarrage rapide : questions courantes

### Y a-t-il un SDK à installer ?

Non. WebReaderAPI est une API HTTPS simple, donc n'importe quel client HTTP fonctionne. La documentation fournit du code à copier-coller pour Python, Node.js et curl, ainsi que des définitions d'outils pour MCP, LangChain, LlamaIndex et le function calling d'OpenAI. Rien n'est publié sous forme de package.

### Puis-je envoyer la clé dans l'URL au lieu d'un header ?

Oui, via le paramètre de requête `api_key`. Le header `Authorization: Bearer` est plus sûr, car les URL finissent souvent dans les logs et l'historique du navigateur. Créez plusieurs clés API, par exemple une par agent ou par projet, et révoquez n'importe laquelle depuis votre dashboard.

### Une page en échec consomme-t-elle un crédit ?

Non. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Seule une page qui revient avec du contenu est facturée.

### Puis-je l'essayer avant d'acheter ?

Il n'existe pas d'offre gratuite. Il n'y a pas d'offre gratuite : le plus petit pack est le moyen de tester, payé à partir de la recharge minimale, et le montant ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande sous 30 jours, en USDT ou USDC, tant qu'il n'est pas dépensé.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# API batch et crawl : lire de nombreuses URLs ou un site entier

> API batch et crawl : lisez 100 URLs par job ou un site jusqu'à 10 000 pages, robots.txt respecté. Sans KYC, payez en crypto.

- URL: https://webreaderapi.com/fr/docs/crawl/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Deux endpoints lancent des jobs en arrière-plan : `/batch` pour une liste de 100 URLs maximum, `/crawl` pour un site web. Les deux renvoient un job ID ; vous récupérez les pages depuis `/jobs/{job_id}`, une page de résultats à la fois.

**Réponse rapide — Comment crawler un site web vers du Markdown avec WebReaderAPI ?**

Envoyez l'URL de départ à `POST https://webreaderapi.com/api/v1/crawl` avec une page `limit`. **WebReaderAPI** lit le site en arrière-plan, même domaine uniquement, en suivant son sitemap, robots.txt et Crawl-delay, jusqu'à 10 000 pages par job. Récupérez les pages Markdown du job, une page de résultats à la fois. Chaque page lue coûte 1 crédit (2 avec un navigateur), à partir de 0,07 $US/1K pages depuis octobre 2026. Sans KYC ; payez en crypto.

## Les jobs en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Batch | Jusqu'à 100 URLs par job batch : `POST https://webreaderapi.com/api/v1/batch` |
| Crawl | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay : `POST https://webreaderapi.com/api/v1/crawl` |
| Résultats | `GET https://webreaderapi.com/api/v1/jobs/{job_id}`, puis `?cursor=…` pour la page de résultats suivante |
| Facturation | Chaque page lue est facturée comme un appel `/read` ; les pages ignorées par robots.txt et les pages en échec ne coûtent rien |
| Périmètre d'un crawl | Un seul domaine ; les liens vers d'autres domaines sont listés mais non lus |
| Annuler un job | Non disponible en v1 : réglez `limit` sur le nombre maximum de pages que vous êtes prêt à payer |

## Lancer un job batch

`POST /api/v1/batch`

Lit jusqu'à 100 URLs en arrière-plan avec les mêmes options. Les options utilisent les noms et valeurs de [/read](https://webreaderapi.com/fr/docs/read/). La réponse est le job ID ; les valeurs sont illustratives.

Authentification : clé API dans le header `Authorization: Bearer API_KEY`.

**Corps de la requête**

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `urls` | array of strings | Oui | De 1 à 100 URLs http ou https. Les doublons ne sont lus qu'une fois. |
| `options` | object | Non | Tout paramètre `/read` sauf `url` : `format`, `main_content`, `render`, `include_links`, `include_images`, `country`, `max_chars`, `timeout`. |

*Exemple: three articles as Markdown*

```json
{
  "urls": [
    "https://example.com/blog/post-1",
    "https://example.com/blog/post-2",
    "https://example.org/news/launch"
  ],
  "options": {
    "format": "markdown",
    "max_chars": 50000
  }
}
```

**Réponse** `202 Accepted`

```json
{
  "job_id": "job_5c1e8a90d2"
}
```

*curl*

```bash
curl -s "https://webreaderapi.com/api/v1/batch" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com/blog/post-1", "https://example.com/blog/post-2"], "options": {"format": "markdown"}}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://webreaderapi.com/api/v1/batch",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    json={"urls": ["https://example.com/blog/post-1", "https://example.com/blog/post-2"], "options": {"format": "markdown"}},
    timeout=30,
)
print(resp.json()["job_id"])
```

*Node.js*

```javascript
const res = await fetch('https://webreaderapi.com/api/v1/batch', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ urls: ['https://example.com/blog/post-1', 'https://example.com/blog/post-2'], options: { format: 'markdown' } }),
});
console.log((await res.json()).job_id);
```

## Démarrer un job de crawl

`POST /api/v1/crawl`

Lit un site web à partir d'une URL de départ, en largeur d'abord. Le crawler reste sur le domaine de l'URL de départ, utilise le sitemap indiqué dans robots.txt ou trouvé à `/sitemap.xml`, et respecte robots.txt et Crawl-delay. Les valeurs sont illustratives.

Authentification : clé API dans le header `Authorization: Bearer API_KEY`.

**Corps de la requête**

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `url` | string | Oui | La page de départ, comme la page d'accueil d'un site de documentation. |
| `limit` | integer | Non | Nombre maximal de pages à lire, jusqu'à 10 000. Le job s'arrête lorsqu'il atteint ce nombre. |
| `max_depth` | integer | Non | Nombre maximal de sauts de lien depuis l'URL de départ. |
| `include_paths` | array of strings | Non | Motifs de chemin simples à conserver, comme `/docs/*`. |
| `exclude_paths` | array of strings | Non | Motifs de chemin simples à ignorer, comme `/blog/tag/*`. |
| `options` | object | Non | Tout paramètre `/read` sauf `url`, appliqué à chaque page. |

*Exemple: the docs section of a site, 500 pages at most*

```json
{
  "url": "https://docs.example.com/",
  "limit": 500,
  "max_depth": 3,
  "include_paths": [
    "/docs/*"
  ],
  "exclude_paths": [
    "/docs/archive/*"
  ],
  "options": {
    "format": "markdown"
  }
}
```

**Réponse** `202 Accepted`

```json
{
  "job_id": "job_8b27f41c0e"
}
```

*curl*

```bash
curl -s "https://webreaderapi.com/api/v1/crawl" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://docs.example.com/", "limit": 500, "include_paths": ["/docs/*"]}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://webreaderapi.com/api/v1/crawl",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    json={"url": "https://docs.example.com/", "limit": 500, "include_paths": ["/docs/*"]},
    timeout=30,
)
print(resp.json()["job_id"])
```

*Node.js*

```javascript
const res = await fetch('https://webreaderapi.com/api/v1/crawl', {
  method: 'POST',
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`, 'Content-Type': 'application/json' },
  body: JSON.stringify({ url: 'https://docs.example.com/', limit: 500, include_paths: ['/docs/*'] }),
});
console.log((await res.json()).job_id);
```

## Obtenir le statut et les résultats d'un job

`GET /api/v1/jobs/{job_id}`

Renvoie le statut du job et les prochains résultats prêts. Chaque élément de `results` est soit une réponse `/read` complète, soit `{url, error}` pour une page qui n'a pas pu être lue. Quand `next_cursor` est présent, rappelez avec `cursor` défini à cette valeur ; quand il est absent, aucun autre résultat n'est encore prêt. Les valeurs sont illustratives.

Authentification : clé API dans le header `Authorization: Bearer API_KEY`.

**Paramètres**

| Nom | Emplacement | Type | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `job_id` | path | string | Oui | L'ID renvoyé par `/batch` ou `/crawl`. |
| `cursor` | query | string | Non | La valeur `next_cursor` de l'appel précédent, pour obtenir les résultats suivants. |

**Réponse** `200`

```json
{
  "job_id": "job_8b27f41c0e",
  "status": "running",
  "results": [
    {
      "url": "https://docs.example.com/docs/install",
      "final_url": "https://docs.example.com/docs/install",
      "status_code": 200,
      "rendered": false,
      "credits_used": 1,
      "title": "Install",
      "markdown": "# Install\n\nRun the installer...",
      "word_count": 418
    },
    {
      "url": "https://docs.example.com/docs/private",
      "error": {
        "code": "blocked_by_robots",
        "message": "robots.txt disallows this page for WebReaderAPI."
      }
    }
  ],
  "next_cursor": "c_000002",
  "credits_used": 1
}
```

*curl*

```bash
curl -sG "https://webreaderapi.com/api/v1/jobs/job_8b27f41c0e" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -d cursor=c_000002
```

*Python*

```python
import os
import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/jobs/job_8b27f41c0e",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"cursor": "c_000002"},
    timeout=30,
)
job = resp.json()
print(job["status"], len(job["results"]), job.get("next_cursor"))
```

*Node.js*

```javascript
const res = await fetch('https://webreaderapi.com/api/v1/jobs/job_8b27f41c0e?cursor=c_000002', {
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
});
const job = await res.json();
console.log(job.status, job.results.length, job.next_cursor);
```

## Comment attendre la fin d'un job ?

Interrogez `/jobs/{job_id}` et conservez le curseur. Traitez les résultats reçus, puis rappelez avec `cursor` défini à `next_cursor`. Quand `next_cursor` est absent et que `status` vaut `done`, vous avez tout ; quand il est absent et que le job est encore `running`, attendez et rappelez avec le même curseur.

Commencez à interroger toutes les 2 secondes et doublez l'attente jusqu'à 30 secondes tant que rien de nouveau n'arrive. Un crawl qui respecte le Crawl-delay d'un site peut prendre du temps : une longue attente est normale et ne coûte rien.

*Python : interroger un job et enregistrer chaque page dans un fichier .md*

```python
import os
import pathlib
import re
import time

import requests

JOBS = "https://webreaderapi.com/api/v1/jobs"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


def save_job(job_id, folder="pages"):
    out = pathlib.Path(folder)
    out.mkdir(exist_ok=True)
    cursor, wait, saved = None, 2, 0
    while True:
        params = {"cursor": cursor} if cursor else {}
        job = requests.get(f"{JOBS}/{job_id}", headers=HEADERS, params=params, timeout=30).json()
        for item in job["results"]:
            if "error" in item:
                print("skipped", item["url"], item["error"]["code"])
                continue
            name = re.sub(r"[^a-z0-9]+", "-", item["final_url"].lower()).strip("-")[:120]
            (out / f"{name}.md").write_text(item["markdown"], encoding="utf-8")
            saved += 1
        if job.get("next_cursor"):
            cursor, wait = job["next_cursor"], 2
            continue
        if job["status"] == "done":
            return saved
        time.sleep(wait)
        wait = min(wait * 2, 30)


if __name__ == "__main__":
    print(save_job("job_8b27f41c0e"), "pages saved")

```

## Quelles pages un crawl lit-il ?

Un crawl démarre à votre URL et progresse vers l'extérieur, un saut de lien à la fois, en largeur d'abord, jusqu'à `max_depth`. Il lit aussi le sitemap du site, à l'adresse indiquée dans robots.txt ou à `/sitemap.xml`, pour trouver les pages vers lesquelles peu de liens pointent.

- **Même domaine uniquement.** Les liens vers d'autres domaines sont listés dans les résultats quand vous demandez `include_links`, mais ils ne sont pas lus.
- **Filtres de chemin.** `include_paths` et `exclude_paths` acceptent des motifs simples comme `/blog/*`.
- **Une copie par page.** Quand un site déclare une URL canonique, une page atteinte via plusieurs adresses n'est lue qu'une fois.
- **Un arrêt net.** Le job se termine quand il a lu `limit` pages.

## Comment un crawl respecte-t-il le site ?

Chaque requête porte le User-Agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, et le crawler suit les règles robots.txt pour `WebReaderAPI`, ou pour tous les robots quand aucun ne le nomme. Les pages interdites sont ignorées et apparaissent dans `results` avec l'erreur `blocked_by_robots` ; elles ne coûtent rien.

Quand robots.txt définit un `Crawl-delay`, le crawler attend ce délai entre deux requêtes vers le site. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

## Combien coûte un crawl ?

Chaque page lue coûte ce que coûterait un appel `/read` : 1 crédit, 2 si la page a nécessité un navigateur, plus 10 avec `country`. Les pages ignorées et en échec sont gratuites. Le champ `credits_used` du job totalise ce qui a été facturé jusqu'ici.

Un site de documentation de 500 pages lu sans navigateur utilise environ 500 crédits, que le pack 10 000 pages (3,75 $US) couvre largement. Comme un job ne peut pas être annulé en v1, `limit` est votre plafond de dépense : fixez-le au nombre maximal de pages que vous êtes prêt à payer.

## Batch et crawl : questions fréquentes

### Faut-il utiliser /batch ou plusieurs appels /read ?

Utilisez `/batch` quand vous avez déjà les URLs et n'avez pas besoin de chaque réponse immédiatement. Cela vous évite de gérer la concurrence et les tentatives. Utilisez `/read` quand un agent a besoin d'une page tout de suite.

### Combien de temps les résultats d'un job sont-ils conservés ?

Récupérez-les dès qu'ils sont prêts. Les résultats attendent que vous les récupériez ; une fois livrés, aucune copie du contenu de la page n'est conservée, stockez donc ce dont vous avez besoin de votre côté.

### Un crawl peut-il suivre des liens vers d'autres sites web ?

Non. Un crawl lit un seul domaine. Les autres domaines apparaissent comme liens quand vous les demandez, et vous pouvez envoyer ces URLs à `/batch` si vous voulez qu'elles soient lues.

### Puis-je arrêter un crawl déjà démarré ?

Pas en v1. Le job s'arrête à `limit` pages, choisissez donc une limite adaptée à votre budget. Les pages déjà lues restent facturées ; les pages jamais lues ne coûtent rien.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Page web en Markdown avec curl et jq

> Convertissez des pages web en Markdown avec curl et jq : enregistrez, listez les liens et lancez un batch. Dès 0,07 $US/1K pages, sans KYC.

- URL: https://webreaderapi.com/fr/docs/curl/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Tout ce que fait l'API tient en une ligne de shell. Ces recettes utilisent curl pour appeler l'API et jq pour extraire des champs du JSON, avec une version PowerShell pour Windows à la fin.

**Réponse rapide — Comment convertir une page web en Markdown depuis la ligne de commande ?**

Lancez `curl -sG https://webreaderapi.com/api/v1/read --data-urlencode "url=…"` avec votre clé dans un header `Authorization: Bearer`, puis passez la réponse à `jq -r .markdown`. **WebReaderAPI** renvoie l'extraction du contenu principal de la page en Markdown avec ses métadonnées. Une page simple utilise 1 crédit, à partir de 0,07 $US/1K pages depuis octobre 2026. Sans KYC ; payez en crypto.

## Comment configurer le terminal ?

Installez curl et jq, que la plupart des systèmes Linux et macOS possèdent déjà, et exportez votre clé une fois par session. Chaque recette ci-dessous la lit depuis `$WEBREADER_API_KEY`, ainsi la clé n'apparaît jamais dans l'historique de votre shell au sein d'une commande.

Utilisez `-G` avec `--data-urlencode` pour les requêtes GET : curl encode alors l'adresse de la page pour vous, ce qui compte car les adresses contiennent leurs propres `?`, `&` et `=`.

*Définir la clé et enregistrer une page dans un fichier .md*

```bash
export WEBREADER_API_KEY="your-key"

curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/guides/compost" \
  | jq -r '.markdown' > compost.md
```

## Comment voir ce qu'un appel a renvoyé et ce qu'il a coûté ?

Demandez les métadonnées à jq plutôt que le contenu. `final_url` indique où les redirections ont mené, `rendered` vous dit si un navigateur headless a été utilisé, et `credits_used` correspond au coût de l'appel. Si la réponse est une erreur, le même filtre affiche les champs `null` ; affichez `.error` pour lire le code et le message.

*Métadonnées seules, ou l'erreur s'il y en a une*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/guides/compost" \
  | jq '.error // {title, final_url, rendered, credits_used, word_count}'
```

## Comment lister les liens d'une page ?

Ajoutez `include_links=true` et transformez la liste `links` en lignes séparées par des tabulations. Vous obtenez une carte rapide des liens sortants d'une page, que vous pouvez trier, filtrer avec grep ou envoyer à un job par lots.

*Liens sous forme de texte et d'URL, un par ligne*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/docs/" \
  -d include_links=true \
  | jq -r '.links[] | "\(.text)\t\(.url)"' | sort -u
```

## Comment lire une page JavaScript ou un PDF ?

Ajoutez `-d render=true` pour une page qui construit son contenu avec JavaScript ; elle coûte alors 2 crédits. Un PDF n'a besoin de rien de particulier : envoyez son URL et le texte revient en `markdown`. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

*Une page rendue, puis un PDF*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/app/changelog" -d render=true \
  | jq -r '.markdown' > changelog.md

curl -sG "https://webreaderapi.com/api/v1/read" -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/files/annual-report.pdf" \
  | jq -r '.markdown' > annual-report.md
```

## Comment lancer un job par lots depuis le shell ?

Envoyez un corps JSON avec vos URLs à `/batch`, conservez le `job_id`, puis lisez le job. Une petite boucle attend que le job soit `done` et affiche le titre ou le code d'erreur de chaque page. Pour les jobs longs, suivez `next_cursor` comme indiqué sur la [page batch et crawl](https://webreaderapi.com/fr/docs/crawl/).

*Lot de trois URLs, puis attente du résultat*

```bash
JOB=$(curl -s "https://webreaderapi.com/api/v1/batch" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://example.com/a", "https://example.com/b", "https://example.com/c"]}' \
  | jq -r '.job_id')

until [ "$(curl -s "https://webreaderapi.com/api/v1/jobs/$JOB" -H "Authorization: Bearer $WEBREADER_API_KEY" | jq -r '.status')" = "done" ]; do
  sleep 5
done

curl -s "https://webreaderapi.com/api/v1/jobs/$JOB" -H "Authorization: Bearer $WEBREADER_API_KEY" \
  | jq -r '.results[] | "\(.url)\t\(.title // .error.code)"'
```

## Comment vérifier mes crédits ?

Appelez `/credits` ; c'est gratuit. La réponse contient `credits_remaining`, `credits_used_today` et votre `concurrency_limit`. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

*Crédits restants*

```bash
curl -s "https://webreaderapi.com/api/v1/credits" -H "Authorization: Bearer $WEBREADER_API_KEY" | jq '.credits_remaining'
```

## Quelle est la version PowerShell sous Windows ?

`Invoke-RestMethod` analyse le JSON pour vous, donc jq n'est pas nécessaire. Construisez la requête avec `[uri]::EscapeDataString` pour encoder l'adresse de la page, et passez la clé dans une table headers.

*PowerShell : enregistrer une page*

```powershell
$headers = @{ Authorization = "Bearer $env:WEBREADER_API_KEY" }
$target = [uri]::EscapeDataString('https://example.com/guides/compost')
$page = Invoke-RestMethod -Uri "https://webreaderapi.com/api/v1/read?url=$target" -Headers $headers
$page.markdown | Out-File -Encoding utf8 compost.md
"$($page.title): $($page.word_count) words, $($page.credits_used) credit(s)"
```

## curl : questions fréquentes

### Pourquoi mon URL contenant & échoue-t-elle ?

Parce que le shell ou curl la découpe. Mettez l'argument `url=…` entier entre guillemets et passez-le avec `--data-urlencode`, comme dans les recettes ci-dessus ; curl encode alors `&`, `?` et `=` à l'intérieur de l'adresse de la page.

### Comment voir le statut HTTP d'une erreur ?

Ajoutez `-w '\n%{http_code}\n'` pour l'afficher après le corps, ou `-i` pour voir tous les headers. Le `error.code` du corps est la valeur stable à tester dans les scripts.

### Un appel échoué est-il facturé ?

Non. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Erreurs, refus liés à robots.txt et retries

> Codes d'erreur WebReaderAPI : refus robots.txt, refus du site, timeouts et erreurs de crédits, lesquels réessayer, et pourquoi aucun n'est jamais facturé.

- URL: https://webreaderapi.com/fr/docs/errors/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Chaque erreur possède un statut HTTP, un `code` stable et un `message` lisible. Aucune d'elles n'utilise de crédit. Certaines méritent une nouvelle tentative ; les refus émanant d'un site sont définitifs, et nous ne les contournons jamais.

**Réponse rapide — Que signifient les codes d'erreur de WebReaderAPI, et lesquels dois-je réessayer ?**

Les erreurs **WebReaderAPI** se répartissent en trois groupes, et aucune n'est jamais facturée. Les problèmes de requête (`invalid_url`, `invalid_api_key`, `insufficient_credits`) nécessitent une correction de votre côté. Les décisions du site (`blocked_by_robots`, `blocked_by_site_policy`, `target_refused`) sont définitives. Les échecs temporaires (`fetch_failed`, `fetch_timeout`, `concurrency_limit`) peuvent être réessayés avec un backoff. Les crédits commencent à 0,07 $US/1K pages, payés en crypto sans KYC.

## Quels codes d'erreur l'API peut-elle renvoyer ?

Le corps est toujours `{"error": {"code", "message"}}`, plus `target_status` lorsque le refus provient du site.

| HTTP | `code` | Cause | Réessayer ? |
| --- | --- | --- | --- |
| 400 | `invalid_url` | Ni http ni https, trop long, ou une adresse privée, locale ou de métadonnées cloud | Non : corrigez l'URL |
| 400 | `invalid_parameter` | Un paramètre a une valeur hors de sa liste ou de sa plage | Non : corrigez la requête |
| 401 | `invalid_api_key` | Clé absente, erronée ou révoquée | Non : vérifiez la clé |
| 402 | `insufficient_credits` | Votre solde n'a plus de crédits | Après l'achat d'un pack |
| 403 | `blocked_by_robots` | Le robots.txt du site interdit la page pour WebReaderAPI ou pour tous les robots | Non : définitif |
| 403 | `blocked_by_site_policy` | Le site déclare `Content-Signal: ai-input=no` | Non : définitif |
| 422 | `unsupported_content` | Un type que nous ne lisons pas (vidéo, archive) ou un fichier trop volumineux | Non |
| 429 | `concurrency_limit` | Trop de vos requêtes tournent en même temps | Oui, avec backoff |
| 502 | `target_refused` | Le site a refusé : 403, 429, une page de challenge ou un mur de connexion ; son statut est dans `target_status` | Non : définitif |
| 502 | `fetch_failed` | Erreur DNS, TLS ou de connexion, ou le site a répondu 404 ou 410 | Une ou deux fois, avec backoff |
| 504 | `fetch_timeout` | Le site n'a pas répondu dans les `timeout` | Oui, avec backoff ou un timeout plus long |

## Pourquoi les refus liés au robots.txt et au site sont-ils définitifs ?

Parce qu'ils relèvent de la décision du propriétaire du site, et WebReaderAPI est conçu pour la respecter. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous.

Quand un site refuse une requête autrement, par un 403, un 429, une page de challenge ou un formulaire de connexion, vous recevez `target_refused` et le statut du site dans `target_status`. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Réessayer la même URL une minute plus tard donnera généralement la même réponse : traitez donc ces codes comme un résultat, pas comme un échec : journalisez-les et passez à la suite.

## Comment vérifier pourquoi une page a été refusée ?

Ouvrez le `/robots.txt` du site et cherchez un groupe qui nomme `WebReaderAPI`, ou le groupe `*` qui s'applique à tous les robots. Une ligne `Disallow` qui correspond au chemin explique un `blocked_by_robots`. Une ligne comme `Content-Signal: ai-input=no` explique un `blocked_by_site_policy`.

Nous conservons une copie de chaque robots.txt pendant 24 heures au maximum. Si un site vient d'ouvrir une section aux robots, la modification peut prendre jusqu'à un jour pour s'appliquer. Les propriétaires de sites peuvent voir comment notre crawler se comporte, et comment l'autoriser ou le bloquer, sur [notre page crawler](https://webreaderapi.com/fr/bot/).

## Comment réessayer les échecs temporaires ?

Réessayez uniquement `concurrency_limit`, `fetch_timeout` et, une ou deux fois, `fetch_failed`. Attendez avant chaque nouvelle tentative et doublez l'attente à chaque fois, avec un léger jitter aléatoire pour que les workers parallèles ne réessaient pas ensemble. Arrêtez après 4 ou 5 tentatives.

Pour `concurrency_limit`, la meilleure solution est d'envoyer moins de requêtes à la fois : Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter. Pour `fetch_timeout`, augmentez `timeout` jusqu'à 60 secondes avant de réessayer un site lent. Les tentatives ne coûtent rien, car une tentative échouée n'est jamais facturée.

*Python : ne réessayer que les erreurs qui peuvent changer*

```python
import os
import random
import time

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
RETRY = {"concurrency_limit", "fetch_timeout", "fetch_failed"}
FINAL = {"blocked_by_robots", "blocked_by_site_policy", "target_refused", "unsupported_content"}


def read_page(url, attempts=5, **options):
    wait = 1.0
    for attempt in range(1, attempts + 1):
        resp = requests.get(API, headers=HEADERS, params={"url": url, **options}, timeout=75)
        if resp.status_code == 200:
            return resp.json()
        error = resp.json().get("error", {})
        code = error.get("code", "unknown")
        if code in FINAL:
            return {"url": url, "skipped": code, "target_status": error.get("target_status")}
        if code not in RETRY or attempt == attempts or (code == "fetch_failed" and attempt >= 3):
            raise RuntimeError(f"{code}: {error.get('message')}")
        time.sleep(wait + random.uniform(0, wait / 2))
        wait = min(wait * 2, 30)
    raise RuntimeError("unreachable")


if __name__ == "__main__":
    print(read_page("https://example.com/blog/first-post", max_chars=20000).get("title"))

```

*Node.js : la même règle avec backoff exponentiel*

```javascript
const RETRY = new Set(['concurrency_limit', 'fetch_timeout', 'fetch_failed']);
const FINAL = new Set(['blocked_by_robots', 'blocked_by_site_policy', 'target_refused', 'unsupported_content']);
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

export async function readPage(url, options = {}, attempts = 5) {
  let wait = 1000;
  for (let attempt = 1; attempt <= attempts; attempt++) {
    const params = new URLSearchParams({ url, ...options });
    const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
      headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
    });
    const body = await res.json();
    if (res.ok) return body;
    const code = body.error?.code ?? 'unknown';
    if (FINAL.has(code)) return { url, skipped: code, target_status: body.error.target_status };
    if (!RETRY.has(code) || attempt === attempts) throw new Error(`${code}: ${body.error?.message}`);
    await sleep(wait + Math.random() * (wait / 2));
    wait = Math.min(wait * 2, 30000);
  }
}

```

## Et les erreurs au sein d'un batch ou d'un crawl ?

Un job ne s'arrête pas parce qu'une page échoue. Cette page apparaît dans `results` comme `{url, error}` avec les mêmes codes que ci-dessus, et elle ne coûte rien. Un crawl qui rencontre `blocked_by_robots` sur une section lit simplement le reste du site.

À la fin d'un job, comptez les codes d'erreur. Beaucoup de `target_refused` sur un même site signifient que le site n'accepte pas les lecteurs automatisés ; beaucoup de `fetch_timeout` signifient qu'il est lent, et un `timeout` plus long dans les options du job peut aider.

## Erreurs : questions fréquentes

### Suis-je facturé pour une page bloquée par robots.txt ?

Non. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Il en va de même pour toutes les autres erreurs de cette page.

### Pouvez-vous lire une page qui bloque votre crawler si je vous le demande ?

Non. Nous respectons le choix du propriétaire du site, et la politique est la même pour tous les clients. Si vous êtes propriétaire du site, ajoutez une règle pour `WebReaderAPI` dans votre robots.txt ; la [page du crawler](https://webreaderapi.com/fr/bot/) montre comment faire.

### Pourquoi est-ce que j'obtiens fetch_failed pour une page qui existe ?

Le site était peut-être indisponible, lent à accepter une connexion TLS ou renvoyait un 404 aux clients automatisés. Réessayez une ou deux fois avec un backoff. Si l'échec persiste, vérifiez l'adresse dans un navigateur.

### Que doit dire mon agent à l'utilisateur après un refus ?

Quelque chose de simple, par exemple que le site n'autorise pas la lecture automatisée de cette page. Laissez ensuite le modèle utiliser d'autres sources. Renvoyer le code d'erreur comme résultat de l'outil suffit pour la plupart des modèles.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# LangChain et LlamaIndex : un chargeur de pages web et un outil read_url

> Chargeur pages web LangChain LlamaIndex : outil read_url, document loader et index RAG depuis un crawl en Python. Sans KYC, payez en crypto.

- URL: https://webreaderapi.com/fr/docs/langchain/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Deux façons d'utiliser l'API dans une stack IA Python : charger des pages comme documents pour la recherche, ou donner à un agent un outil `read_url`. Les mêmes 20 lignes de glue servent LangChain et LlamaIndex.

**Réponse rapide — Comment charger des pages web dans LangChain ou LlamaIndex en Markdown propre ?**

Appelez l'endpoint `/read` de **WebReaderAPI** et enveloppez chaque réponse dans un `Document` : le Markdown comme contenu, `final_url` et le titre comme metadata. Pour les agents, exposez le même appel comme outil `read_url`. Chaque page coûte 1 crédit, 2 avec un navigateur, à partir de 0,07 $US/1K pages en octobre 2026. Aucun package de notre part n'est nécessaire. Sans KYC ; payez en crypto.

## Pourquoi des documents Markdown plutôt que du HTML brut ?

Parce que la recherche fonctionne sur du texte, et que le Markdown conserve la structure qui compte tout en supprimant le reste. Les titres survivent, donc un splitter peut découper selon les changements de sujet. Les listes et les tableaux survivent, donc les étapes et les spécifications restent ensemble. La navigation, les bannières de cookies et les publicités disparaissent, donc elles ne polluent pas vos embeddings et ne gaspillent pas de tokens.

Les metadata viennent du même appel : `final_url` comme source à citer, `title`, `published_at` et `language` pour filtrer.

*reader.py : le helper partagé (enregistrez-le à côté de votre code)*

```python
import os

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


class PageError(Exception):
    pass


def read_page(url, **options):
    resp = requests.get(API, headers=HEADERS, params={"url": url, **options}, timeout=75)
    body = resp.json()
    if resp.status_code != 200:
        raise PageError(body["error"]["code"])
    return body

```

## Comment construire un document loader LangChain ?

Transformez chaque page en `langchain_core.documents.Document`, puis découpez-la par titres avec `MarkdownHeaderTextSplitter` du package `langchain-text-splitters`. Chaque chunk conserve le chemin de titres dans ses metadata, et vous ajoutez l'URL source pour que chaque réponse puisse renvoyer à sa page.

Les pages ignorées, comme celles refusées par robots.txt, lèvent `PageError` avec le code ; journalisez-les et continuez.

*LangChain : charger et découper des pages*

```python
from langchain_core.documents import Document
from langchain_text_splitters import MarkdownHeaderTextSplitter

from reader import PageError, read_page

splitter = MarkdownHeaderTextSplitter(headers_to_split_on=[("#", "h1"), ("##", "h2"), ("###", "h3")])


def load_pages(urls):
    chunks = []
    for url in urls:
        try:
            page = read_page(url)
        except PageError as exc:
            print("skipped", url, exc)
            continue
        for part in splitter.split_text(page["markdown"]):
            part.metadata.update({"source": page["final_url"], "title": page.get("title", "")})
            chunks.append(part)
    return chunks


docs = load_pages(["https://example.com/docs/install", "https://example.com/docs/configure"])
print(len(docs), "chunks", isinstance(docs[0], Document) if docs else "")

```

## Comment donner à un agent LangChain un outil read_url ?

Décorez une fonction avec `@tool` de `langchain_core.tools`. La docstring devient la description de l'outil que lit le modèle, alors indiquez ce que l'outil renvoie et quand l'utiliser. Renvoyez du texte brut : une ligne de titre, la source et le Markdown, coupé avec `max_chars` selon votre modèle.

Liez l'outil à n'importe quel chat model qui prend en charge le tool calling, ou passez-le au constructeur de votre agent. Le modèle appelle ensuite `read_url` avec une URL issue de la conversation ou d'un résultat de recherche.

*LangChain : l'outil read_url*

```python
import os

from langchain.chat_models import init_chat_model
from langchain_core.tools import tool

from reader import PageError, read_page


@tool
def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown, with its title and source URL."""
    try:
        page = read_page(url, max_chars=max_chars)
    except PageError as exc:
        return "Could not read the page: " + str(exc)
    return "# " + (page.get("title") or url) + "\nSource: " + page["final_url"] + "\n\n" + page["markdown"]


model = init_chat_model(os.environ.get("CHAT_MODEL", "openai:gpt-4.1-mini")).bind_tools([read_url])
reply = model.invoke("Summarise https://example.com/blog/first-post in three bullet points.")
print(reply.tool_calls)

```

## Comment faire la même chose dans LlamaIndex ?

LlamaIndex utilise sa propre classe `Document` avec `text` et `metadata`, et `FunctionTool.from_defaults` pour transformer une fonction en outil. Le helper reste le même. Construisez un index à partir des documents avec `VectorStoreIndex.from_documents`, qui utilise le modèle d'embedding nommé dans vos réglages LlamaIndex.

*LlamaIndex : indexer un crawl, et un outil read_url*

```python
import os
import time

import requests
from llama_index.core import Document, VectorStoreIndex
from llama_index.core.tools import FunctionTool

from reader import HEADERS, PageError, read_page


def crawl_pages(start_url, limit=200):
    job = requests.post("https://webreaderapi.com/api/v1/crawl", headers=HEADERS, json={"url": start_url, "limit": limit}, timeout=30).json()
    pages, cursor = [], None
    while True:
        params = {"cursor": cursor} if cursor else {}
        res = requests.get("https://webreaderapi.com/api/v1/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=30).json()
        pages += [r for r in res["results"] if "error" not in r]
        cursor = res.get("next_cursor")
        if not cursor and res["status"] == "done":
            return pages
        if not cursor:
            time.sleep(5)


pages = crawl_pages("https://docs.example.com/")
docs = [Document(text=p["markdown"], metadata={"source": p["final_url"], "title": p.get("title", "")}) for p in pages]
index = VectorStoreIndex.from_documents(docs)
print(index.as_query_engine().query("How do I install the product?"))


def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown."""
    try:
        return read_page(url, max_chars=max_chars)["markdown"]
    except PageError as exc:
        return "Could not read the page: " + str(exc)


read_tool = FunctionTool.from_defaults(fn=read_url, name="read_url")
print(os.environ.get("CHAT_MODEL", "set CHAT_MODEL for your agent"), read_tool.metadata.name)

```

## Quelle taille de crawl faut-il pour un petit index RAG ?

Moins que vous ne le pensez. La documentation d'un produit fait souvent quelques centaines de pages, et un crawl avec `include_paths` réglé sur la section docs ne lit que celles-là. À 1 crédit la page, un site de docs de 300 pages coûte environ 300 crédits ; 10 000 pages (3,75 $US) le rafraîchit de nombreuses fois.

Relancez le crawl selon un rythme qui correspond à la fréquence de modification de la source, et comparez `final_url` et `word_count` avec l'exécution précédente pour ne ré-embedder que les pages qui ont changé. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

## LangChain et LlamaIndex : questions fréquentes

### Existe-t-il un package WebReaderAPI pour LangChain ou LlamaIndex ?

Non. Le helper et l'outil de cette page constituent toute l'intégration, vous pouvez donc les adapter librement. WebReaderAPI est une API HTTPS simple que n'importe quel client HTTP Python peut appeler.

### Quelle version de LangChain faut-il ?

N'importe quelle version récente avec `langchain_core`, `langchain-text-splitters` et `init_chat_model`. Le décorateur d'outil et la classe `Document` sont stables depuis plusieurs versions récentes.

### Comment éviter de relire les pages qui n'ont pas changé ?

Stockez `final_url`, `word_count` et la date de chaque lecture. Relisez selon un rythme planifié, et ne ré-embeddez une page que lorsque son nombre de mots ou son hash de contenu change. Chaque relecture coûte un crédit, choisissez donc un rythme adapté à la source.

### Et si certaines pages sont refusées ?

Elles lèvent `PageError` avec un code tel que `blocked_by_robots`, et elles ne coûtent rien. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Serveur MCP de lecture de pages web pour Claude, Cursor et autres clients MCP

> Serveur MCP lecture de pages web pour Claude Desktop, Cursor : outil read_url Python de 40 lignes qui renvoie du Markdown propre. Sans KYC, payez en crypto.

- URL: https://webreaderapi.com/fr/docs/mcp/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Donnez à n'importe quel client MCP un outil `read_url` qui transforme un lien en Markdown propre. Le serveur est un court fichier Python que vous exécutez sur votre propre machine ; votre clé API reste dans son environnement.

**Réponse rapide — Comment ajouter un lecteur de pages web à Claude Desktop ou Cursor avec MCP ?**

Lancez un petit serveur MCP qui expose un outil `read_url` appelant **WebReaderAPI**, puis enregistrez-le dans les paramètres MCP de votre client avec votre clé dans `env`. Le modèle peut alors lire n'importe quelle page publique en Markdown propre. Chaque page lue coûte 1 crédit, 2 avec un navigateur, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## Le serveur MCP en bref

| Attribut | Valeur |
| --- | --- |
| Langage | Python 3.10+, avec les packages `mcp` et `httpx` |
| Transport | stdio : le client démarre le serveur comme processus local |
| Outil | `read_url(url, max_chars)` → titre, URL source, puis le Markdown de la page |
| Pourquoi pas web_fetch | Claude Code et OpenClaw embarquent déjà un outil intégré portant ce nom |
| Clé | Lue depuis `WEBREADER_API_KEY` dans l'environnement du serveur |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |

## Pourquoi un outil read_url et pas web_fetch ?

Parce que deux outils du même nom perturbent à la fois le client et le modèle. Claude Code et OpenClaw incluent déjà un outil nommé `web_fetch`. Un nom distinct, `read_url`, et une description claire permettent au modèle de choisir le nôtre lorsqu'il a besoin du contenu principal d'une page, pages JavaScript et PDF compris.

L'outil renvoie du texte, pas du JSON. Les modèles traitent mieux un court en-tête et du Markdown que des champs imbriqués, et l'en-tête garde l'URL source visible pour que la réponse puisse la citer.

*webreader_mcp.py*

```python
import os

import httpx
from mcp.server.fastmcp import FastMCP

API = "https://webreaderapi.com/api/v1/read"
KEY = os.environ["WEBREADER_API_KEY"]
mcp = FastMCP("webreaderapi")


@mcp.tool()
def read_url(url: str, max_chars: int = 20000) -> str:
    """Read a public web page and return its main content as Markdown.

    Use it when the user gives a link or when a page must be read to answer.
    max_chars caps the length of the returned text (1,000 to 500,000).
    """
    params = {"url": url, "max_chars": max(1000, min(int(max_chars), 500000))}
    try:
        resp = httpx.get(API, params=params, headers={"Authorization": "Bearer " + KEY}, timeout=75)
    except httpx.HTTPError as exc:
        return "Network error while reading the page: " + str(exc)
    body = resp.json()
    if resp.status_code != 200:
        err = body.get("error", {})
        return "Could not read the page: " + err.get("code", str(resp.status_code)) + ". " + err.get("message", "")
    title = body.get("title") or url
    return "# " + title + "\nSource: " + body.get("final_url", url) + "\n\n" + body.get("markdown", "")


if __name__ == "__main__":
    mcp.run()

```

## Comment installer et tester le serveur ?

Créez un environnement virtuel, installez `mcp` et `httpx`, puis enregistrez le fichier ci-dessus. Le package `mcp` est le SDK Python officiel du Model Context Protocol ; `FastMCP` transforme une fonction Python typée en outil, en utilisant la docstring comme description.

Avant de le brancher dans un client, exécutez le fichier une fois depuis un terminal avec votre clé définie. Il attend silencieusement un client sur stdin, ce qui signifie qu'il a démarré correctement ; arrêtez-le avec Ctrl+C.

*Installation*

```bash
python -m venv .venv
. .venv/bin/activate
pip install "mcp[cli]" httpx
WEBREADER_API_KEY="your-key" python webreader_mcp.py
```

## Comment l'enregistrer dans Claude Desktop ?

Ouvrez les paramètres développeur de Claude Desktop, modifiez `claude_desktop_config.json` et ajoutez une entrée sous `mcpServers`. Utilisez des chemins absolus : le Python de votre environnement virtuel et le fichier du serveur. Placez la clé dans `env`, pour qu'elle n'apparaisse jamais dans les arguments de l'outil ni dans la conversation. Redémarrez Claude Desktop, et `read_url` apparaît dans la liste des outils.

Cursor lit la même structure `mcpServers` depuis son propre fichier de configuration MCP, et Claude Code peut enregistrer la même commande avec sa commande `claude mcp add`. Pour OpenClaw, voir la [page OpenClaw](https://webreaderapi.com/fr/docs/openclaw/).

*claude_desktop_config.json*

```json
{
  "mcpServers": {
    "webreaderapi": {
      "command": "/home/you/webreader/.venv/bin/python",
      "args": ["/home/you/webreader/webreader_mcp.py"],
      "env": { "WEBREADER_API_KEY": "your-key" }
    }
  }
}
```

## Comment garder les pages dans le contexte du modèle ?

Baissez `max_chars`. La valeur par défaut de 20 000 caractères suffit pour la plupart des articles et évite qu'une longue page ne sature le contexte. Un modèle qui lit plusieurs pages dans une même réponse s'en sort mieux avec 8 000 à 12 000 par page.

Demandez au modèle de lire les pages dont il a besoin, pas tous les liens qu'il voit. Une phrase courte dans les instructions de votre projet, comme « lire au maximum trois pages par question », maîtrise à la fois le coût et le contexte.

## Que se passe-t-il quand un site refuse la lecture ?

L'outil renvoie un court message avec le code d'erreur, tel que `blocked_by_robots` ou `target_refused`, et rien n'est facturé. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Le modèle peut alors indiquer que la page n'est pas accessible aux lecteurs automatisés et utiliser une autre source.

## Serveur MCP : questions fréquentes

### Existe-t-il un package MCP officiel WebReaderAPI ?

Non. Le fichier de cette page est l'intégration : 40 lignes que vous pouvez lire, modifier et exécuter vous-même. Rien à installer de notre côté, et votre clé ne quitte jamais votre machine, sauf dans les appels à notre API.

### Le modèle peut-il faire une recherche web avec ce serveur ?

Non. `read_url` lit une page dont vous ou le modèle avez déjà l'adresse. Associez-le à n'importe quel outil de recherche proposé par votre client ; le modèle cherche, puis lit les pages qui comptent.

### Combien coûte l'usage d'un assistant avec ce serveur ?

Un crédit par page lue, deux lorsqu'un navigateur est nécessaire. Un assistant qui lit 50 pages par jour utilise environ 1 500 crédits par mois, et 10 000 pages (3,75 $US) couvre cela pendant environ six mois.

### Le serveur fonctionne-t-il hors ligne ?

Non. Il appelle `https://webreaderapi.com/api/v1/read` pour chaque page, il lui faut donc un accès internet et une clé valide.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Lire des pages web dans les agents IA n8n avec WebReaderAPI

> Lire des pages web dans les agents IA n8n : réglages de l'outil HTTP Request qui transforment une URL en Markdown propre. Sans KYC, payez en crypto.

- URL: https://webreaderapi.com/fr/docs/n8n/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Le node HTTP Request de n8n peut servir d'outil à son node AI Agent. Indiquez-lui `/read`, laissez le modèle remplir l'URL, et l'agent peut lire n'importe quelle page publique en Markdown propre, sans aucun node communautaire à installer.

**Réponse rapide — Comment faire lire des pages web à un agent IA n8n ?**

Attachez un node HTTP Request au AI Agent de n8n en tant qu'outil, réglez-le sur `GET https://webreaderapi.com/api/v1/read` avec une credential Header Auth contenant votre clé **WebReaderAPI**, et laissez le modèle définir le paramètre `url`. Activez Optimize Response pour ne garder que `title`, `final_url` et `markdown`. Chaque page coûte 1 crédit, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## Quels réglages HTTP Request dois-je utiliser ?

Les noms des options suivent la documentation du node HTTP Request de n8n, consultée le 2026-10-22.

| Réglage | Valeur |
| --- | --- |
| Placement | Attaché au node **AI Agent** comme outil |
| Method | `GET` |
| URL | `https://webreaderapi.com/api/v1/read` |
| Authentification | Generic credentials → **Header Auth** |
| Credential Header Auth | Name `Authorization`, Value `Bearer ` suivi de votre clé API |
| Send Query Parameters | On, **Using Fields Below** |
| Paramètre `url` | Défini par le modèle (voir ci-dessous) |
| Paramètre `max_chars` | Une valeur fixe comme `15000` |
| Optimize Response | On · type de réponse **JSON** · Include Fields **Selected** : `title`, `final_url`, `markdown` |

## Pourquoi utiliser le node HTTP Request comme outil ?

Parce qu'il fait déjà tout ce dont cette API a besoin : une requête GET, un header et deux paramètres de requête. n8n documente que le node HTTP Request peut s'exécuter comme node classique ou être attaché à un agent IA comme outil, et que certaines options n'existent que dans la forme outil.

Il n'y a rien de notre côté à installer ou à mettre à jour, et la clé réside dans le credential store de n8n plutôt que dans le workflow. Donnez à n8n sa propre clé, afin que son usage soit visible séparément de vos autres scripts et que vous puissiez la révoquer seule. Créez plusieurs clés API, par exemple une par agent ou par projet, et révoquez n'importe laquelle depuis votre dashboard.

## Comment le modèle choisit-il l'URL à lire ?

Laissez le modèle définir le paramètre `url`. n8n affiche un bouton à côté des champs de paramètre éligibles qui confie la valeur au modèle, et vous pouvez aussi écrire l'expression vous-même avec la fonction `$fromAI()` de n8n. Elle prend une clé, une description, un type et une valeur par défaut facultative, par exemple la clé `url`, la description "The http or https address of the page to read" et le type `string`.

n8n documente que `$fromAI()` ne fonctionne que dans les outils connectés au node AI Agent. Rédigez aussi la description de l'outil en mots simples, comme "Reads a public web page and returns its main content as Markdown", pour que l'agent sache quand l'appeler.

## Pourquoi activer Optimize Response ?

Parce que tout ce que renvoie un outil entre dans le contexte du modèle. Optimize Response est une option réservée aux outils qui réduit les données transmises au modèle. Avec le type de réponse JSON, vous pouvez n'inclure que les champs sélectionnés ; gardez `title`, `final_url` et `markdown` et abandonnez le reste.

Limitez la longueur de notre côté avec `max_chars`, qui coupe le Markdown avant qu'il ne quitte l'API. Les types de réponse HTML et Text du node ont leur propre option Truncate Response, mais avec notre réponse JSON, `max_chars` est le contrôle le plus simple.

## Comment utiliser l'API dans un workflow planifié ?

Utilisez le node HTTP Request comme node classique, pas comme outil, derrière un Schedule Trigger. Donnez-lui un `url` fixe, par exemple un changelog ou une page de tarifs que vous suivez, et envoyez le champ `markdown` au node suivant : un fichier, une base de données, un message de chat ou une comparaison avec l'exécution précédente.

Chaque exécution lit une page par URL. Surveiller 20 pages une fois par jour consomme environ 600 crédits par mois pour les pages sans navigateur, donc 10 000 pages (3,75 $US) dure plus d'un an. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

## Que se passe-t-il quand un site refuse la lecture ?

Le node reçoit une réponse d'erreur avec un code comme `blocked_by_robots` ou `target_refused`, et rien n'est facturé. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Dans un agent, laissez l'outil renvoyer l'erreur pour que le modèle puisse l'expliquer ou essayer une autre source ; dans un workflow planifié, acheminez les erreurs vers une branche qui les journalise. La [page errors](https://webreaderapi.com/fr/docs/errors/) liste tous les codes.

## Puis-je tester l'appel avant de construire le workflow ?

Exécutez le même appel dans un terminal avec curl, comme montré dans les [recettes curl](https://webreaderapi.com/fr/docs/curl/). S'il fonctionne là-bas et échoue dans n8n, la cause est dans les réglages du node, le plus souvent la valeur de la credential sans le préfixe `Bearer ` ou le paramètre `url` laissé vide.

## n8n : questions fréquentes

### Ai-je besoin d'un node communautaire pour WebReaderAPI ?

Non. Le node HTTP Request intégré suffit, comme outil pour le AI Agent ou comme node classique dans n'importe quel workflow.

### L'agent peut-il lire des pages JavaScript ou des PDF ?

Oui. L'API décide quand un navigateur est nécessaire (`render=auto`) et lit les PDF comme du texte. Une page rendue utilise 2 crédits ; Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

### Comment empêcher l'agent de lire trop de pages ?

Indiquez dans le message système de l'agent combien de pages il peut lire, et gardez `max_chars` modeste. Chaque lecture est un appel d'outil, donc toute limite que vous fixez sur les appels d'outils de l'agent plafonne aussi le nombre de pages.

### Comment payer des crédits ?

Rechargez depuis 25 $US en BTC, USDT, USDC, ETH, SOL, LTC, puis achetez un pack. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni documents d'entreprise.

## Sources

1. [Nœud HTTP Request](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/) — n8n docs (read 2026-10-22)
2. [Identifiants HTTP Request](https://docs.n8n.io/integrations/builtin/credentials/httprequest/) — n8n docs (read 2026-10-22)
3. [Nœud AI Agent](https://docs.n8n.io/integrations/builtin/cluster-nodes/root-nodes/n8n-nodes-langchain.agent/) — n8n docs (read 2026-10-22)
4. [Laisser l'IA spécifier les paramètres d'outil avec $fromAI()](https://docs.n8n.io/advanced-ai/examples/using-the-fromai-function/) — n8n docs (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Page web en Markdown dans Node.js

> Convertissez des pages web en Markdown dans Node.js : une page, un pool de concurrence et une boucle de polling. Depuis 0,07 $US/1K pages, sans KYC, en crypto.

- URL: https://webreaderapi.com/fr/docs/node/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Node.js 18 et les versions suivantes embarquent `fetch`, donc vous n'avez besoin d'aucune dépendance. Trois recettes : lire une page, lire une liste avec un petit pool de concurrence, et suivre un job de crawl jusqu'à sa fin.

**Réponse rapide — Comment convertir une page web en Markdown dans Node.js ?**

Utilisez le `fetch` intégré de Node.js 18+ : appelez `https://webreaderapi.com/api/v1/read?url=…` avec votre clé dans l'en-tête `Authorization` et lisez `markdown` dans la réponse JSON. **WebReaderAPI** renvoie le contenu principal de la page avec son titre, son auteur et sa date. Une page coûte 1 crédit, 2 avec un navigateur, depuis 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## De quoi ai-je besoin ?

Node.js 18 ou plus récent, pour le `fetch` global, et une clé API dans la variable d'environnement `WEBREADER_API_KEY`. Les exemples sont des modules ES : enregistrez-les avec l'extension `.mjs`, ou définissez `"type": "module"` dans votre `package.json`, pour que le `await` de haut niveau fonctionne.

Les commentaires JSDoc décrivent la forme de la réponse, donc des éditeurs comme VS Code vous offrent la complétion sans étape de build TypeScript.

*read.mjs : une page*

```javascript
/**
 * @typedef {Object} Page
 * @property {string} url
 * @property {string} final_url
 * @property {number} status_code
 * @property {boolean} rendered
 * @property {number} credits_used
 * @property {string} [title]
 * @property {string} [author]
 * @property {string} [published_at]
 * @property {string} [language]
 * @property {string} [markdown]
 * @property {number} word_count
 */

/** @returns {Promise<Page>} */
export async function readPage(url, options = {}) {
  const params = new URLSearchParams({ url, ...options });
  const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
    headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
    signal: AbortSignal.timeout(75_000),
  });
  const body = await res.json();
  if (!res.ok) throw Object.assign(new Error(body.error.message), { code: body.error.code });
  return body;
}

const page = await readPage('https://example.com/docs/getting-started', { max_chars: '20000' });
console.log(page.title, page.word_count, 'words,', page.credits_used, 'credit(s)');

```

## Comment lire une liste d'URL sans atteindre la limite ?

Lancez un nombre fixe de workers qui prennent des URL dans une file partagée. C'est plus simple que `Promise.all` sur toute la liste, ce qui lancerait toutes les requêtes à la fois et atteindrait `429 concurrency_limit`. Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter.

Le pool ci-dessous garde les erreurs à côté des résultats, donc une page refusée n'arrête pas l'exécution. Les refus comme `blocked_by_robots` sont définitifs et gratuits ; comptez-les et passez à la suite.

*pool.mjs : une liste d'URL, 8 à la fois*

```javascript
import { readPage } from './read.mjs';

export async function readAll(urls, workers = 8) {
  const queue = [...urls];
  const results = [];
  async function worker() {
    while (queue.length) {
      const url = queue.shift();
      try {
        const page = await readPage(url, { max_chars: '50000' });
        results.push({ url, page });
      } catch (err) {
        results.push({ url, error: err.code ?? err.name });
      }
    }
  }
  await Promise.all(Array.from({ length: workers }, worker));
  return results;
}

const urls = Array.from({ length: 30 }, (_, i) => `https://example.com/blog/post-${i + 1}`);
for (const r of await readAll(urls)) console.log(r.url, '->', r.error ?? r.page.title);

```

## Comment suivre un job de crawl dans Node.js ?

Démarrez le job avec `POST https://webreaderapi.com/api/v1/crawl`, puis lisez `https://webreaderapi.com/api/v1/jobs/{job_id}` dans une boucle. Passez `cursor` à chaque fois que `next_cursor` revient ; quand il n'y a pas de curseur et que le statut est `done`, le job est terminé. Attendez entre les polls vides et doublez l'attente jusqu'à 30 secondes, car un crawl qui respecte le Crawl-delay d'un site peut être lent.

La [page batch and crawl](https://webreaderapi.com/fr/docs/crawl/) décrit comment le crawl choisit ses pages et comment `limit` plafonne ce qu'il lit.

*crawl.mjs : démarrer un crawl et collecter chaque page*

```javascript
const headers = {
  Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`,
  'Content-Type': 'application/json',
};
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

const start = await fetch('https://webreaderapi.com/api/v1/crawl', {
  method: 'POST',
  headers,
  body: JSON.stringify({ url: 'https://docs.example.com/', limit: 300, include_paths: ['/docs/*'] }),
});
const { job_id } = await start.json();

const pages = [];
let cursor = '';
let wait = 2000;
for (;;) {
  const url = `https://webreaderapi.com/api/v1/jobs/${job_id}${cursor ? `?cursor=${encodeURIComponent(cursor)}` : ''}`;
  const job = await (await fetch(url, { headers })).json();
  pages.push(...job.results.filter((r) => !r.error));
  if (job.next_cursor) {
    cursor = job.next_cursor;
    wait = 2000;
    continue;
  }
  if (job.status === 'done') break;
  await sleep(wait);
  wait = Math.min(wait * 2, 30000);
}
console.log(pages.length, 'pages read, job', job_id);

```

## Comment passer le résultat à un modèle ?

Envoyez le Markdown, pas le JSON entier. Le champ `markdown` est ce qu'un modèle doit lire ; les métadonnées sont mieux gardées pour les citations. Préfixez avec le titre et `final_url`, pour que le modèle puisse nommer sa source, et gardez `max_chars` à une taille que le contexte de votre modèle peut contenir, par exemple 20 000 caractères par page.

La [page OpenAI function calling](https://webreaderapi.com/fr/docs/openai/) montre la boucle d'outil complète en Python ; la même fonction `readPage` ci-dessus peut servir de corps d'outil dans un agent Node.js.

## Node.js : questions fréquentes

### Est-ce que cela fonctionne dans Deno, Bun ou le navigateur ?

Deno et Bun prennent en charge le même `fetch` et les modules ES. N'appelez pas l'API depuis une page de navigateur : la clé serait visible par chaque visiteur. Appelez-la depuis votre serveur à la place.

### Existe-t-il un package npm ?

Non. Les fonctions de cette page constituent l'intégration complète. WebReaderAPI est du HTTPS et du JSON simples, donc vous gardez le contrôle des retries, des timeouts et du logging.

### Comment gérer 429 concurrency_limit ?

Réduisez le nombre de workers, ou réessayez après une courte attente qui double à chaque fois. Un 429 ne coûte rien, et la [page errors](https://webreaderapi.com/fr/docs/errors/) propose une fonction de backoff prête à l'emploi.

### Combien coûte la lecture de 10 000 pages ?

Environ 10 000 crédits pour des pages simples, davantage si certaines nécessitent un navigateur. 10 000 pages coûtent 3,75 $US ; Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# OpenAI function calling : un outil read_url pour votre modèle

> OpenAI function calling avec un outil read_url : le schéma JSON et la boucle Python qui transforme les liens en Markdown propre pour le modèle.

- URL: https://webreaderapi.com/fr/docs/openai/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Décrivez une fonction, `read_url`, et exécutez-la quand le modèle le demande. Le modèle choisit quelles pages lire ; votre code appelle l'API et renvoie le Markdown. Le même schéma fonctionne avec d'autres modèles qui prennent en charge le tool calling.

**Réponse rapide — Comment permettre à un modèle OpenAI de lire des pages web avec le function calling ?**

Déclarez une fonction `read_url` dans la liste `tools`, puis exécutez une boucle : lorsque le modèle renvoie un appel d'outil, appelez l'endpoint `/read` de **WebReaderAPI** avec l'URL et renvoyez le Markdown dans un message `tool`. Chaque page coûte 1 crédit, 2 avec un navigateur, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## À quoi ressemble le schéma read_url ?

Deux paramètres suffisent : l'`url` à lire, obligatoire, et un `max_chars` facultatif qui permet au modèle de raccourcir une page longue. La description est l'élément le plus important : elle indique au modèle ce que l'outil renvoie et quand l'utiliser. Restez factuel et bref.

Nous nommons l'outil `read_url` plutôt que `web_fetch` pour éviter un conflit avec des outils que certains environnements d'exécution d'agents fournissent déjà sous ce nom.

*La définition de l'outil*

```json
{
  "type": "function",
  "function": {
    "name": "read_url",
    "description": "Read a public web page and return its main content as Markdown, with its title and source URL. Use it when the user gives a link or when a page must be read to answer.",
    "parameters": {
      "type": "object",
      "properties": {
        "url": { "type": "string", "description": "The http or https address of the page." },
        "max_chars": { "type": "integer", "description": "Most characters to return, 1000 to 500000. Default 20000." }
      },
      "required": ["url"],
      "additionalProperties": false
    }
  }
}
```

## Comment fonctionne la boucle de function calling ?

Envoyez la conversation avec la liste `tools`. Si la réponse contient des appels d'outils, exécutez chacun d'eux, ajoutez le résultat sous forme de message avec le rôle `tool` et le `tool_call_id` correspondant, puis interrogez à nouveau le modèle. Une réponse sans appel d'outil est la réponse finale.

Limitez le nombre de tours. Trois ou quatre suffisent pour une question portant sur quelques pages, et cette limite vous protège d'un modèle qui en redemande sans cesse.

*Python : la boucle complète avec le package openai*

```python
import json
import os

import requests
from openai import OpenAI

READ_URL = {
    "type": "function",
    "function": {
        "name": "read_url",
        "description": "Read a public web page and return its main content as Markdown, with its title and source URL.",
        "parameters": {
            "type": "object",
            "properties": {
                "url": {"type": "string", "description": "The http or https address of the page."},
                "max_chars": {"type": "integer", "description": "Most characters to return. Default 20000."},
            },
            "required": ["url"],
            "additionalProperties": False,
        },
    },
}


def read_url(url, max_chars=20000):
    resp = requests.get(
        "https://webreaderapi.com/api/v1/read",
        headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
        params={"url": url, "max_chars": max_chars},
        timeout=75,
    )
    body = resp.json()
    if resp.status_code != 200:
        return "Could not read the page: " + body["error"]["code"]
    return "# " + (body.get("title") or url) + "\nSource: " + body["final_url"] + "\n\n" + body["markdown"]


client = OpenAI()
model = os.environ.get("OPENAI_MODEL", "gpt-4.1-mini")
messages = [{"role": "user", "content": "What does https://example.com/blog/first-post announce? Answer in two sentences."}]

for _ in range(4):
    reply = client.chat.completions.create(model=model, messages=messages, tools=[READ_URL])
    msg = reply.choices[0].message
    if not msg.tool_calls:
        print(msg.content)
        break
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({"role": "tool", "tool_call_id": call.id, "content": read_url(**args)})

```

## Comment réduire la consommation de tokens et le coût ?

Trois réglages comptent. Gardez `max_chars` modeste, autour de 8 000 à 20 000 caractères par page, car chaque caractère renvoyé est lu par le modèle. Conservez l'`main_content=true` par défaut, pour que les menus et pieds de page n'atteignent jamais le contexte. Et limitez la boucle, comme ci-dessus, afin qu'une seule question ne déclenche pas des dizaines de lectures.

De notre côté, le coût se compte par page, pas par caractère : 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Un assistant de support qui lit 300 pages par jour consomme environ 9 000 crédits par mois, compris dans 10 000 pages (3,75 $US).

## Le schéma fonctionne-t-il avec d'autres modèles ?

Oui, avec de petits ajustements dans le wrapper. La plupart des API de function calling acceptent un JSON Schema pour les paramètres, ainsi qu'un nom et une description pour l'outil ; `read_url` se transmet donc tel quel d'un fournisseur à l'autre. La [page MCP](https://webreaderapi.com/fr/docs/mcp/) prépare la même fonction pour les clients qui parlent le Model Context Protocol, et la [page LangChain](https://webreaderapi.com/fr/docs/langchain/) l'enveloppe pour les agents LangChain et LlamaIndex.

## Que doit voir le modèle lorsqu'une page est refusée ?

Une phrase courte et claire, telle que la renvoie la boucle ci-dessus : « Could not read the page: blocked_by_robots ». Les modèles la gèrent bien et se rabattent sur d'autres sources ou informent l'utilisateur. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Aucun de ces refus ne consomme de crédit.

## Function calling : questions fréquentes

### Faut-il l'Responses API ou Chat Completions ?

L'exemple utilise Chat Completions avec le paramètre `tools`. La même définition de fonction et le même corps `read_url` fonctionnent avec les autres interfaces OpenAI qui acceptent des function tools ; seule la boucle autour d'elles change.

### Le modèle peut-il lire plusieurs pages en un seul tour ?

Oui. Une réponse peut contenir plusieurs appels d'outils ; la boucle exécute chacun d'eux et renvoie tous les résultats avant d'interroger à nouveau le modèle. Réduisez `max_chars` lorsque le modèle lit plusieurs pages d'un coup.

### La clé API est-elle exposée au modèle ?

Non. La clé reste dans l'environnement de votre code. Le modèle ne voit que le nom de l'outil, sa description et le texte que votre fonction renvoie.

### Combien coûte une page refusée ?

Rien. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# OpenClaw : ajouter un lecteur de pages web via MCP, aux côtés de web_fetch

> Lecteur de pages web pour OpenClaw via MCP : openclaw mcp add, doctor --probe, read_url complète web_fetch. Sans KYC, payez en crypto.

- URL: https://webreaderapi.com/fr/docs/openclaw/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

OpenClaw dispose déjà d'un outil `web_fetch` pour les pages légères. Ajouter notre serveur MCP donne à l'agent un second lecteur, `read_url`, pour les pages JavaScript, les PDF et les documents plus longs. L'installation tient en une commande.

**Réponse rapide — Comment ajouter une API de lecture de pages web à OpenClaw ?**

Enregistrez le serveur MCP **WebReaderAPI**, puis déclarez-le avec `openclaw mcp add webreaderapi --command … --arg … --env WEBREADER_API_KEY=…` et vérifiez-le avec `openclaw mcp doctor --probe`. L'agent obtient un outil `read_url` à côté du `web_fetch` intégré, capable de rendre le JavaScript et de lire les PDF. Les pages coûtent 1 crédit, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## web_fetch et read_url d'OpenClaw côte à côte

| Attribut | Valeur |
| --- | --- |
| web_fetch (intégré) | S'exécute localement, extrait le contenu principal avec Readability, renvoie du Markdown ou du texte |
| limites de web_fetch | Pas d'exécution JavaScript ; `maxChars` par défaut et plafond de 20 000 caractères (docs OpenClaw) |
| read_url (notre outil MCP) | Rendu JavaScript si nécessaire, PDF jusqu'à 100 pages, jusqu'à 500 000 caractères |
| coût de read_url | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Notre crawler | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, robots.txt respecté |
| Profils d'outils | Les outils MCP apparaissent dans les profils `coding` et `messaging`, pas dans `minimal` |

## Pourquoi ajouter un reader quand OpenClaw dispose de web_fetch ?

Parce qu'ils couvrent des pages différentes. La documentation d'OpenClaw indique que `web_fetch` s'exécute toujours en local, utilise Readability pour l'extraction du contenu principal et n'exécute pas JavaScript ; elle renvoie vers son outil Web Browser pour les sites lourds en JavaScript ou protégés par login. Son réglage `maxChars` vaut 20 000 caractères par défaut et est plafonné à cette valeur.

Gardez `web_fetch` pour les pages rapides et légères. Ajoutez `read_url` pour les pages qui construisent leur contenu en JavaScript, pour les PDF et pour les longs documents dont vous voulez extraire plus de 20 000 caractères. La doc d'OpenClaw note aussi que le plugin officiel Firecrawl est aujourd'hui le seul fournisseur intégré vers lequel `web_fetch` peut se rabattre.

## Comment enregistrer le serveur MCP dans OpenClaw ?

Installez d'abord le serveur Python depuis la [page MCP](https://webreaderapi.com/fr/docs/mcp/) : un fichier plus les packages `mcp` et `httpx`. Enregistrez-le ensuite dans OpenClaw avec `openclaw mcp add`. La documentation du registre d'OpenClaw décrit les flags stdio `--command`, `--arg`, `--env` et `--cwd`, et stocke les définitions enregistrées sous `mcp.servers` dans sa configuration.

Lancez `openclaw mcp doctor --probe` ensuite. Sans `--probe`, le doctor ne vérifie que la configuration enregistrée ; avec, il confirme aussi que les serveurs activés se connectent.

*Enregistrer et vérifier le serveur*

```bash
openclaw mcp add webreaderapi \
  --command /home/you/webreader/.venv/bin/python \
  --arg /home/you/webreader/webreader_mcp.py \
  --env WEBREADER_API_KEY=your-key

openclaw mcp doctor webreaderapi --probe
```

## L'agent verra-t-il read_url ?

Dans les profils habituels, oui. La documentation du registre d'OpenClaw indique qu'OpenClaw embarqué expose les outils MCP configurés dans les profils `coding` et `messaging`. Le profil `minimal` les masque, et `tools.deny: ["bundle-mcp"]` les désactive, donc vérifiez ces deux réglages si l'outil n'apparaît pas.

La description de l'outil indique au modèle quand le préférer : les pages qui nécessitent JavaScript, les PDF et les lectures longues. Le modèle peut toujours utiliser `web_fetch` pour tout le reste.

## Comment read_url traite-t-il les sites qu'il lit ?

De la même manière que chaque appel à notre API. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

Les pages derrière un login sont donc hors du périmètre de `read_url`. Pour un site auquel vous êtes connecté, l'outil navigateur d'OpenClaw, exécuté avec votre session, est l'outil adapté.

## Combien coûtera la lecture de pages via OpenClaw ?

Un crédit par page qui revient avec du contenu, deux lorsqu'un navigateur est nécessaire, rien pour les refus et les erreurs. Un assistant qui lit 30 pages par jour sur ses canaux de chat utilise environ 900 crédits par mois : 10 000 pages (3,75 $US) dure près d'un an. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez.

Donnez à OpenClaw sa propre clé API, pour que son usage se distingue de vos autres projets.

## OpenClaw : questions fréquentes

### WebReaderAPI est-il un fournisseur intégré à OpenClaw ?

Non. Il se connecte comme serveur MCP, ce qu'OpenClaw prend en charge sans aucun code de plugin. Le serveur MCP est le court fichier Python de notre [page MCP](https://webreaderapi.com/fr/docs/mcp/).

### Dois-je désactiver web_fetch ?

Pas besoin. Les deux outils peuvent rester activés ; les descriptions indiquent au modèle lequel convient. Ne désactivez `web_fetch` que si vous voulez que chaque lecture passe par un seul endroit pour la journalisation.

### Puis-je gérer le serveur depuis l'interface web d'OpenClaw ?

La documentation d'OpenClaw décrit les réglages MCP dans sa Control UI, qui modifient les mêmes définitions enregistrées que la ligne de commande. Utilisez celle que vous préférez.

### Cela fonctionne-t-il dans une installation OpenClaw en sandbox ?

Le serveur MCP est un processus local qui a besoin d'un accès internet pour joindre `https://webreaderapi.com/api/v1/read`. Vérifiez que votre sandbox autorise le processus à démarrer et à effectuer cet appel HTTPS.

## Sources

1. [Outils web](https://docs.openclaw.ai/tools/web) — OpenClaw docs (read 2026-10-22)
2. [Web Fetch](https://docs.openclaw.ai/tools/web-fetch) — OpenClaw docs (read 2026-10-22)
3. [Gérer les serveurs MCP enregistrés](https://docs.openclaw.ai/cli/mcp/registry) — OpenClaw docs (read 2026-10-22)
4. [MCP dans la Control UI](https://docs.openclaw.ai/cli/mcp/control-ui) — OpenClaw docs (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Page web en Markdown en Python

> Convertissez des pages web en Markdown en Python avec requests, httpx en async, batch jobs et découpage RAG. Depuis 0,07 $US/1K pages, sans KYC.

- URL: https://webreaderapi.com/fr/docs/python/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Quatre recettes qui couvrent la plupart des projets Python : lire une page avec requests, lire plusieurs pages en parallèle avec httpx, confier une liste à un batch job, et découper le Markdown en chunks pour un vector store.

**Réponse rapide — Comment convertir une page web en Markdown en Python ?**

Appelez **WebReaderAPI** avec `requests.get("https://webreaderapi.com/api/v1/read", params={"url": ...})` et votre clé dans le header `Authorization` ; la réponse JSON contient le contenu principal de la page dans `markdown`. Pour plusieurs pages, utilisez `httpx.AsyncClient` avec un sémaphore ou un batch job. Une page coûte 1 crédit, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## De quoi ai-je besoin d'installer ?

Python 3.9 ou ultérieur et un client HTTP. `requests` suffit pour les scripts qui lisent une page à la fois ; `httpx` ajoute le support async pour de nombreuses pages en parallèle. Aucun package de notre part n'est nécessaire : l'API est du HTTPS et du JSON simples.

Gardez votre clé hors du code. Lisez-la depuis la variable d'environnement `WEBREADER_API_KEY`, comme dans chaque exemple ci-dessous, et donnez à chaque projet sa propre clé pour pouvoir en révoquer une sans toucher aux autres.

*Installation*

```bash
pip install requests httpx
export WEBREADER_API_KEY="your-key"
```

## Comment lire une page avec requests ?

Envoyez `url` et les options en paramètres de requête, levez une exception en cas d'erreur HTTP et lisez les champs dont vous avez besoin. L'exemple conserve le contenu principal, le limite à 20 000 caractères pour un modèle et affiche ce que l'appel a coûté.

*requests : une page*

```python
import os

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


def read(url, **options):
    resp = requests.get(API, headers=HEADERS, params={"url": url, **options}, timeout=75)
    if resp.status_code != 200:
        error = resp.json()["error"]
        raise RuntimeError(error["code"] + ": " + error["message"])
    return resp.json()


page = read("https://example.com/docs/getting-started", max_chars=20000)
print(page["title"], page["word_count"], "words", page["credits_used"], "credit(s)")
print(page["markdown"][:500])

```

## Comment lire plusieurs pages à la fois avec httpx ?

Utilisez un seul `httpx.AsyncClient` et un `asyncio.Semaphore` réglé au niveau de votre limite de concurrence ou en dessous. Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter. Les erreurs d'une page ne doivent pas arrêter les autres, donc l'exemple les collecte à côté des résultats au lieu de lever une exception.

Si vous dépassez la limite, l'API répond `429 concurrency_limit` ; rien n'est facturé, mais la page n'est pas lue. Garder le sémaphore sous la limite est plus simple que de réessayer.

*httpx : jusqu'à 10 pages en vol*

```python
import asyncio
import os

import httpx

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


async def read_one(client, sem, url):
    async with sem:
        resp = await client.get(API, params={"url": url, "max_chars": 50000})
    body = resp.json()
    if resp.status_code == 200:
        return url, body, None
    return url, None, body["error"]["code"]


async def read_many(urls, limit=10):
    sem = asyncio.Semaphore(limit)
    async with httpx.AsyncClient(headers=HEADERS, timeout=75) as client:
        return await asyncio.gather(*(read_one(client, sem, u) for u in urls))


if __name__ == "__main__":
    urls = [f"https://example.com/blog/post-{n}" for n in range(1, 21)]
    for url, page, error in asyncio.run(read_many(urls)):
        print(url, "->", error or page["title"])

```

## Quand dois-je plutôt utiliser un batch job ?

Lorsque vous avez une liste pouvant aller jusqu'à 100 URL et que vous n'avez pas besoin de chaque page dès qu'elle est prête. Un job par lots s'exécute de notre côté, donc votre script ne garde aucune connexion ouverte et ne gère aucune logique de réessai. Lancez-le avec `POST https://webreaderapi.com/api/v1/batch`, puis récupérez les résultats du job avec la boucle de curseur présentée sur la [page batch et crawl](https://webreaderapi.com/fr/docs/crawl/).

Pour un site entier, lancez plutôt un crawl et laissez-le suivre le sitemap et les liens ; la même page contient une boucle complète qui écrit un fichier `.md` par page.

*Lancer un job batch*

```python
import os

import requests

urls = [f"https://example.com/changelog/{year}" for year in range(2020, 2027)]
resp = requests.post(
    "https://webreaderapi.com/api/v1/batch",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    json={"urls": urls, "options": {"format": "markdown", "main_content": True}},
    timeout=30,
)
resp.raise_for_status()
print("job:", resp.json()["job_id"])

```

## Comment découper le Markdown en chunks pour le RAG ?

Découpez d'abord sur les titres, puis sur la taille. Les titres marquent les changements de sujet, donc un chunk qui commence à un titre est plus facile à faire correspondre pour un retriever. Conservez le titre de la page et le chemin des titres dans les métadonnées de chaque chunk : ils aident le modèle à citer la bonne section.

La fonction ci-dessous ne nécessite aucune bibliothèque supplémentaire. Elle coupe au niveau des titres `#` à `###`, puis découpe toute section longue sur les lignes vides pour rester sous un budget de caractères. Stockez `final_url` avec chaque chunk, afin que deux adresses menant à la même page ne créent pas de doublons.

*Découper le Markdown par titres*

```python
import re


def chunk_markdown(page, max_chars=2000):
    """Split a /read response into chunks with a heading path and the source URL."""
    chunks, path, buf = [], [], []

    def flush():
        text = "\n".join(buf).strip()
        while text:
            part = text[:max_chars]
            cut = part.rfind("\n\n")
            if len(text) > max_chars and cut > max_chars // 2:
                part = part[:cut]
            chunks.append({"text": part.strip(), "section": " > ".join(path), "title": page.get("title"), "source": page["final_url"]})
            text = text[len(part):].strip()
        buf.clear()

    for line in page["markdown"].splitlines():
        m = re.match(r"^(#{1,3}) (.+)", line)
        if m:
            flush()
            level = len(m.group(1))
            path[:] = path[: level - 1] + [m.group(2).strip()]
        buf.append(line)
    flush()
    return chunks

```

## Combien coûte un job Python ?

Comptez les pages, pas les requêtes. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Lire 2 000 pages de documentation sans navigateur utilise environ 2 000 crédits, ce que 10 000 pages (3,75 $US) couvre cinq fois. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez, donc un pipeline qui s'exécute une fois par mois n'utilise que ce qu'il lit.

## Python : questions fréquentes

### Existe-t-il un package Python officiel ?

Non. Le code de cette page est tout ce dont vous avez besoin : WebReaderAPI est une API HTTPS simple, et `requests` ou `httpx` la gèrent directement.

### Comment gérer une page que robots.txt refuse ?

Vérifiez le code d'erreur. `blocked_by_robots` et `target_refused` sont définitifs et gratuits ; enregistrez-les et continuez. La [page errors](https://webreaderapi.com/fr/docs/errors/) contient un assistant de réessai qui ne relance que les codes susceptibles de changer.

### Puis-je utiliser l'API depuis un notebook Jupyter ?

Oui. La recette `requests` fonctionne telle quelle. Dans un notebook, `await read_many(urls)` remplace `asyncio.run`, car le notebook exécute déjà une boucle d'événements.

### Quel timeout mon client doit-il utiliser ?

Un peu plus que celui de l'API : la valeur par défaut est 30 secondes et le maximum 60, donc 75 secondes côté client laissent de la marge pour un site lent et la réponse.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Référence de l'endpoint read : GET et POST /read

> Référence de l'endpoint read : paramètres GET et POST /read, format, pays et max_chars, avec exemples. Depuis 0,07 $US/1K pages, sans KYC.

- URL: https://webreaderapi.com/fr/docs/read/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

`/read` récupère une page publique, en extrait le contenu principal et le renvoie en Markdown, en texte brut ou en HTML nettoyé. Cette page liste chaque paramètre, sa valeur par défaut et ce qu'il coûte.

**Réponse rapide — Quels paramètres prend l'endpoint read de WebReaderAPI ?**

L'endpoint `/read` de **WebReaderAPI** nécessite un paramètre, `url`. Les paramètres optionnels choisissent la sortie (`format`), la part de la page à conserver (`main_content`), si un navigateur s'exécute (`render`), les liens et les images, le pays de lecture, une limite de caractères et un timeout. Une page simple coûte 1 crédit, 2 avec un navigateur, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payer en crypto.

## /read at a glance

| Attribut | Valeur |
| --- | --- |
| Méthodes | `GET` avec des paramètres de requête, ou `POST` avec un corps JSON utilisant les mêmes noms |
| URL | `https://webreaderapi.com/api/v1/read` |
| Obligatoire | `url` : une adresse http ou https, jusqu'à 2 048 caractères |
| Sortie par défaut | Markdown du contenu principal |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Pays | Choisir le pays depuis lequel une page est lue coûte 10 crédits de plus, car la page est alors lue via une connexion résidentielle dans ce pays |
| PDF | Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé |
| Identité du crawler | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` |

## Lire une page (GET)

`GET /api/v1/read`

Récupère une page publique et renvoie son contenu principal en Markdown, avec les métadonnées de la page. Les paramètres vont dans la query string, encodés en URL. L'exemple lit un billet de blog ; les IDs, les dates et les valeurs sont illustratifs.

Authentification : clé API dans le header `Authorization: Bearer API_KEY`.

**Paramètres**

| Nom | Emplacement | Type | Obligatoire | Description |
| --- | --- | --- | --- | --- |
| `url` | query | string | Oui | La page à lire : http ou https, 2 048 caractères au maximum. Les adresses privées, locales et de métadonnées cloud sont refusées. |
| `format` | query | string | Non | `markdown` (par défaut), `text` (texte brut, sans balisage) ou `html` (HTML nettoyé du contenu). |
| `main_content` | query | boolean | Non | `true` (par défaut) ne conserve que l'article ou le contenu principal ; `false` convertit toute la page, menus et pied de page inclus. |
| `render` | query | string | Non | `auto` (par défaut) ne démarre un navigateur que lorsque le HTML brut contient trop peu de texte ; `true` toujours ; `false` jamais. Une page rendue coûte 2 crédits. |
| `include_links` | query | boolean | Non | `true` ajoute une liste `links` de `{url, text}`. Valeur par défaut `false`. |
| `include_images` | query | boolean | Non | `true` conserve les images sous forme de `![alt](src)` dans le Markdown. Valeur par défaut `false`. |
| `country` | query | string | Non | Code pays à deux lettres (ISO 3166-1 alpha-2). La page est lue depuis une adresse dans ce pays, pour 10 crédits supplémentaires (connexion résidentielle). |
| `max_chars` | query | integer | Non | Tronque la sortie à ce nombre de caractères, de 1 000 à 500 000. Utile pour tenir dans le contexte d'un modèle. |
| `timeout` | query | integer | Non | Secondes d'attente pour le site, de 5 à 60. Par défaut 30. |
| `api_key` | query | string | Non | Votre clé, si vous n'envoyez pas l'en-tête `Authorization`. |

**Réponse** `200`

```json
{
  "url": "https://example.com/blog/first-post",
  "final_url": "https://example.com/blog/first-post",
  "status_code": 200,
  "fetched_at": "2026-10-22T09:41:12Z",
  "rendered": false,
  "credits_used": 1,
  "title": "Our first post",
  "description": "Why we started this blog and what comes next.",
  "language": "en",
  "author": "Jane Doe",
  "published_at": "2026-10-01",
  "site_name": "Example Blog",
  "markdown": "# Our first post\n\nWe started this blog to share what we learn...\n\n## What comes next\n\n- A post every month\n- Notes from our team",
  "word_count": 612
}
```

*curl*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/blog/first-post" \
  -d format=markdown -d max_chars=20000
```

*Python*

```python
import os
import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/blog/first-post", "max_chars": 20000},
    timeout=70,
)
resp.raise_for_status()
print(resp.json()["markdown"][:300])
```

*Node.js*

```javascript
const params = new URLSearchParams({ url: 'https://example.com/blog/first-post', max_chars: '20000' });
const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
});
const page = await res.json();
console.log(page.markdown.slice(0, 300));
```

## Lire une page (POST)

`POST /api/v1/read`

Même endpoint, mêmes paramètres, envoyés dans un corps JSON. Préférez POST lorsque l'URL est très longue ou lorsque votre client HTTP construit plus facilement du JSON que des query strings. La réponse est identique à celle de la forme GET.

Authentification : clé API dans le header `Authorization: Bearer API_KEY`.

**Corps de la requête**

| Champ | Type | Obligatoire | Description |
| --- | --- | --- | --- |
| `url` | string | Oui | La page à lire. |
| `format`, `main_content`, `render`, `include_links`, `include_images`, `country`, `max_chars`, `timeout` | mixed | Non | Comme dans le tableau GET ci-dessus, avec les types JSON : booléens en `true`/`false`, nombres sans guillemets. |

*Exemple: a JavaScript-heavy page, read from Germany, with its links*

```json
{
  "url": "https://example.com/app/pricing",
  "render": "true",
  "country": "de",
  "include_links": true,
  "max_chars": 30000
}
```

**Réponse** `200`

```json
{
  "url": "https://example.com/app/pricing",
  "final_url": "https://example.com/de/app/pricing",
  "status_code": 200,
  "fetched_at": "2026-10-22T09:44:03Z",
  "rendered": true,
  "credits_used": 3,
  "title": "Pricing",
  "language": "de",
  "markdown": "# Pricing\n\n| Plan | Price |\n|---|---|\n| Basic | ... |",
  "word_count": 214,
  "links": [
    {
      "url": "https://example.com/de/contact",
      "text": "Contact"
    }
  ]
}
```

*curl*

```bash
curl -s "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/app/pricing", "render": "true", "country": "de", "include_links": true}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    json={"url": "https://example.com/app/pricing", "render": "true", "country": "de", "include_links": True},
    timeout=70,
)
print(resp.json()["credits_used"], "credits")
```

*Node.js*

```javascript
const res = await fetch('https://webreaderapi.com/api/v1/read', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ url: 'https://example.com/app/pricing', render: 'true', country: 'de', include_links: true }),
});
console.log((await res.json()).credits_used);
```

## Quel format de sortie choisir ?

Choisissez `markdown` pour les modèles de langage et le RAG : les titres, les listes, les tableaux et les liens sont conservés, et le texte reste compact. Choisissez `text` lorsque vous ne faites que compter des mots, classifier ou rechercher, et que le balisage serait du bruit. Choisissez `html` lorsque votre propre pipeline parse déjà le HTML et que vous voulez seulement retirer l'encombrement.

Les champs de métadonnées sont identiques dans les trois formats. Seul le nom du champ de contenu change : `markdown`, `text` ou `html`.

## Quand dois-je mettre main_content à false ?

Mettez-le à `false` lorsque ce sont les parties autour de l'article dont vous avez besoin. Par exemple, la navigation d'un site pour cartographier ses sections, un pied de page avec les mentions légales ou les coordonnées, ou une page produit dont les caractéristiques se trouvent dans une barre latérale.

Avec la valeur par défaut `true`, l'extracteur conserve le bloc de contenu principal et supprime la navigation, les bannières de cookies, les publicités, les boutons de partage et les pieds de page. C'est ce que veulent la plupart des agents et des pipelines RAG, et cela réduit souvent une page à une fraction de la taille de son HTML.

## Comment render=auto décide-t-il d'utiliser un navigateur ?

Il récupère d'abord le HTML brut, ce qui est rapide et coûte 1 crédit. Si ce HTML contient trop peu de texte lisible, typiquement une application qui construit la page en JavaScript, il recharge la page dans un navigateur headless et l'appel coûte 2 crédits. La réponse indique quel chemin a été exécuté : `rendered` vaut `true` ou `false`.

Définissez `render=false` lorsque vous savez que le site sert du HTML complet et voulez un coût fixe. Définissez `render=true` pour les applications monopage, afin de sauter la première tentative.

## Que changent country et max_chars ?

`country` lit la page depuis une adresse située dans le pays que vous indiquez, avec le même User-Agent. Utilisez-le pour les pages dont les prix, la langue ou la disponibilité varient selon le pays. Cela ajoute 10 crédits, car la page est alors lue via une connexion résidentielle, et ne peut pas être utilisé avec les pays où le service n'opère pas.

`max_chars` coupe la sortie après ce nombre de caractères. Cela ne change pas le prix, mais protège la fenêtre de contexte d'un agent : 20 000 caractères est une valeur par défaut raisonnable pour une page unique transmise à un modèle.

## /read peut-il gérer les fichiers PDF ?

Oui. Lorsque l'URL renvoie un PDF, le texte revient au format Markdown dans le même champ `markdown`. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé. Les PDF scannés sans couche de texte renvoient peu ou pas de texte, car il n'y a pas d'étape de reconnaissance de caractères.

## Endpoint read : questions courantes

### /read suit-il les redirections ?

Oui, jusqu'à 5. La réponse donne l'adresse que vous avez demandée dans `url` et l'adresse réellement lue dans `final_url`. Une redirection vers une adresse privée ou locale est refusée.

### Puis-je lire une page nécessitant une connexion ?

Non. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Les pages derrière une connexion ou un paywall renvoient le refus du site, et l'appel est gratuit.

### La vérification du robots.txt est-elle effectuée à chaque appel ?

Oui, sur une copie du robots.txt du site vieille de 24 heures au maximum. Une URL non autorisée renvoie `403 blocked_by_robots` et n'utilise aucun crédit.

### Combien de pages puis-je lire en même temps ?

Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter. Pour de nombreuses URL, un [batch job](https://webreaderapi.com/fr/docs/crawl/) est plus simple que de lancer de nombreux appels en parallèle.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Format de réponse de l'API Read, champ par champ

> Format de réponse API Read : chaque champ d'une page, de markdown et word_count à final_url, plus les résultats de job. Paiement crypto, sans KYC.

- URL: https://webreaderapi.com/fr/docs/response/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Chaque appel `/read` renvoie un objet JSON : le contenu de la page dans le format demandé, ses métadonnées, et trois champs qui vous indiquent ce qui s'est passé et ce que cela a coûté. Les résultats de job réutilisent le même objet.

**Réponse rapide — Que contient la réponse de lecture de WebReaderAPI ?**

Une réponse **WebReaderAPI** `/read` contient le contenu de la page en `markdown` (ou `text` ou `html`), ses métadonnées (`title`, `description`, `author`, `published_at`, `language`, `site_name`, `word_count`), et les informations du fetch : `final_url`, `status_code`, `rendered` et `credits_used`. Une page simple utilise 1 crédit, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## Quels champs décrivent le fetch ?

Ces champs sont toujours présents dans une réponse réussie.

| Champ | Type | Signification |
| --- | --- | --- |
| `url` | string | L'adresse que vous avez envoyée |
| `final_url` | string | L'adresse réellement lue, après redirections (5 au maximum) |
| `status_code` | entier | Le statut HTTP renvoyé par le site pour l'adresse finale, normalement 200 |
| `fetched_at` | string | Heure de la récupération, ISO 8601 en UTC |
| `rendered` | booléen | `true` lorsqu'un navigateur headless a construit la page |
| `credits_used` | entier | Crédits facturés pour cette page : 1, 2 avec un navigateur, plus 10 avec `country` ; PDF 1 par tranche de 10 pages commencées |

## Quels champs décrivent la page ?

Les métadonnées proviennent de la page elle-même : sa balise title, ses balises meta, ses données structurées et sa signature visible. Un champ que la page ne fournit pas est absent : testez sa présence avant de l'utiliser.

| Champ | Type | Signification |
| --- | --- | --- |
| `title` | string | Le titre de la page ou de l'article |
| `description` | string | Le résumé que la page donne d'elle-même |
| `language` | string | Code de langue du contenu, par exemple `en` ou `de` |
| `author` | string | L'auteur indiqué sur la page |
| `published_at` | string | Date de publication indiquée par la page |
| `site_name` | string | Le nom du site lui-même |
| `word_count` | entier | Mots dans le contenu renvoyé, après extraction et avant `max_chars` |

## Où se trouve le contenu lui-même ?

Un seul champ de contenu est renvoyé, nommé d'après le `format` choisi.

| Champ | Quand | Contenu |
| --- | --- | --- |
| `markdown` | `format=markdown` (par défaut) | Titres, paragraphes, listes, tableaux et liens en Markdown ; images aussi avec `include_images=true` |
| `text` | `format=text` | Texte brut, paragraphes séparés par des lignes vides |
| `html` | `format=html` | HTML nettoyé du contenu principal, sans scripts, styles ni publicités |
| `links` | `include_links=true` | Liste des `{url, text}` pour les liens trouvés sur la page, URL absolues |

*Une réponse complète (les valeurs sont illustratives)*

```json
{
  "url": "https://example.com/guides/compost",
  "final_url": "https://example.com/guides/compost-at-home",
  "status_code": 200,
  "fetched_at": "2026-10-22T10:02:44Z",
  "rendered": false,
  "credits_used": 1,
  "title": "Compost at home: a beginner's guide",
  "description": "What to put in a compost bin, and what to leave out.",
  "language": "en",
  "author": "Sam Rivera",
  "published_at": "2026-09-14",
  "site_name": "Example Garden",
  "markdown": "# Compost at home: a beginner's guide\n\nA compost bin turns kitchen scraps into soil...\n\n## What goes in\n\n- Fruit and vegetable peels\n- Coffee grounds\n\nSee also [Choosing a bin](https://example.com/guides/bins).",
  "word_count": 1184,
  "links": [
    { "url": "https://example.com/guides/bins", "text": "Choosing a bin" }
  ]
}
```

## Comment distinguer une page rendue d'une page brute ?

Regardez `rendered`. Avec `render=auto`, l'API lit d'abord le HTML brut ; elle ne lance un navigateur que lorsque ce HTML contient trop peu de texte, et passe alors `rendered` à `true` et `credits_used` à 2. Si un site que vous lisez souvent revient toujours rendu, envoyez `render=true` dès le départ : le coût est identique et vous évitez une première étape inutile.

Si une page revient non rendue mais pauvre en contenu, comparez `word_count` avec ce que vous voyez dans un navigateur. Un nombre faible signifie généralement que le contenu nécessite JavaScript ; réessayez une fois avec `render=true`.

## Pourquoi final_url peut-il différer de url ?

Parce que les sites redirigent. Un lien court, une ancienne adresse, une barre oblique finale manquante ou un changement de langue vous envoient ailleurs. L'API suit jusqu'à 5 redirections et indique l'adresse qu'elle a finalement lue dans `final_url`.

Stockez `final_url` comme source canonique d'un document dans un index RAG. Deux valeurs `url` différentes qui aboutissent au même `final_url` désignent la même page : vous pouvez donc supprimer le doublon avant de l'embedder.

## À quoi ressemble le résultat d'un job ?

`GET https://webreaderapi.com/api/v1/jobs/{job_id}` renvoie `job_id`, `status` (`queued`, `running` ou `done`), `results`, `next_cursor` et l'état d'avancement `credits_used` du job. Chaque élément de `results` prend l'une de deux formes :

- une réponse `/read` complète, exactement comme décrit ci-dessus, pour une page qui a été lue ;
- `{url, error}` pour une page qui ne l'a pas été, où `error` possède les mêmes `code` et `message` qu'une [erreur API](https://webreaderapi.com/fr/docs/errors/).

`next_cursor` est présent tant que d'autres résultats sont disponibles ; renvoyez-le en tant que `cursor` pour les récupérer. La [page batch et crawl](https://webreaderapi.com/fr/docs/crawl/) contient une boucle de polling complète.

*Une page de résultat de job (les valeurs sont illustratives)*

```json
{
  "job_id": "job_5c1e8a90d2",
  "status": "done",
  "results": [
    { "url": "https://example.com/blog/post-1", "final_url": "https://example.com/blog/post-1", "status_code": 200, "rendered": false, "credits_used": 1, "title": "Post one", "markdown": "# Post one\n\n...", "word_count": 802 },
    { "url": "https://example.org/members/area", "error": { "code": "target_refused", "message": "The site refused the request.", "target_status": 403 } }
  ],
  "credits_used": 1
}
```

## À quoi ressemble une réponse d'erreur ?

Une erreur revient avec un statut HTTP de 400 ou plus et un corps JSON `{"error": {"code", "message"}}`. Lorsque le site lui-même a refusé la requête, `target_status` indique le statut envoyé par le site. Aucune erreur n'est facturée. La [page des erreurs](https://webreaderapi.com/fr/docs/errors/) liste chaque code avec sa cause et précise si une nouvelle tentative peut aider.

## Format de réponse : questions fréquentes

### Le Markdown est-il coupé lorsque je définis max_chars ?

Oui. Le champ content s'arrête à ce nombre de caractères. `word_count` décrit toujours l'intégralité du contenu extrait, vous pouvez donc voir ce qui a été omis.

### Pourquoi author ou published_at sont-ils absents ?

Parce que la page ne l'indique pas d'une manière lisible. Beaucoup de pages ne fournissent ni auteur ni date. Les champs absents sont omis plutôt que renvoyés vides.

### Les liens dans le Markdown sont-ils absolus ?

Les liens de la liste `links` sont absolus. Écrivez votre code pour accepter les deux formes dans le corps Markdown, et résolvez les liens relatifs par rapport à `final_url`.

### Puis-je obtenir le HTML brut de la page entière ?

Le plus proche est `format=html` avec `main_content=false`, qui renvoie la page entière nettoyée des scripts et des styles. Le HTML original octet par octet ne fait pas partie de la v1.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# FAQ WebReaderAPI

> FAQ WebReaderAPI : 30 réponses sur l'API de lecture de pages web : prix par page, JavaScript et PDF, crawl, robots.txt, sites bloqués.

- URL: https://webreaderapi.com/fr/faq/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Réponses aux questions que se posent le plus les développeurs, les créateurs d'IA et les propriétaires de sites sur la conversion de pages web en Markdown avec WebReaderAPI. Chaque réponse commence par la réponse.

**Réponse rapide — Que demande-t-on le plus à propos de WebReaderAPI ?**

Surtout le prix par page, la façon dont sont comptées les pages JavaScript et les PDF, et ce qui se passe quand un site refuse robots. En bref : **WebReaderAPI** facture un crédit par page lue, deux avec un navigateur, à partir de 0,07 $US/1K pages en octobre 2026 ; les pages refusées ou en échec ne coûtent rien ; robots.txt est toujours respecté. Sans KYC ; payer en crypto.

## Prix et crédits

### Combien coûte WebReaderAPI ?

Les packs prépayés coûtent 3,75 $US pour 10 000 pages, 21,75 $US pour 100 000 pages et 74,25 $US pour 1 000 000 pages, en octobre 2026. Le tarif descend à 0,07 $US/1K pages sur le pack 5 000 000 pages. La [page de tarifs](https://webreaderapi.com/fr/pricing/) liste tous les packs.

### Que permet d'acheter un crédit ?

Une page lue sans navigateur. Une page qui nécessite un rendu JavaScript utilise deux crédits, et la lecture depuis un pays choisi en ajoute un. La réponse indique ce qui a été utilisé dans `credits_used`, pour que vous puissiez suivre le coût par page dans vos propres logs.

### Les crédits expirent-ils ?

Non. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez. Un pack acheté pour un crawl ponctuel conserve ses pages inutilisées pour le projet suivant.

### Suis-je facturé quand une page ne peut pas être lue ?

Non. Les erreurs n'utilisent aucun crédit, que la cause vienne de notre côté, du réseau ou du site web. Cela inclut les pages refusées par robots.txt, par un signal `ai-input=no`, ou par la réponse du site lui-même.

### Existe-t-il une offre gratuite ?

Non. Il n'y a pas d'offre gratuite : le plus petit pack est le moyen de tester, payé à partir de la recharge minimale, et le montant ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande sous 30 jours, en USDT ou USDC, tant qu'il n'est pas dépensé.

### Quel est le montant minimum que je peux dépenser ?

La recharge minimum est de 25 $US. Le plus petit pack, 10 000 pages, coûte 3,75 $US ; le reste de la recharge demeure sur votre solde pour de futurs packs ou peut être demandé en remboursement sous 30 jours s'il n'est pas dépensé.

## Ce que l'API lit et renvoie

### WebReaderAPI peut-il lire les pages construites avec JavaScript ?

Oui. Rendu JavaScript dans un navigateur headless quand la page en a besoin (render=auto), ou toujours, ou jamais. Avec `render=auto`, un navigateur n'est utilisé que lorsque le HTML brut contient trop peu de texte, si bien que les pages simples restent à un crédit.

### Peut-il convertir des fichiers PDF ?

Oui. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé. Envoyez l'URL du PDF au même endpoint `/read` ; le texte revient en Markdown.

### Puis-je lire un site web entier ?

Oui, avec un job de crawl. Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay. Vous pouvez le restreindre à des chemins tels que `/docs/*` ; chaque page lue utilise des crédits comme une requête unique.

### Combien d'URL puis-je envoyer à la fois ?

Jusqu'à 100 URLs par job batch. Un lot s'exécute comme un job : vous envoyez la liste, recevez un `job_id`, et récupérez chaque résultat une fois le job terminé.

### Comment garder une page dans la fenêtre de contexte de mon modèle ?

Définissez `max_chars`. Le Markdown est coupé à cette longueur, de 1 000 à 500 000 caractères. Combiné à `main_content=true`, cela maintient les pages longues dans un budget de tokens prévisible.

### Le Markdown conserve-t-il les tableaux, les blocs de code et les liens ?

Oui. Les titres, listes, tableaux, blocs de code et liens conservent leur forme Markdown. Les liens sont en ligne ; ajoutez `include_links=true` pour les obtenir aussi sous forme de liste séparée, et `include_images=true` pour conserver les images.

### Que signifie « contenu principal » ?

La partie de la page pour laquelle un lecteur est venu : l'article, la documentation ou la description du produit. Avec `main_content=true`, la valeur par défaut, les menus, bannières cookies, publicités, barres latérales et pieds de page sont supprimés. Définissez-le à `false` pour convertir toute la page.

### Puis-je lire une page telle qu'elle apparaît dans un autre pays ?

Oui, avec le paramètre `country` et un code pays à deux lettres. Choisir le pays depuis lequel une page est lue coûte 10 crédits de plus, car la page est alors lue via une connexion résidentielle dans ce pays. Certains sites modifient les prix, la langue ou le contenu selon le pays.

## robots.txt et pages refusées

### WebReaderAPI respecte-t-il robots.txt ?

Toujours. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. La [page bot](https://webreaderapi.com/fr/bot/) indique le user agent et comment les propriétaires de sites peuvent l'autoriser ou le refuser.

### Que se passe-t-il avec les sites protégés par Cloudflare ou un autre filtre anti-bot ?

Si le site laisse passer notre crawler, la page est lue normalement. S'il refuse ou répond avec une page de challenge, nous renvoyons cette réponse en `target_refused` et ne facturons rien. Nous ne tentons jamais de contourner un challenge.

### WebReaderAPI peut-il lire des pages derrière un login ou un paywall ?

Non, jamais, même avec des identifiants que vous fournissez. Le contenu qui exige un compte ou un abonnement reste hors périmètre, et le demander enfreint la [Acceptable Use Policy](https://webreaderapi.com/fr/acceptable-use/).

### Qu'est-ce que le signal ai-input=no ?

Une ligne que certains sites ajoutent à robots.txt, issue de la Content Signals Policy, pour refuser l'utilisation de leurs pages comme entrée pour les réponses IA. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous ; l'API renvoie `blocked_by_site_policy`, gratuitement.

### Lire des pages web pour l'IA est-il légal ?

Cela dépend du contenu, du pays et de ce que vous faites du texte. Respecter robots.txt et rester à l'écart des données personnelles et des paywalls réduit le risque. Notre [aperçu des règles](https://webreaderapi.com/fr/guides/is-reading-web-pages-for-ai-legal/) résume les points principaux ; ce n'est pas un avis juridique.

## Compte, paiement et confidentialité

### Dois-je vérifier mon identité ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni document d'entreprise, ni carte bancaire. Connexion par numéro de compte ; l'email est facultatif. La [page sans KYC](https://webreaderapi.com/fr/no-kyc-web-reader-api/) explique ce qui s'applique malgré tout.

### Avec quelles cryptomonnaies puis-je payer ?

BTC, USDT, USDC, ETH, SOL, LTC. USDT fonctionne sur TRC-20 ou ERC-20, USDC sur ERC-20. Envoyez le montant exact affiché, cliquez sur « I've sent the payment », et la recharge est créditée une fois le paiement confirmé.

### Puis-je obtenir un remboursement ?

Oui, sur votre solde. Un pack utilisé à moins de 20 % est remboursé dans les 72 heures suivant l'achat, et un pack qui n'a jamais fonctionné est crédité en totalité. La [politique de remboursement](https://webreaderapi.com/fr/refunds/) donne la règle exacte et trois exemples.

### Comment fonctionnent les clés API ?

Créez plusieurs clés API, par exemple une par agent ou par projet, et révoquez n'importe laquelle depuis votre dashboard. Envoyez votre clé API dans le header Authorization en tant que Bearer token, ou dans le paramètre de requête api_key. Une clé par application ou par agent permet d'en révoquer une sans arrêter les autres.

### Que journalisez-vous à propos de mes requêtes ?

Le nom d'hôte de chaque page, jamais l'URL complète ni son contenu, ainsi que l'heure, le statut et les crédits, pendant 30 jours. Nous ne conservons aucune copie des pages que vous lisez. La [politique de confidentialité](https://webreaderapi.com/fr/privacy/) donne les détails.

## Développeurs et agents IA

### Y a-t-il du code pour Python et Node.js ?

Oui. Les guides [Python](https://webreaderapi.com/fr/docs/python/) et [Node.js](https://webreaderapi.com/fr/docs/node/) montrent des lectures simples, des lots, des crawls et des retries, et le [quick start](https://webreaderapi.com/fr/docs/) contient un exemple curl. Aucun package SDK n'est nécessaire : l'API est du HTTPS simple avec du JSON.

### Claude, Cursor ou un autre client MCP peuvent-ils utiliser WebReaderAPI ?

Oui, via un petit serveur MCP que vous hébergez vous-même, documenté sur la [page MCP](https://webreaderapi.com/fr/docs/mcp/). Il expose un outil qui prend une URL et renvoie la page en Markdown.

### Est-ce compatible avec LangChain et LlamaIndex ?

Oui. La [page LangChain et LlamaIndex](https://webreaderapi.com/fr/docs/langchain/) montre un document loader qui transforme les URL en documents avec leurs métadonnées, prêts pour le chunking et l'embedding.

### Combien de pages puis-je lire en même temps ?

Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter. Les crawls suivent aussi le `Crawl-delay` de chaque site, donc un gros crawl d'un domaine peut prendre plus de temps que son nombre de pages ne le suggère.

### Qui gère WebReaderAPI ?

SerpGoat LLC. Voir la [page à propos](https://webreaderapi.com/fr/about/) pour comprendre comment le service fonctionne et comment joindre une personne. L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations.

### Quelle est la vitesse d'une lecture ?

Cela dépend surtout du site web et de la nécessité ou non d'un navigateur. Nous ne publions pas de chiffre de vitesse avant d'en avoir mesuré un sur un échantillon public ; le jour où ce sera fait, il apparaîtra avec sa méthode et sa date sur la [page de statut](https://webreaderapi.com/fr/status/).

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Glossaire de l'API de lecture web

> Glossaire de 36 termes pour lire des pages web avec une API : Markdown, contenu principal, rendu JavaScript, robots.txt, RAG, MCP, crédits et plus.

- URL: https://webreaderapi.com/fr/glossary/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Les mots que vous rencontrez lorsque vous transformez des pages web en texte pour les modèles de langage, du côté HTML au côté IA, avec des liens vers les endroits de la documentation où chacun compte.

**Réponse rapide — Que signifient les principaux termes de l'API de lecture web ?**

Une API de lecture web récupère une page, conserve son **contenu principal** et le renvoie en **Markdown** qu'un modèle peut lire. **WebReaderAPI** ajoute le **rendu JavaScript** quand une page a besoin d'un navigateur, respecte **robots.txt** et les **Content Signals**, et facture un **crédit** par page, à partir de 0,07 $US/1K pages depuis octobre 2026. Les 36 termes ci-dessous expliquent le reste.

## Du côté de la page web

**HTML** — Le langage de balisage des pages web. Le HTML brut mélange le texte que vous voulez avec des balises, des scripts et du style, c'est pourquoi il se lit mal pour un modèle de langage.

**DOM** — Le Document Object Model : l'arbre d'éléments qu'un navigateur construit à partir du HTML puis modifie avec JavaScript. Une page rendue est lue depuis le DOM, pas depuis le HTML brut.

**Rendu JavaScript** — Exécuter les scripts d'une page dans un navigateur pour faire apparaître le contenu chargé après la première réponse. WebReaderAPI le fait quand c'est nécessaire (`render=auto`), pour deux crédits au lieu d'un.

**Navigateur headless** — Un vrai moteur de navigateur qui tourne sans écran, piloté par logiciel. C'est ainsi que les pages riches en JavaScript sont rendues sur un serveur.

**Extraction du contenu principal** — Trouver la partie d'une page pour laquelle un lecteur est venu, comme l'article ou la documentation, et laisser de côté tout ce qui l'entoure. Dans notre API, c'est `main_content=true`, le mode par défaut.

**Readability** — À la fois une qualité de texte et le nom d'une famille bien connue d'algorithmes qui notent les blocs d'une page pour trouver le contenu principal, comme le font les modes lecture des navigateurs.

**Boilerplate** — Le texte répété sur chaque page d'un site : menus, avis de cookies, barres latérales, pieds de page, boutons de partage. Le retirer représente l'essentiel du travail d'un lecteur de pages web.

**Markdown** — Un format en texte brut où `#` marque un titre, `-` un élément de liste et `[text](url)` un lien. Les modèles le lisent bien et il consomme bien moins de tokens que le HTML.

**Métadonnées** — Des informations sur une page plutôt que son texte : titre, description, auteur, date de publication, langue. WebReaderAPI les renvoie à côté du Markdown quand la page les indique.

**Extraction PDF** — Convertir le texte d'un fichier PDF en Markdown. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

**Sitemap** — Un fichier XML où un site liste ses pages. Un crawl démarre à partir de lui quand il existe, ce qui permet de trouver les pages plus vite et avec moins de requêtes.

**Paywall** — Une barrière qui n'affiche le contenu qu'aux abonnés. WebReaderAPI ne lit jamais derrière un paywall.

## Côté crawler

**Crawler** — Un programme qui récupère des pages web dans un but précis. Le nôtre ne récupère que les pages demandées par les clients, et la [page bot](https://webreaderapi.com/fr/bot/) le décrit.

**User agent** — Le nom qu'un client envoie avec chaque requête. Le nôtre est `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, ainsi les propriétaires de sites savent toujours qui demande.

**robots.txt** — Un fichier à la racine d'un site qui indique aux crawlers les chemins qu'ils peuvent récupérer, normalisé sous le nom RFC 9309. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées.

**Crawl-delay** — Une ligne de robots.txt demandant aux crawlers d'attendre un certain nombre de secondes entre les requêtes. Nos crawls la respectent.

**Content Signals** — Une politique pour les lignes de robots.txt telles que `Content-Signal: search=yes, ai-input=no`, qui précisent comment le contenu d'un site peut être utilisé, y compris par l'IA.

**ai-input** — Le réglage Content Signals qui couvre l'utilisation d'une page comme entrée pour une réponse d'IA. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous.

**llms.txt** — Un fichier Markdown que certains sites publient à l'adresse `/llms.txt` pour donner aux modèles de langage un court guide de leur contenu et de leurs pages clés.

**Crawl** — Lire de nombreuses pages d'un même site en suivant ses liens et son sitemap. Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay.

**Traitement par lot** — Une liste d'URL envoyée en une seule requête et traitée en arrière-plan. Jusqu'à 100 URLs par job batch.

**HTTP 403** — Le statut qu'un serveur envoie pour refuser une requête. Quand un site répond 403 à notre crawler, l'API renvoie `target_refused` et ne facture rien.

**HTTP 429** — Le statut pour trop de requêtes. Venant d'un site, il signifie de ralentir ; venant de notre API (`concurrency_limit`), il signifie que votre compte a atteint sa limite de lectures simultanées.

**Backoff exponentiel** — Attendre plus longtemps après chaque tentative échouée (par exemple 1, puis 2, puis 4 secondes) avant de réessayer, pour ne pas saturer un serveur surchargé.

## Côté IA

**Token** — L'unité qu'un modèle de langage lit et sur laquelle il est facturé, en gros un mot court ou une partie de mot. Un Markdown propre consomme bien moins de tokens que la même page en HTML.

**Fenêtre de contexte** — La quantité de texte qu'un modèle peut traiter d'un coup. Le paramètre `max_chars` maintient chaque page dans le budget que vous fixez.

**RAG** — Génération augmentée par récupération : le modèle répond à partir de documents récupérés pour la question. Un lecteur de pages web fournit ces documents depuis des pages en direct.

**Chunking** — Découper un long document en passages avant de l'indexer. Les titres Markdown offrent des points de découpe naturels.

**Embedding** — Une liste de nombres qui représente le sens d'un passage, utilisée pour trouver les passages proches d'une question.

**Vector store** — Une base de données qui stocke les embeddings et renvoie les passages les plus proches d'une requête, le logement habituel des pages web découpées en chunks dans un système RAG.

**Tool calling** — La capacité d'un modèle à demander à l'application d'exécuter une fonction, comme lire une URL, et à exploiter le résultat. Voir [OpenAI function calling](https://webreaderapi.com/fr/docs/openai/).

**MCP** — Le Model Context Protocol, une façon standard de brancher des outils dans des clients IA comme Claude Desktop ou Cursor. Notre [page MCP](https://webreaderapi.com/fr/docs/mcp/) présente un outil de récupération construit sur l'API.

## Côté facturation

**Crédit** — L'unité d'usage de l'API. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

**Concurrence** — Le nombre de lectures que votre compte peut exécuter au même moment. Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter.

**KYC** — Know your customer : contrôles d'identité que certains services exigent, comme une pièce d'identité ou un selfie. WebReaderAPI n'en demande aucun.

**Stablecoin** — Une cryptomonnaie indexée sur une devise comme le dollar américain. USDT et USDC sont les deux acceptées pour les recharges ; la liste complète des coins est BTC, USDT, USDC, ETH, SOL, LTC.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Comment convertir une page web en Markdown pour un LLM

> Convertir une page web en Markdown pour un LLM en 2026 : trois méthodes, ce qu'un Markdown propre conserve et du code Python qui découpe la page en chunks.

- URL: https://webreaderapi.com/fr/guides/convert-web-page-to-markdown/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Le copier-coller suffit pour une page. Une bibliothèque convient si vous faites tourner votre propre crawler. Une API convient quand vous voulez une requête par page. Voici comment choisir, à quoi ressemble un bon résultat, et du code réutilisable.

**Réponse rapide — Comment convertir une page web en Markdown pour un LLM ?**

Récupérez la page, ne gardez que son contenu principal, puis transformez titres, listes, tableaux et liens en Markdown et plafonnez la longueur selon le budget de votre modèle. Vous pouvez le faire à la main, avec des bibliothèques open source, ou en un seul appel API : **WebReaderAPI** renvoie le Markdown et les métadonnées pour un crédit par page, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## Trois façons d'obtenir du Markdown depuis une page web

| Attribut | Valeur |
| --- | --- |
| À la main | Copiez le texte depuis le navigateur ou sa vue lecture ; suffisant pour quelques pages |
| Bibliothèques open source | Readability, Trafilatura, MarkItDown ou Crawl4AI dans votre propre fetcher |
| Une API de lecture de pages web | `GET https://webreaderapi.com/api/v1/read?url=…` renvoie le Markdown, le titre, l'auteur et la date |
| Contrôle de la longueur | `max_chars` sur WebReaderAPI, ou coupez le texte vous-même après conversion |
| Pages JavaScript | Nécessite un navigateur headless ; WebReaderAPI les rend lorsque c'est nécessaire, pour 2 crédits |

## Quelle méthode dois-je utiliser ?

Choisissez selon le volume et selon l'infrastructure que vous voulez faire tourner.

| Méthode | Adaptée à | À votre charge |
|---|---|---|
| Copier-coller | Une poignée de pages, une requête ponctuelle | Le nettoyage à la main |
| Bibliothèque dans votre code | Volumes réguliers, contrôle total | Récupération, navigateurs, robots.txt, PDF, nouvelles tentatives |
| API de lecture de pages web | Agents et pipelines qui lisent de nombreux sites | Uniquement la requête et le résultat |

Les bibliothèques vous donnent le contrôle sans frais par page. Le coût est opérationnel : un navigateur headless pour les pages JavaScript, une vérification de robots.txt, la gestion du jeu de caractères et des redirections, et un chemin séparé pour les PDF. Une API regroupe tout cela en un seul appel HTTP.

## Que doit conserver un bon Markdown, et que doit-il supprimer ?

Un bon Markdown conserve chaque élément porteur de sens et supprime tout ce qui n'existe que pour la mise en page ou le marketing.

- **Conservez les titres** en `#`, `##` et `###` : ils indiquent au modèle, et à votre chunker, où commence chaque sujet.
- **Conservez les listes et les tableaux** sous forme de listes Markdown et de tableaux à barres verticales, pour que les étapes et les chiffres restent lisibles.
- **Conservez les liens** en `[text](url)` : ils permettent à un assistant de citer et de suivre les sources.
- **Conservez les blocs de code** délimités, avec le langage lorsque la page l'indique.
- **Supprimez les menus, les bannières de cookies, les publicités, les widgets d'articles liés et les pieds de page** : ils se répètent sur chaque page et polluent la récupération.

Vérifiez le résultat sur quelques-unes de vos vraies pages. Les outils d'extraction divergent surtout sur les forums, les longs tableaux et les pages contenant plusieurs articles.

## De combien le Markdown est-il plus petit que le HTML ?

Généralement bien plus petit, car l'habillage de la page et le balisage disparaissent. Lorsque Cloudflare a lancé sa fonctionnalité Markdown for Agents le 12 février 2026, sa page d'exemple est passée de 16 180 tokens en HTML à 3 150 tokens en Markdown, environ 80 % de moins.

Votre propre ratio dépend du site. Les longs articles diminuent moins, en pourcentage, que les pages courtes enveloppées dans des templates lourds. Mesurez sur vos sources avant de dimensionner un budget.

## Comment garder une page dans le budget de tokens de mon modèle ?

Plafonnez le texte avant qu'il n'atteigne le modèle, puis découpez ce qui reste au niveau des titres. Avec WebReaderAPI, le paramètre `max_chars` coupe le Markdown à une longueur définie, entre 1 000 et 500 000 caractères. Le champ `word_count` vous indique la longueur de l'article complet, pour qu'un agent puisse décider si lire le reste en vaut la peine.

Pour la récupération, découpez d'abord sur les titres, puis coupez les longues sections. Un chunk qui commence par son propre titre conserve son sujet ; un chunk coupé en pleine phrase depuis une longue page, non.

*Python : lire une page en Markdown et la découper en chunks basés sur les titres*

```python
import os
import re

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


def page_to_chunks(url, max_chars=60000, chunk_len=1500):
    params = {"url": url, "format": "markdown", "max_chars": max_chars}
    resp = requests.get(API, headers=HEADERS, params=params, timeout=90)
    data = resp.json()
    if resp.status_code != 200:
        print("not read:", data["error"]["code"])
        return []
    chunks = []
    for section in re.split(r"\n(?=#{1,3} )", data["markdown"]):
        section = section.strip()
        while section:
            chunks.append(section[:chunk_len])
            section = section[chunk_len:]
    return [{"text": c, "source": data["final_url"], "title": data["title"]} for c in chunks]


if __name__ == "__main__":
    for chunk in page_to_chunks("https://example.com/guides/compost")[:3]:
        print(chunk["title"], "|", chunk["text"][:80])

```

## Qu'est-ce qui tourne mal d'habitude, et comment le repérer ?

Quatre problèmes expliquent la plupart des mauvaises conversions :

- **Sortie vide.** La page construit son contenu en JavaScript. Cherchez un `word_count` faible ; rendez la page dans un navigateur, ou définissez `render=true`.
- **Texte de cookies ou de consentement dans le résultat.** L'extracteur a conservé une bannière. Privilégiez l'extraction du contenu principal et vérifiez les premières lignes de chaque résultat.
- **Tableaux manquants.** Certains sites dessinent les tableaux en images ou en éléments canvas ; aucun extracteur de texte ne peut les lire.
- **Un refus au lieu d'une page.** Le site interdisait l'accès dans robots.txt ou a refusé la requête. Respectez-le : demandez l'accès au propriétaire, ou utilisez une API ou un flux officiel si le site en propose un.

Aucun de ces problèmes ne se règle en réessayant plus vite. Lisez l'erreur, puis changez de méthode ou de source.

## Page web en Markdown : questions fréquentes

### Le Markdown est-il meilleur que le texte brut pour un LLM ?

Pour la plupart des pages, oui. Le Markdown conserve les titres, les listes, les tableaux et les liens à un faible coût en tokens, de sorte que le modèle voit la structure et peut citer les sources. Le texte brut est légèrement plus court mais perd cette structure.

### Puis-je convertir un site entier, pas seulement une page ?

Oui. Crawlez-le et convertissez chaque page. L'[API de crawl](https://webreaderapi.com/fr/crawl-api/) de WebReaderAPI fait les deux en une seule tâche : Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay.

### Puis-je convertir un PDF de la même façon ?

Oui, en envoyant l'URL du PDF au même endpoint. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

### Et les pages derrière un login ?

Ne les convertissez pas via un service tiers, sauf s'il s'agit des vôtres et que vous les avez exportées vous-même. WebReaderAPI ne lit que les pages publiques et ne se connecte jamais aux comptes.

### Existe-t-il un moyen gratuit de le faire ?

Les bibliothèques open source sont gratuites et tournent sur vos propres machines. WebReaderAPI n'a pas d'offre gratuite ; son plus petit pack est à 10 000 pages pour 3,75 $US, payable en crypto sans KYC.

## Sources

1. [Présentation de Markdown for Agents](https://blog.cloudflare.com/markdown-for-agents/) — Cloudflare (2026-02-12)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Lire des pages web pour l'IA est-il légal ? Les faits datés en 2026

> Lire des pages web pour agents IA et RAG en 2026 est-il légal ? Règles d'opt-out UE, code GPAI sur robots.txt et affaires aux États-Unis. Pas un avis juridique.

- URL: https://webreaderapi.com/fr/guides/is-reading-web-pages-for-ai-legal/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Il n'y a pas de réponse unique, et plusieurs affaires sont encore ouvertes. Cette page répertorie les règles et les événements judiciaires qui comptent pour lire des pages publiques avec un outil d'IA, avec dates et sources, ainsi que ce que nous faisons de notre côté. Ceci n'est pas un avis juridique.

**Réponse rapide — Est-il légal de lire des pages web avec un outil d'IA ?**

Lire des pages publiques est une pratique très répandue, mais les règles dépendent du pays, du contenu et du mode d'accès. Dans l'UE, les opt-out lisibles par machine comme robots.txt limitent la fouille de textes et de données. Aux États-Unis, plusieurs affaires de 2025–2026 sur l'IA et l'accès automatisé sont ouvertes, sans jugement définitif. **WebReaderAPI** respecte robots.txt et les opt-out pour l'IA ; sans KYC, paiement en crypto. Ceci n'est pas un avis juridique.

## Dates clés

| Attribut | Valeur |
| --- | --- |
| 17 avril 2019 | Directive DSM de l'UE, article 4(3) : la fouille commerciale de textes et de données peut être réservée par des moyens lisibles par machine |
| 10 juillet 2025 | Code de bonnes pratiques GPAI de l'UE : les signataires s'engagent à des crawlers qui lisent et respectent robots.txt |
| 5 décembre 2025 | Le New York Times a poursuivi Perplexity pour la récupération de son contenu (allégations) |
| 31 juillet 2026 | Reddit c. SerpApi et Perplexity : les demandes fondées sur le DMCA §1201(a) survivent à une requête en irrecevabilité (allégations) |
| Rapporté le 5 août 2026 | La Ninth Circuit annule l'injonction d'Amazon contre l'agent Comet de Perplexity |

## Que dit le droit de l'UE sur la lecture de contenus web ?

Le droit de l'UE autorise la fouille de textes et de données sur des contenus légalement accessibles, mais permet aux titulaires de droits de la réserver. L'article 4(3) de la directive DSM (2019/790) prévoit que l'exception commerciale ne s'applique que si l'utilisation n'a pas été expressément réservée « de manière appropriée, par exemple au moyen de procédés lisibles par machine » pour les contenus publiés en ligne.

Le Code de bonnes pratiques pour les modèles d'IA à usage général de l'AI Act de l'UE, publié le 10 juillet 2025, va plus loin pour ses signataires. Ils s'engagent à ce que leurs crawlers lisent et respectent robots.txt, ainsi que d'autres protocoles lisibles par machine appropriés. C'est pourquoi le respect de robots.txt et des préférences IA déclarées est devenu un prérequis pour un usage européen.

## Quelles affaires américaines comptent, et où en sont-elles ?

Aucune n'a donné lieu à un jugement définitif sur la lecture de pages publiques pour l'IA. Les faits connus à ce jour, tous des allégations sauf lorsque la justice a tranché :

- **Reddit c. SerpApi, Perplexity et autres (S.D.N.Y.).** Le 31 juillet 2026, le tribunal a laissé se poursuivre les demandes fondées sur le DMCA §1201(a) au stade des conclusions, en considérant les protections de Google fondées sur des challenges comme des mesures qui contrôlent l'accès. Aucun défendeur n'a été jugé responsable.
- **The New York Times c. Perplexity.** Déposée le 5 décembre 2025. Le Times allègue une récupération de son contenu au moment de la requête, après avoir bloqué Perplexity dans robots.txt.
- **Amazon c. Perplexity.** Comme rapporté le 5 août 2026, la Ninth Circuit a annulé une injonction contre l'agent d'achat Comet de Perplexity, notant que l'assistant exécutait les instructions de son utilisateur. La formation a précisé qu'elle ne posait aucune règle générale pour l'IA agentique.

La tendance est mitigée, et les appels se poursuivent. Considérez tout résumé, y compris celui-ci, comme daté.

## Qu'est-ce qui réduit le risque quand un outil d'IA lit des pages ?

Quelques pratiques reviennent dans chaque règle et chaque affaire ci-dessus :

- **Lire uniquement des pages publiques.** Aucun identifiant, aucun espace membres, aucun paywall.
- **Respecter les opt-out lisibles par machine.** robots.txt et les préférences IA déclarées, telles que `ai-input=no`.
- **Ne jamais contourner une protection.** Pas d'User-Agent déguisé, pas d'adresses tournantes pour échapper aux blocages, pas de résolution de challenges.
- **Éviter les données personnelles.** Ne pas collecter de profils, de coordonnées ni d'autres données sur des personnes privées.
- **Citer vos sources.** Conservez l'URL de chaque page et affichez-la quand une réponse s'appuie dessus.

Ce sont de bonnes pratiques, pas une garantie. Consultez un avocat pour votre propre cas d'usage.

## Que fait WebReaderAPI de son côté ?

Nous avons conçu le service autour de ces pratiques. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

Notre [Acceptable Use Policy](https://webreaderapi.com/fr/acceptable-use/) interdit de collecter des données personnelles sur des personnes privées et de lire des contenus derrière un identifiant ou un paywall. Chaque requête s'identifie comme `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, et notre [page crawler](https://webreaderapi.com/fr/bot/) explique aux propriétaires de sites comment nous joindre.

## Questions juridiques

### Le respect de robots.txt rend-il mon usage légal ?

Pas à lui seul. Il répond à la question de l'opt-out européen et démontre la bonne foi, mais le droit d'auteur, les contrats, le droit de la vie privée et les conditions de chaque site s'appliquent toujours. Ceci n'est pas un conseil juridique.

### Puis-je stocker les pages que je lis ?

Cela dépend du contenu, de votre objectif et de votre juridiction. WebReaderAPI ne conserve aucune copie des pages qu'il lit pour vous ; ce que vous stockez de votre côté relève de votre décision et de votre responsabilité.

### Lire une page pour un utilisateur est-il différent de crawler un site ?

Certains fournisseurs et une formation d'appel ont traité un agent piloté par l'utilisateur différemment d'un crawler. La loi n'est pas fixée, donc WebReaderAPI applique les mêmes règles robots.txt aux deux.

### Où puis-je en lire davantage ?

Notre [guide robots.txt](https://webreaderapi.com/fr/guides/robots-txt-for-ai-agents/) couvre les standards, et les sources ci-dessous renvoient aux textes et aux rapports. Pour votre propre situation, consultez un avocat dans votre juridiction.

## Sources

1. [Directive (UE) 2019/790, article 4](https://www.legislation.gov.uk/eudr/2019/790/article/4) — legislation.gov.uk (read 2026-10-22)
2. [L'AI Office publie la version finale du Code de bonnes pratiques pour les modèles d'IA à usage général](https://www.globalpolicywatch.com/2025/07/ai-office-publishes-final-version-of-the-code-of-practice-for-general-purpose-ai-models/) — Global Policy Watch (2025-07)
3. [Reddit c. SerpApi LLC](https://www.loeb.com/en/insights/publications/2026/08/reddit-v-serpapi-llc) — Loeb & Loeb (2026-08)
4. [NYT poursuit le moteur de recherche IA Perplexity](https://the-decoder.com/nyt-sues-ai-search-engine-perplexity-for-alleged-content-misuse/) — The Decoder (read 2026-10-22)
5. [Un tribunal américain annule l'injonction d'Amazon contre Perplexity](https://www.retail-insight-network.com/news/us-court-overturns-amazon-injunction-perplexity/) — Retail Insight Network (2026-08-05)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Générateur llms.txt : créez le fichier à partir d'un crawl de votre propre site

> Générez un fichier llms.txt pour votre site depuis un crawl : un script Python lit chaque page en Markdown et la liste avec un résumé. Données 2026.

- URL: https://webreaderapi.com/fr/guides/llms-txt-generator/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un fichier llms.txt liste les pages clés d'un site, avec une ligne pour chacune, dans un Markdown que les modèles lisent facilement. Ce guide donne des chiffres d'adoption honnêtes, puis un script qui crawle votre site et écrit le fichier pour vous.

**Réponse rapide — Comment générer un fichier llms.txt pour mon site ?**

Crawlez votre propre site, prenez le titre et le premier paragraphe de chaque page, et écrivez-les sous forme de liste Markdown sous le nom de votre site dans un fichier à l'emplacement `/llms.txt`. **WebReaderAPI** effectue le crawl : jusqu'à 10 000 pages par job, en Markdown avec métadonnées, à un crédit par page à partir de 0,07 $US/1K pages en octobre 2026. Le script Python ci-dessous écrit le fichier. Sans KYC ; payez en crypto.

## llms.txt en bref

| Attribut | Valeur |
| --- | --- |
| Ce que c'est | Un fichier Markdown proposé à la racine d'un site qui liste ses pages clés pour les modèles de langage |
| Adoption, 1 000 premiers sites | 9,3 % (93 sites) le 18 septembre 2026, selon Rankability |
| Sites disposant du fichier | De 4 088 à 36 120 entre juin 2025 et mai 2026, selon Originality.ai |
| Utilisation mesurée | 97 % des fichiers llms.txt n'ont reçu aucune requête dans une étude Ahrefs portant sur 137 000 domaines |
| Coût de construction avec WebReaderAPI | Un crédit par page crawlée ; 10 000 pages coûtent 3,75 $US |

## llms.txt vaut-il la peine d'être créé ?

Sa création est peu coûteuse, et son effet mesuré reste faible à ce jour. L'adoption progresse : Rankability a trouvé le fichier sur 9,3 % des 1 000 meilleurs sites le 18 septembre 2026, contre 0,3 % en juin 2025, bien que sa méthode ait changé entre les deux comptages. Originality.ai a compté les sites disposant du fichier, passant de 4 088 à 36 120 entre juin 2025 et mai 2026.

L'utilisation est une autre affaire. Une étude Ahrefs portant sur 137 000 domaines, rapportée par PPC Land le 2 juillet 2026, a constaté que 97 % des fichiers llms.txt ne recevaient aucune requête, et que les bots de récupération IA effectuaient 1,1 % des requêtes que les fichiers recevaient. Créez-en un si votre documentation est volumineuse et que vous voulez un index propre ; n'attendez pas qu'il modifie à lui seul la façon dont les assistants vous citent.

## Que contient un fichier llms.txt ?

Un titre, un résumé d'un paragraphe, puis des listes de liens regroupées avec une courte description pour chacun. Un fichier minimal ressemble à ceci :

- `# Example Docs` sur la première ligne, le nom du site ou du projet.
- `> One sentence on what the site covers.` comme résumé entre guillemets.
- `## Guides`, `## API reference` et d'autres sections, une par partie du site.
- `- [Page title](https://example.com/page): one line on what the page answers.` pour chaque page.

Gardez des descriptions factuelles et courtes. N'écrivez pas d'instructions destinées aux systèmes d'IA dans le fichier ; les assistants traitent de plus en plus ce type de texte comme une manipulation.

*Python : crawlez votre propre site et écrivez llms.txt*

```python
import os
import time
from collections import defaultdict
from urllib.parse import urlparse

import requests

API = "https://webreaderapi.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
SITE = "https://docs.example.com/"


def first_paragraph(markdown):
    for block in markdown.split("\n\n"):
        block = block.strip()
        if block and not block.startswith(("#", "-", "|", "!", ">")):
            return " ".join(block.split())[:160]
    return ""


job = requests.post(API + "/crawl", headers=HEADERS, json={"url": SITE, "limit": 300}, timeout=60).json()
pages, cursor, delay = [], None, 5
while True:
    params = {"cursor": cursor} if cursor else {}
    batch = requests.get(API + "/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=60).json()
    pages += [p for p in batch.get("results", []) if "markdown" in p]
    cursor = batch.get("next_cursor")
    if batch["status"] == "done" and not cursor:
        break
    if not cursor:
        time.sleep(delay)
        delay = min(delay * 2, 60)

sections = defaultdict(list)
for p in pages:
    path = urlparse(p["final_url"]).path.strip("/")
    section = path.split("/")[0].replace("-", " ").title() if path else "Home"
    summary = p.get("description") or first_paragraph(p["markdown"])
    sections[section].append("- [" + p["title"] + "](" + p["final_url"] + "): " + summary)

lines = ["# Example Docs", "", "> Documentation for the Example product.", ""]
for name in sorted(sections):
    lines += ["## " + name, ""] + sorted(sections[name]) + [""]
with open("llms.txt", "w", encoding="utf-8") as fh:
    fh.write("\n".join(lines))
print(len(pages), "pages written to llms.txt")

```

## Comment fonctionne le script ?

Il lance une tâche de crawl, collecte les résultats page par page, puis regroupe les pages par le premier dossier de leur chemin. Pour chaque page, il utilise la méta description quand le site en fournit une, et sinon le premier paragraphe du Markdown, tronqué à 160 caractères.

Modifiez `SITE`, la ligne de titre et la ligne de résumé pour correspondre à votre projet, et augmentez `limit` pour un site plus grand, jusqu'à 10 000 pages par tâche. Relisez la sortie avant de la publier : les noms de sections proviennent de la structure de vos URL et peuvent nécessiter une retouche humaine.

## Mon robots.txt doit-il autoriser le crawl ?

Oui. WebReaderAPI ne lit que ce que robots.txt autorise pour `WebReaderAPI` ou pour tous les robots, et il respecte tout `Crawl-delay` que vous définissez. Si votre propre site bloque les robots, ajoutez un groupe qui autorise notre token pendant la durée du crawl ; notre [page crawler](https://webreaderapi.com/fr/bot/) montre les lignes exactes.

Les pages interdites par robots.txt sont ignorées et non facturées, donc un fichier strict ne vous coûte rien de plus ; il exclut simplement ces pages de llms.txt.

## Combien cela coûte-t-il ?

Un crédit par page lue, deux pour les pages qui nécessitent un navigateur. Un site de documentation de 300 pages coûte 300 crédits, ou jusqu'à 600 s'il s'agit d'une application JavaScript. Cela tient facilement dans 10 000 pages pour 3,75 $US, en date d'octobre 2026, et les crédits restants demeurent sur votre compte : ils n'expirent jamais.

Reconstruisez le fichier quand votre documentation change. Si vous conservez la sortie du crawl, vous pouvez relire uniquement les pages modifiées avec une tâche par lots au lieu de tout crawler à nouveau.

## llms.txt : questions fréquentes

### Où placer le fichier llms.txt ?

À la racine de votre site, pour qu'il soit servi à `/llms.txt`, en texte brut ou en Markdown. Certains sites publient aussi `llms-full.txt` avec le texte intégral des pages listées.

### llms.txt remplace-t-il robots.txt ?

Non. robots.txt indique quels chemins les robots doivent éviter ; llms.txt liste les pages que vous voulez que les modèles trouvent. Gardez les deux. Notre [guide robots.txt](https://webreaderapi.com/fr/guides/robots-txt-for-ai-agents/) explique la différence.

### llms.txt fera-t-il citer mon site par ChatGPT ou Claude ?

Rien ne prouve qu'il le fait à lui seul. L'étude Ahrefs rapportée en juillet 2026 a constaté que 97 % des fichiers ne recevaient aucune requête. Des pages claires avec des réponses directes et des faits datés comptent davantage.

### Puis-je générer un llms.txt pour le site de quelqu'un d'autre ?

Uniquement pour vos propres sites ou avec l'accord du propriétaire. Le fichier parle au nom du site, il appartient donc au propriétaire du site de le publier.

## Sources

1. [Données d'adoption de llms.txt](https://www.rankability.com/data/llms-txt-adoption/) — Rankability (2026-09-18)
2. [L'adoption de llms.txt est multipliée par 8,8 mais 97 % des fichiers ne reçoivent aucune requête IA](https://ppc.land/llms-txt-adoption-rises-8-8x-but-97-of-files-get-zero-ai-requests/) — PPC Land (2026-07-02)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# robots.txt pour les agents IA et les fetchers : ce qui s'applique en 2026

> robots.txt pour les agents IA en 2026 : crawlers contre fetchers déclenchés par l'utilisateur, ce que disent OpenAI, Anthropic, Google et Perplexity.

- URL: https://webreaderapi.com/fr/guides/robots-txt-for-ai-agents/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

robots.txt a été écrit pour les crawlers, puis les agents IA sont arrivés, qui récupèrent une page parce qu'une personne l'a demandé. Les fournisseurs tracent désormais cette frontière différemment. Ce guide expose la norme, la politique déclarée de chaque fournisseur, les signaux plus récents, et le comportement de notre propre crawler.

**Réponse rapide — Les agents IA doivent-ils suivre robots.txt ?**

Cela dépend du fournisseur. robots.txt est une norme volontaire (RFC 9309, septembre 2022). Les crawlers qui construisent des index la suivent généralement ; pour les récupérations déclenchées par un utilisateur, OpenAI indique que ses règles peuvent ne pas s'appliquer, Google et Perplexity indiquent que leurs fetchers les ignorent généralement, et Anthropic indique que ses bots les respectent. **WebReaderAPI** suit robots.txt à chaque lecture, sans KYC et avec paiement en crypto.

## robots.txt et IA en octobre 2026

| Attribut | Valeur |
| --- | --- |
| Norme | RFC 9309, Robots Exclusion Protocol, septembre 2022 |
| OpenAI ChatGPT-User | les règles de robots.txt « peuvent ne pas s'appliquer » aux actions déclenchées par l'utilisateur |
| Anthropic (y compris Claude-User) | Indique que ses bots respectent les directives de robots.txt, y compris Crawl-delay |
| Fetchers déclenchés par l'utilisateur de Google | « ignorent généralement les règles de robots.txt » (page mise à jour le 2026-08-19) |
| Perplexity-User | « ignore généralement les règles de robots.txt » |
| Content Signals | Politique Cloudflare du 24 septembre 2025 : `search`, `ai-input`, `ai-train` |
| Préférences IA de l'IETF | Brouillons de groupe de travail, pas encore une RFC |
| WebReaderAPI | Respecte robots.txt et `ai-input=no` à chaque lecture ; jeton `WebReaderAPI` |

## À quoi sert réellement robots.txt ?

Il indique aux clients automatisés les chemins qu'un site préfère leur voir éviter. Le fichier se trouve à la racine d'un hôte, regroupe les règles par jeton user-agent et utilise des lignes `Allow` et `Disallow`. La RFC 9309, publiée en septembre 2022, a fait de cette convention de longue date un standard.

La RFC précise clairement que le fichier ne verrouille rien : « These rules are not a form of access authorization. » Le respect est volontaire. C'est pourquoi la politique déclarée de chaque fournisseur compte, et pourquoi les sites qui veulent des limites strictes utilisent aussi des pare-feu et de la gestion de bots.

## Pourquoi les crawlers et les fetchers déclenchés par l'utilisateur diffèrent-ils ?

Un crawler décide lui-même quelles pages visiter ; un fetcher déclenché par l'utilisateur visite une page parce qu'une personne l'a demandé. Beaucoup de fournisseurs traitent le second cas comme un navigateur agissant pour son utilisateur, et indiquent que robots.txt ne s'applique pas entièrement.

| Fetcher | Politique déclarée (consultée le 2026-10-22) |
|---|---|
| OpenAI ChatGPT-User | Les règles de robots.txt « peuvent ne pas s'appliquer » aux actions initiées par l'utilisateur ; les sites sont renvoyés à OAI-SearchBot pour le refus d'indexation en recherche |
| Anthropic Claude-User | Anthropic indique que ses bots respectent les directives de robots.txt ; bloquer Claude-User empêche la récupération pour les requêtes des utilisateurs |
| Fetchers déclenchés par l'utilisateur de Google | « ignorent généralement les règles de robots.txt » car un utilisateur a demandé la récupération |
| Perplexity-User | « ignore généralement les règles de robots.txt » pour la même raison |
| Serveur de fetch de référence MCP | Respecte robots.txt par défaut pour les fetches initiés par le modèle, pas pour ceux initiés par l'utilisateur |

La distinction est réelle et documentée. Si vous créez un agent, décidez de quel côté vous êtes et indiquez-le dans votre user agent et votre documentation.

## Que sont Content Signals, aipref et RSL ?

Ce sont de nouveaux moyens de préciser ce que les systèmes d'IA peuvent faire avec le contenu, et pas seulement si un robot peut le récupérer.

- **Content Signals.** Cloudflare a publié cette politique le 24 septembre 2025. Un robots.txt peut indiquer `search`, `ai-input` (utilisation comme entrée d'une réponse IA, par exemple pour le grounding) et `ai-train`. Le robots.txt géré par Cloudflare sert `search=yes, ai-train=no` par défaut.
- **Préférences IA de l'IETF (aipref).** Les brouillons de vocabulaire et de rattachement du groupe de travail étaient encore des Internet-Drafts en octobre 2026, destinés à devenir des Proposed Standards.
- **Web Bot Auth.** Un moyen pour les bots de signer leurs requêtes ; le groupe de travail de l'IETF a adopté son brouillon de protocole le 1er septembre 2026.
- **RSL (Really Simple Licensing).** Son site indique que la spécification RSL 1.0 est disponible ; elle permet aux éditeurs d'énoncer des conditions de licence, y compris le paiement au crawl, via robots.txt, des en-têtes ou RSS.

## llms.txt est-il la même chose que robots.txt ?

Non. robots.txt indique ce qu'il ne faut pas récupérer ; llms.txt est un fichier proposé qui liste les pages clés d'un site pour les modèles de langage. Son adoption progresse mais son usage mesuré reste faible. Rankability a relevé la présence de llms.txt sur 9,3 % des 1 000 principaux sites le 18 septembre 2026. Une étude Ahrefs portant sur 137 000 domaines, rapportée par PPC Land le 2 juillet 2026, a constaté que 97 % des fichiers llms.txt ne recevaient aucune requête.

Notre [guide llms.txt](https://webreaderapi.com/fr/guides/llms-txt-generator/) explique comment en créer un à partir d'un crawl de votre propre site, si vous en voulez un malgré tout.

## Comment WebReaderAPI traite-t-il robots.txt ?

Il le respecte à chaque lecture, y compris les lectures déclenchées par un client. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Pour les tâches de crawl, il attend aussi le `Crawl-delay` défini par un site.

Chaque requête porte le même User-Agent, `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`, afin que les propriétaires de sites puissent nous voir dans leurs logs et écrire des règles pour nous. Notre [page crawler](https://webreaderapi.com/fr/bot/) donne les détails et un contact en cas de problème.

*Exemples de robots.txt pour WebReaderAPI*

```text
# Block WebReaderAPI from the whole site
User-agent: WebReaderAPI
Disallow: /

# Or: allow it, but keep it out of one folder and slow it down
User-agent: WebReaderAPI
Disallow: /account/
Crawl-delay: 5

# Or: allow reading for search, but not as AI input (Content Signals)
User-agent: *
Content-Signal: search=yes, ai-input=no
Allow: /

```

## robots.txt pour l'IA : questions fréquentes

### Bloquer GPTBot empêche-t-il ChatGPT de lire ma page pour un utilisateur ?

Pas nécessairement. OpenAI documente des jetons distincts : GPTBot pour l'entraînement, OAI-SearchBot pour la recherche et ChatGPT-User pour les actions de l'utilisateur, et indique que les règles de robots.txt peuvent ne pas s'appliquer aux actions initiées par l'utilisateur. Vérifiez la documentation actuelle de chaque fournisseur.

### robots.txt a-t-il une valeur juridique ?

Pas en soi ; la RFC 9309 précise qu'il ne s'agit pas d'une autorisation d'accès. Dans l'UE, les opt-outs lisibles par machine comptent pour la fouille de textes et de données au titre de la directive DSM. Voir notre [aperçu juridique](https://webreaderapi.com/fr/guides/is-reading-web-pages-for-ai-legal/) ; il ne s'agit pas d'un avis juridique.

### Comment bloquer WebReaderAPI ?

Ajoutez un groupe `User-agent: WebReaderAPI` avec `Disallow: /` à votre robots.txt. Nos lectures le vérifient avant chaque page ; les pages interdites ne sont jamais lues.

### WebReaderAPI lit-il les pages qui indiquent ai-input=no ?

Non. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. L'API renvoie `403 blocked_by_site_policy` au client, sans frais.

## Sources

1. [RFC 9309 : Robots Exclusion Protocol](https://www.rfc-editor.org/rfc/rfc9309.html) — RFC Editor (September 2022)
2. [Présentation des crawlers OpenAI](https://developers.openai.com/api/docs/bots) — OpenAI (read 2026-10-22)
3. [Anthropic crawle-t-il des données du web, et comment les propriétaires de sites peuvent-ils bloquer le crawler ?](https://support.claude.com/en/articles/8896518-does-anthropic-crawl-data-from-the-web-and-how-can-site-owners-block-the-crawler) — Anthropic (2026-04-07)
4. [Fetchers déclenchés par l'utilisateur de Google](https://developers.google.com/crawling/docs/crawlers-fetchers/google-user-triggered-fetchers) — Google (updated 2026-08-19)
5. [Crawlers Perplexity](https://docs.perplexity.ai/guides/bots) — Perplexity (read 2026-10-22)
6. [Serveur de fetch MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch) — Model Context Protocol (read 2026-10-22)
7. [Content Signals Policy](https://blog.cloudflare.com/content-signals-policy/) — Cloudflare (2025-09-24)
8. [Documents du groupe de travail AI Preferences](https://datatracker.ietf.org/wg/aipref/documents/) — IETF (read 2026-10-22)
9. [Documents du groupe de travail Web Bot Auth](https://datatracker.ietf.org/wg/webbotauth/documents/) — IETF (read 2026-10-22)
10. [Really Simple Licensing](https://rslstandard.org/) — rslstandard.org (read 2026-10-22)
11. [Données d'adoption de llms.txt](https://www.rankability.com/data/llms-txt-adoption/) — Rankability (2026-09-18)
12. [L'adoption de llms.txt est multipliée par 8,8 mais 97 % des fichiers ne reçoivent aucune requête IA](https://ppc.land/llms-txt-adoption-rises-8-8x-but-97-of-files-get-zero-ai-requests/) — PPC Land (2026-07-02)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Pourquoi les agents IA reçoivent des erreurs 403 en récupérant des pages web

> Pourquoi le fetch web échoue avec une erreur 403 dans Claude Code, OpenClaw et d'autres agents IA en 2026 : Cloudflare, robots.txt, rate limits, et quoi faire.

- URL: https://webreaderapi.com/fr/guides/web-fetch-403-errors/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un 403 est un refus émis par un site. Depuis 2025, de plus en plus de sites le renvoient par défaut aux agents IA, et depuis septembre 2026, Cloudflare bloque le trafic des agents sur de nombreux nouveaux sites financés par la publicité. Voici comment distinguer les causes et ce que vous pouvez faire légitimement.

**Réponse rapide — Pourquoi mon agent IA reçoit-il un 403 lorsqu'il récupère une page ?**

Généralement parce que le site, ou son CDN, refuse le trafic automatisé ou IA. Cloudflare bloque les crawlers IA par défaut pour les nouveaux domaines depuis le 1er juillet 2025, et depuis le 15 septembre 2026, il bloque le trafic « Agent » sur les pages financées par la publicité des nouveaux domaines. D'autres causes sont les rate limits et les murs de connexion. La solution est la permission, pas le déguisement. **WebReaderAPI** renvoie la réponse du site, sans frais ; sans KYC, paiement en crypto.

## Causes fréquentes d'une récupération web échouée

| Attribut | Valeur |
| --- | --- |
| 403 depuis un CDN | La gestion des bots bloque les crawlers IA ou les agents par défaut sur de nombreux sites |
| 403 ou 401 depuis le site | Mur de connexion, espace membre, règles régionales ou blocage strict des agents connus |
| 429 | Trop de requêtes en peu de temps ; le site vous applique un rate limit |
| 402 | Le site demande un paiement, par exemple via Cloudflare pay per crawl |
| 200 mais texte vide | La page construit son contenu avec JavaScript ; pas une erreur, mais rien à lire |
| Refusé avant la récupération | Votre propre outil a respecté robots.txt et ignoré la page |

## Qu'est-ce qui a changé sur le web en 2025 et 2026 ?

Les grands fournisseurs d'infrastructure ont fait du blocage de l'IA une option par défaut. Trois changements datés expliquent la plupart des nouveaux 403 :

- **1er juillet 2025 :** Cloudflare a annoncé bloquer désormais les crawlers IA par défaut, en demandant à chaque nouveau domaine lors de l'inscription s'il souhaite les autoriser. Le même jour, il a lancé pay per crawl en bêta privée, qui répond avec un HTTP 402 et un prix.
- **1er juillet 2026 :** Cloudflare a introduit trois catégories de trafic IA : Search, Agent et Training. « Agent » inclut explicitement les fetchers de chat tels que ChatGPT-User.
- **15 septembre 2026 :** pour les nouveaux domaines, les préréglages de Cloudflare bloquent le trafic Training et Agent sur les pages qui affichent des publicités ; Search reste autorisé.

Un agent qui récupère une page pour un utilisateur relève de la catégorie Agent. Sur les sites financés par la publicité intégrés après septembre 2026, attendez-vous à des refus.

## Comment distinguer un blocage d'un bug ?

Lisez le code de statut et le body avant de changer quoi que ce soit.

| Ce que vous voyez | Signification probable | Étape suivante |
|---|---|---|
| 403 avec un challenge ou une page « access denied » | Le site ou son CDN refuse le trafic automatisé | Respectez-le ; cherchez une API ou demandez l'accès |
| 402 avec des headers de prix | Le site vend l'accès à la requête | Décidez si vous payez via son canal |
| 429 | Vous avez envoyé trop de requêtes | Ralentissez et réessayez plus tard avec un backoff |
| 401, ou une page de connexion | Le contenu nécessite un compte | Hors périmètre pour un reader public |
| 200 avec presque aucun texte | Contenu construit par JavaScript | Rendez la page dans un navigateur |
| Votre outil indique que robots.txt l'interdit | Le site a demandé aux robots de l'ignorer | Respectez-le |

Seuls le 429 et la page JavaScript vide sont des problèmes techniques que vous pouvez résoudre de votre côté. Les autres sont des décisions prises par le propriétaire du site.

## Que peut faire légitimement un développeur d'agent ?

Travaillez avec le site, pas contre lui. Ces étapes résolvent de nombreux échecs et gardent votre agent du bon côté des propriétaires de sites :

1. **Utilisez le canal propre au site.** De nombreux sites proposent une API, un flux RSS ou Atom, ou un sitemap avec le contenu dont vous avez besoin.
2. **Demandez l'accès.** Les propriétaires de sites peuvent autoriser un bot nommé dans robots.txt ou dans les réglages de leur CDN. Un User-Agent clair et une page de contact facilitent cette démarche.
3. **Rendez les pages autorisées mais vides.** Pour les pages uniquement JavaScript, utilisez un reader qui exécute un navigateur headless.
4. **Ralentissez et mettez en cache.** Lisez la même page une fois, stockez-la et respectez les réponses `Crawl-delay` et 429.
5. **Payez là où le site vend l'accès.** Un 402 est une offre ; acceptez-la via le canal du site ou laissez la page de côté.

Chacune de ces étapes laisse le propriétaire du site aux commandes, ce qui permet aussi à votre agent de rester utile dans la durée.

## Que ne dois-je jamais faire pour contourner un refus ?

Ne déguisez jamais l'agent et ne contournez jamais une protection. Falsifier le User-Agent d'un navigateur, faire tourner les adresses IP pour échapper à un blocage ou résoudre des pages de challenge transforme un client poli en un outil conçu pour contourner des contrôles d'accès. En 2026, deux tribunaux américains ont considéré ces techniques comme du contournement dans des procès portant sur l'accès automatisé à des résultats de recherche. Les affaires sont toujours en cours et rien n'est tranché, mais le risque n'est pas théorique.

Cela rompt aussi la confiance avec les sites dont dépendent vos utilisateurs. Un refus est une information : notez-le, indiquez à l'utilisateur que la page n'était pas disponible et passez à une autre source.

## Que font les outils de récupération intégrés quand un site refuse ?

La plupart renvoient l'erreur au modèle, qui indique ensuite à l'utilisateur qu'il n'a pas pu lire la page. La documentation d'OpenClaw, consultée le 22 octobre 2026, indique que son web_fetch intégré extrait le contenu avec Readability, n'exécute pas JavaScript et limite la sortie à 20 000 caractères ; il peut se rabattre sur un fournisseur de récupération, et des plugins peuvent en enregistrer de nouveaux. Le serveur fetch de référence MCP respecte robots.txt par défaut pour les récupérations lancées par le modèle.

Quand ces outils échouent sur des pages qui autorisent robots mais nécessitent JavaScript, un reader qui rend les pages aide. Quand ils échouent parce que le site a refusé, aucun outil ne doit changer la réponse.

## Que renvoie WebReaderAPI quand un site refuse ?

Il renvoie le refus clairement, et vous n'êtes pas facturé. Une page interdite par robots.txt renvoie `403 blocked_by_robots`. Un site déclarant `ai-input=no` renvoie `403 blocked_by_site_policy`. Un site qui refuse la requête d'une autre manière renvoie `502 target_refused`, avec le code de statut propre au site dans `target_status`.

Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Votre agent peut montrer à l'utilisateur exactement pourquoi une page a été ignorée. La [page des erreurs](https://webreaderapi.com/fr/docs/errors/) liste chaque code avec la règle de retry correspondante.

## Erreurs de récupération web : questions fréquentes

### Pourquoi une page s'ouvre-t-elle dans mon navigateur mais échoue dans mon agent ?

Parce que le site traite différemment les personnes et les clients automatisés. La gestion des bots peut autoriser les navigateurs et refuser les agents, et certains sites bloquent le trafic IA par défaut. La page est publique pour les lecteurs, pas nécessairement pour les robots.

### Réessayer suffit-il à corriger un 403 ?

Rarement. Un 403 est une décision, pas un incident. Réessayez les 429, les timeouts et les erreurs réseau avec un backoff exponentiel ; considérez le 403 comme définitif sauf si le propriétaire du site en décide autrement.

### WebReaderAPI peut-il lire des pages que mon agent ne peut pas ?

Uniquement les pages qui autorisent robots mais nécessitent un navigateur pour afficher leur texte, car WebReaderAPI rend le JavaScript lorsque c'est nécessaire. Il ne peut pas lire les pages qu'un site refuse, et n'essaie pas de le faire.

### Comment faire autoriser mon bot sur un site ?

Utilisez un User-Agent stable et descriptif avec une URL de contact, respectez robots.txt, gardez un débit de requêtes faible et demandez au propriétaire. Les dispositifs d'agents signés tels que Web Bot Auth permettent aux sites de vérifier qui vous êtes.

## Sources

1. [Communiqué de presse : crawlers IA bloqués par défaut](https://www.cloudflare.com/press-releases/2025/cloudflare-just-changed-how-ai-crawlers-scrape-the-internet-at-large/) — Cloudflare (2025-07-01)
2. [Présentation de pay per crawl](https://blog.cloudflare.com/introducing-pay-per-crawl/) — Cloudflare (2025-07-01)
3. [Blog : options de trafic Search, Agent et Training](https://blog.cloudflare.com/content-independence-day-ai-options/) — Cloudflare (2026-07-01)
4. [Blog : nouveaux réglages par défaut pour les crawlers et agents IA](https://blog.cloudflare.com/accountable-mixed-use-ai-crawlers/) — Cloudflare (2026-09-15)
5. [Outil de récupération de page web](https://docs.openclaw.ai/tools/web-fetch.md) — OpenClaw (read 2026-10-22)
6. [Serveur de fetch MCP](https://github.com/modelcontextprotocol/servers/tree/main/src/fetch) — Model Context Protocol (read 2026-10-22)
7. [Reddit c. SerpApi LLC](https://www.loeb.com/en/insights/publications/2026/08/reddit-v-serpapi-llc) — Loeb & Loeb (2026-08)
8. [La plainte de Google contre SerpApi rejetée](https://seroundtable.com/google-lawsuit-serpapi-dismissed-41731.html) — Search Engine Roundtable (2026-07-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Qu'est-ce qu'une API de lecture de pages web ? Une URL en entrée, du Markdown lisible en sortie

> WebReaderAPI : une URL en entrée, l'extraction du contenu principal de la page en Markdown propre pour un LLM, et ses différences avec le scraping web.

- URL: https://webreaderapi.com/fr/guides/what-is-a-web-reader-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Une API de lecture de pages web transforme une page destinée aux humains en texte exploitable par un modèle. Ce guide explique ce qu'elle fait étape par étape, où elle se situe à côté du scraping et des API de recherche, et comment le marché la facture.

**Réponse rapide — Qu'est-ce qu'une API de lecture web ?**

Une API de lecture de pages web est un service qui prend une URL, charge la page et renvoie son contenu principal sous forme de texte propre, généralement en Markdown, avec des métadonnées comme le titre, l'auteur et la date. Les agents IA et les pipelines RAG l'utilisent à la place du HTML brut. **WebReaderAPI** en est une : un crédit par page, à partir de 0,07 $US/1K pages en octobre 2026, avec robots.txt respecté, sans KYC et paiement en crypto.

## Une API de lecture de pages web en un tableau

| Attribut | Valeur |
| --- | --- |
| Entrée | L'URL d'une page web publique ou d'un PDF |
| Sortie | Du Markdown du contenu principal, ou du texte brut, avec titre, auteur, date et langue |
| Supprimé | Navigation, bannières de cookies, publicités, barres latérales, pieds de page, scripts et styles |
| Pages JavaScript | Rendu dans un navigateur headless quand le HTML brut contient trop peu de texte |
| Facturation typique | Par page ou par crédit ; certains fournisseurs facturent au token de sortie |
| Exemple de requête | `GET https://webreaderapi.com/api/v1/read?url=https://example.com/post` |

## Que fait une API de lecture de pages web, étape par étape ?

Elle accomplit cinq tâches dont tout pipeline page-vers-texte a besoin, en un seul appel :

1. **Vérifier l'autorisation.** Un lecteur soigneux consulte le robots.txt du site pour son propre nom et pour tous les robots avant de récupérer quoi que ce soit.
2. **Récupérer la page.** Il télécharge le HTML, suit les redirections et s'arrête au bout d'un timeout.
3. **Faire le rendu si nécessaire.** Si le HTML n'est qu'une coquille vide remplie par JavaScript, il charge la page dans un navigateur headless et lit le résultat.
4. **Extraire le contenu principal.** Une étape de type readability identifie le corps de l'article ou de la documentation et écarte l'habillage autour.
5. **Convertir et décrire.** Il écrit le contenu en Markdown et ajoute des métadonnées : titre, auteur, date de publication, langue et nombre de mots.

L'appelant reçoit un objet JSON contenant le Markdown. Un modèle peut le lire d'un coup, ou un pipeline peut le découper en chunks pour un vector store.

## Pourquoi les modèles ont-ils besoin de Markdown plutôt que de HTML ?

Parce que l'essentiel d'une page HTML n'est pas du contenu. Les menus, les balises script, le code de suivi et le balisage de mise en page mobilisent des tokens que le modèle doit lire et que vous devez payer. Le Markdown conserve les parties porteuses de sens : titres, listes, tableaux, liens et emphase.

Cloudflare en a donné un exemple concret lors du lancement de sa fonctionnalité « Markdown for Agents » le 12 février 2026 : une page est passée de 16 180 tokens en HTML à 3 150 tokens en Markdown, soit environ 80 % de moins. Les résultats varient selon la page, mais la tendance est la même sur la plupart des articles et pages de documentation.

## En quoi une API de lecture de pages web diffère-t-elle d'une API de scraping ?

Une API de scraping renvoie ce que le serveur a envoyé ; un lecteur renvoie ce qu'une personne lirait. Les API de scraping sont conçues pour récupérer des pages à grande échelle, souvent pour extraire des champs précis comme des prix ou des noms de produits, et elles renvoient généralement du HTML brut ou du JSON structuré que vous définissez.

Un lecteur de pages web est plus étroit et plus tranché. Il décide ce qu'est le contenu principal, supprime le reste et écrit du texte propre. C'est le bon outil quand le consommateur suivant est un modèle de langage, un index de recherche ou une personne qui lit un résumé. C'est le mauvais outil quand vous avez besoin de chaque champ d'une grille de produits ; pour cela, il vous faut le HTML complet ou une extraction basée sur un schéma.

## En quoi diffère-t-elle d'une API de recherche ?

Une API de recherche répond à « quelles pages parlent de ceci ? » ; un lecteur répond à « que dit cette page ? ». La recherche renvoie une liste d'URL avec titres et extraits pour une requête. Un lecteur prend l'une de ces URL et renvoie son texte intégral.

Les agents enchaînent souvent les deux : recherche pour trouver des pages candidates, puis lecture des trois ou quatre meilleures pour répondre avec des citations. Garder les étapes séparées vous permet de choisir combien de pages lire, ce qui économise tokens et crédits.

## Puis-je utiliser des outils open source au lieu d'une API ?

Oui, et beaucoup d'équipes commencent ainsi. Readability de Mozilla extrait le contenu principal d'une page dans un contexte de navigateur ; Trafilatura fait l'extraction en Python ; MarkItDown de Microsoft convertit des documents, y compris des PDF, en Markdown ; Crawl4AI combine crawl et sortie Markdown.

La bibliothèque est la partie facile. L'exploiter en production implique d'héberger des navigateurs headless pour les pages JavaScript, de vérifier robots.txt, de gérer les timeouts, les redirections et les jeux de caractères, de convertir les PDF et de maintenir le tout à jour. Une API vaut le coup quand vous préférez payer à la page plutôt que d'exploiter cette mécanique ; une bibliothèque vaut le coup quand les volumes sont stables et que vous avez le temps de l'opérer.

## Comment les API de lecture de pages web facturent-elles ?

Trois modèles de facturation sont courants en 2026. Les offres à crédits facturent un nombre fixe de crédits par page : la page de tarifs de Firecrawl, consultée le 22 octobre 2026, compte 1 crédit par page scrapée et 4 crédits supplémentaires par page pour son format JSON. La facturation au token facture le texte renvoyé : Jina Reader applique ce modèle depuis le 6 mai 2025 et offre 10 millions de tokens gratuits à chaque nouvelle clé. Les offres mensuelles remettent leurs crédits à zéro à chaque cycle, tandis que les packs prépayés les conservent.

WebReaderAPI utilise des crédits prépayés qui n'expirent jamais : 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. 10 000 pages coûtent 3,75 $US et le tarif descend à 0,07 $US/1K pages sur 5 000 000 pages, en octobre 2026.

## Que vérifier avant de choisir une API de lecture de pages web ?

Testez-la sur vingt de vos propres URL et regardez six points :

- **Qualité d'extraction.** Le Markdown conserve-t-il l'article et écarte-t-il le reste, y compris les tableaux et les blocs de code ?
- **JavaScript.** Les pages construites dans le navigateur reviennent-elles avec du texte, et combien coûte le rendu ?
- **PDF.** Sont-ils pris en charge, et comment les pages sont-elles comptées ?
- **Choix des propriétaires de sites.** Le service respecte-t-il robots.txt et les préférences IA déclarées, et le dit-il dans sa documentation ?
- **Échecs.** Les pages en échec et refusées sont-elles facturées ?
- **Contrôle du budget.** Pouvez-vous plafonner la longueur de chaque page, et les crédits expirent-ils ?

Notre [comparaison des prix des API de lecture de pages web](https://webreaderapi.com/fr/compare/web-reader-api-pricing/) met les principaux fournisseurs côte à côte, avec les dates.

## API de lecture de pages web : questions fréquentes

### Une API de lecture de pages web, est-ce la même chose que le mode lecture d'un navigateur ?

C'est la même idée, garder l'article et écarter le superflu, mais elle tourne sur un serveur, renvoie du Markdown et des métadonnées en JSON, et fonctionne pour des milliers d'URL. Le mode lecture est fait pour une personne qui lit une page.

### Une API de lecture de pages web peut-elle lire n'importe quel site ?

Non. Elle lit les pages publiques qui l'autorisent. Un service soigneux évite les pages que robots.txt interdit et renvoie la réponse du site quand celui-ci refuse. Les pages derrière un login ou un paywall sont hors de portée par conception.

### Un lecteur de page web conserve-t-il les images ?

En général non par défaut, car les modèles ont surtout besoin du texte. Avec WebReaderAPI, `include_images=true` conserve les images sous forme de liens d'image Markdown avec leur texte alternatif.

### Combien de temps prend la lecture d'une page ?

Cela dépend du site et du fait que la page nécessite un navigateur ou non. Nous ne publions pas de temps de réponse tant que nous ne les avons pas mesurés sur un échantillon public ; prévoyez vos timeouts en fonction du paramètre `timeout`, qui va jusqu'à 60 secondes.

### Ai-je besoin d'un compte avec une pièce d'identité pour utiliser WebReaderAPI ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni document. Votre identifiant est un numéro de compte, et le paiement se fait en BTC, USDT, USDC, ETH, SOL, LTC.

## Sources

1. [Présentation de Markdown for Agents](https://blog.cloudflare.com/markdown-for-agents/) — Cloudflare (2026-02-12)
2. [Tarifs de Firecrawl](https://www.firecrawl.dev/pricing) — Firecrawl (read 2026-10-22)
3. [Reader API](https://jina.ai/reader/) — Jina AI (Elastic) (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# WebReaderAPI : faits, prix et politiques officiels

> Faits officiels sur WebReaderAPI : crédits de l'API de lecture de pages web depuis 0,07 $US/1K pages, sans KYC, crypto uniquement. Mis à jour le 2026-10-23.

- URL: https://webreaderapi.com/fr/llm-info/
- Dernière mise à jour: 2026-10-23
- Éditeur: WebReaderAPI (https://webreaderapi.com)

WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto. Chaque chiffre de cette page provient de la liste de prix en direct et des registres de la société, la même source que la [page de tarifs](https://webreaderapi.com/fr/pricing/) et [pricing.json](https://webreaderapi.com/pricing.json), et est régénéré à chaque mise à jour du site.

**Réponse rapide — Qu'est-ce que WebReaderAPI ?**

WebReaderAPI est une API de lecture de pages web pour les agents IA qui transforme toute page web publique en Markdown propre, payée en crypto sans envoi de pièce d'identité.

## Faits clés (2026-10-23)

| Attribut | Valeur |
| --- | --- |
| Produits | Crédits de l'API de lecture de pages web |
| Crédits de l'API de lecture de pages web — prix | À partir de 3,75 $US (10 000 pages) · [détails](https://webreaderapi.com/fr/pricing/) |
| KYC / vérification d'identité | Aucune — pas de pièce d’identité, pas de selfie, pas de documents pour vous inscrire, recharger ou acheter |
| E-mail requis pour s'inscrire | Non |
| Cryptomonnaies acceptées | Crypto uniquement : Bitcoin (BTC), Tether (USDT, TRC-20 ou ERC-20), USD Coin (USDC, ERC-20), Ethereum (ETH), Solana (SOL), Litecoin (LTC) |
| Recharge minimum | 25 $US — rechargez une fois un solde prépayé, puis achetez n'importe quel forfait à partir de celui-ci |
| Règle du solde | Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement |
| Opérateur | SerpGoat LLC |
| Support | L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations |
| Contact | [support@webreaderapi.com](mailto:support@webreaderapi.com) · signalements d'abus: [abuse@webreaderapi.com](mailto:abuse@webreaderapi.com) |

## Chaque offre et son prix

| Produit | Offre | Prix | Prix par unité |
| --- | --- | --- | --- |
| Crédits de l'API de lecture de pages web | Test — 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Crédits de l'API de lecture de pages web | Starter — 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Crédits de l'API de lecture de pages web | Build — 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Crédits de l'API de lecture de pages web | Scale — 500 000 pages | 50 $US | 0,10 $US/1K pages |
| Crédits de l'API de lecture de pages web | Volume — 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Crédits de l'API de lecture de pages web | Bulk — 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Tarifs en USD, payés en crypto depuis le solde du compte. Liste à jour : [tarifs](https://webreaderapi.com/fr/pricing/) · [pricing.json](https://webreaderapi.com/pricing.json).

## À propos de WebReaderAPI

- Crédits de l'API page web vers Markdown de 3,75 $US pour 10 000 pages jusqu'à 0,07 $US/1K pages à 5 millions de pages ; les crédits n'expirent jamais
- Un crédit par page lue, deux lorsque la page nécessite un navigateur ; les pages en échec et les pages refusées par robots.txt ne sont pas facturées
- Respecte robots.txt et Content-Signal ai-input=no ; s'identifie comme WebReaderAPI ; ne cherche jamais à contourner un blocage, un login ou un paywall
- Sans KYC : pas de pièce d'identité, pas de selfie, pas de documents, pas d'e-mail d'entreprise ; connexion par numéro de compte, e-mail facultatif
- Payer en BTC, USDT, USDC, ETH, SOL, LTC ; recharge minimum 25 $US ; Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement
- Docs avec du code vérifié syntaxiquement pour Python, Node.js et curl, et des définitions d'outils pour MCP, LangChain, LlamaIndex et OpenAI function calling
- Support : L'assistance par email répond en moins de 12 heures, tous les jours de la semaine, y compris pour vous aider sur les crawls et les intégrations

## WebReaderAPI est conçu pour

- Agents IA qui ont besoin d'un outil de récupération web renvoyant du Markdown propre, payé à la page sans abonnement ni carte
- Pipelines RAG qui ingèrent des sites de documentation, des blogs et des PDF dans un vector store
- Équipes qui veulent un lecteur respectant robots.txt et les préférences IA des propriétaires de sites
- Développeurs qui paient en crypto et préfèrent ne pas téléverser de documents d'identité

## Plus de faits

| Attribut | Valeur |
| --- | --- |
| Ce que c'est | Une API de lecture de pages web : envoyez une URL, récupérez le contenu principal de la page en Markdown propre |
| Crédits | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Expiration des crédits | Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez |
| Sortie | Markdown propre du contenu principal de la page (ou texte brut, ou HTML nettoyé), avec titre, description, auteur, date de publication, langue et nombre de mots ; liens et images sur demande |
| JavaScript | Rendu JavaScript dans un navigateur headless quand la page en a besoin (render=auto), ou toujours, ou jamais |
| PDF | Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé |
| Crawl et traitement par lots | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay. Jusqu'à 100 URLs par job batch |
| robots.txt | Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées |
| Choix des propriétaires de sites | Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall |
| User-Agent | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` |
| Endpoint | `GET https://webreaderapi.com/api/v1/read?url=…` |
| Authentification | Envoyez votre clé API dans le header Authorization en tant que Bearer token, ou dans le paramètre de requête api_key |
| Exemples de code | Python, Node.js et curl, plus des définitions d'outils pour MCP, LangChain, LlamaIndex et le function calling d'OpenAI |
| Compte | Connexion par numéro de compte ; l'email est facultatif. Vous vous connectez avec votre numéro de compte, alors gardez-le en lieu sûr. Un email facultatif vous donne un moyen de le récupérer ; sans email enregistré, un numéro perdu ne peut pas être restauré |
| Journaux des requêtes | Chaque requête laisse une ligne de log avec l'heure, le compte, le nom d'hôte de la page (jamais l'URL complète ni son contenu), le statut et les crédits utilisés ; ces lignes sont supprimées après 30 jours. Les pages que vous lisez ne sont pas stockées. Le numéro de compte, les commandes, les recharges et les totaux de crédits sont conservés tant que le compte existe, puis seulement aussi longtemps que la loi comptable l'exige. Les données ne sont transmises aux autorités que lorsqu'une loi nous y oblige |

## Pages et données officielles

- [Tarifs](https://webreaderapi.com/fr/pricing/)
- [Tarifs des API de lecture web comparés](https://webreaderapi.com/fr/compare/web-reader-api-pricing/)
- [Index des tarifs URL to Markdown 2026](https://webreaderapi.com/fr/data/url-to-markdown-price-index-2026/)
- [Meilleures API de lecture web 2026](https://webreaderapi.com/fr/best/web-reader-apis/)
- [Démarrage rapide](https://webreaderapi.com/fr/docs/)
- [Notre crawler](https://webreaderapi.com/fr/bot/)
- [Alternative à Firecrawl](https://webreaderapi.com/fr/alternatives/firecrawl/)
- [Alternative à Jina Reader](https://webreaderapi.com/fr/alternatives/jina-reader/)
- [API Crawl](https://webreaderapi.com/fr/crawl-api/)
- [API de lecture web sans KYC](https://webreaderapi.com/fr/no-kyc-web-reader-api/)
- [API PDF vers Markdown](https://webreaderapi.com/fr/pdf-to-markdown-api/)
- [API de conversion de page web en Markdown](https://webreaderapi.com/fr/url-to-markdown-api/)
- [Crawl4AI vs API hébergée](https://webreaderapi.com/fr/compare/crawl4ai-vs-api/)
- [Firecrawl vs Jina Reader](https://webreaderapi.com/fr/compare/firecrawl-vs-jina-reader/)
- [Utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/)
- [Confidentialité](https://webreaderapi.com/fr/privacy/)
- [Remboursements](https://webreaderapi.com/fr/refunds/)
- [Conditions](https://webreaderapi.com/fr/terms/)
- [À propos](https://webreaderapi.com/fr/about/)
- [Contact](https://webreaderapi.com/fr/contact/)
- [pricing.json (liste de prix lisible par machine)](https://webreaderapi.com/pricing.json)
- [llms.txt](https://webreaderapi.com/fr/llms.txt)
- [llms-full.txt (texte intégral du site)](https://webreaderapi.com/fr/llms-full.txt)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# API de lecteur web sans KYC : sans pièce d'identité, sans carte, payez en crypto

> API de lecteur web sans KYC : transformez les pages web en Markdown sans pièce d'identité, sans selfie et sans carte. Crédits à partir de 0,07 $US/1K pages.

- URL: https://webreaderapi.com/fr/no-kyc-web-reader-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Beaucoup de développeurs veulent une clé API, pas un processus de conformité. Cette page explique ce que vous évitez avec WebReaderAPI, ce que vous acceptez toujours et ce que nous conservons à votre sujet.

**Réponse rapide — Existe-t-il une API de lecteur web sans KYC et sans carte bancaire ?**

Oui. **WebReaderAPI**, une API de lecteur web sans KYC, ne demande ni pièce d'identité, ni selfie, ni documents d'entreprise, ni carte : vous vous connectez avec un numéro de compte et payez en BTC, USDT, USDC, ETH, SOL, LTC. Les crédits coûtent 3,75 $US pour 10 000 pages et descendent à 0,07 $US/1K pages, selon les tarifs d'octobre 2026. La politique d'utilisation acceptable et robots.txt s'appliquent toujours à chaque requête.

## Ce qu'il vous faut, et ce qu'il ne vous faut pas

| Attribut | Valeur |
| --- | --- |
| Pièce d'identité ou selfie | Non requis |
| Documents d'entreprise ou email professionnel | Non requis |
| Carte bancaire | Non requise : crypto uniquement |
| Connexion | Un numéro de compte ; ajouter un email est facultatif |
| Paiement | BTC, USDT, USDC, ETH, SOL, LTC, à partir d'un rechargement de 25 $US |
| Les règles qui s'appliquent toujours | Politique d'utilisation acceptable, robots.txt, refus des propriétaires de sites |
| Ce que nous conservons | Numéro de compte, email facultatif, enregistrements de paiement, 30 jours de logs avec les noms d'hôtes uniquement |

## Pourquoi une API sans vérification d'identité ?

Parce que rien dans le service ne dépend de savoir qui vous êtes. Vous payez avant d'utiliser quoi que ce soit, il n'y a donc aucun crédit à récupérer. Le comportement du crawler ne change pas selon le client : il suit le robots.txt de chaque site et s'arrête à chaque refus, peu importe qui a envoyé la requête.

Une vérification d'identité ajouterait un délai et un stockage de documents à protéger, sans rendre le service plus sûr pour les sites que nous lisons. Nous demandons ce dont le service a réellement besoin : un paiement et une clé.

## Comment fonctionne un compte sans email ?

Vous recevez un numéro de compte à l'inscription, et ce numéro est votre identifiant de connexion. Si vous ajoutez un email, il vous offre un moyen de retrouver l'accès au compte ; sans email, un numéro perdu ne peut pas être récupéré.

Dans le compte, vous créez des clés API, une par application ou par agent si vous le souhaitez, et vous révoquez n'importe laquelle quand vous voulez. Perdre une clé n'est pas un problème ; perdre le numéro de compte sans email en est un, alors conservez-le dans un gestionnaire de mots de passe.

## Quelles règles s'appliquent toujours sans KYC ?

Toutes les règles qui protègent les sites web et les personnes s'appliquent à chaque compte. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

La [politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/) interdit, entre autres, Lire des pages pour collecter des données personnelles sur des personnes privées, lire du contenu derrière un login ou un paywall, le matériel d'abus sexuel sur mineurs, le spam, la fraude, et tout usage qui enfreint la loi là où vous ou nous opérons. Les signalements sont vérifiés par une personne, et toute infraction entraîne une suspension. Sauter la vérification d'identité ne signifie jamais sauter ces règles.

## Que conservons-nous à votre sujet ?

Moins qu'un fournisseur d'API classique, car il y a moins à conserver : votre numéro de compte, un email facultatif, vos paiements et vos crédits, et des logs de requêtes qui ne contiennent que les noms d'hôtes, supprimés après 30 jours. Aucun contenu de page n'est stocké.

Nous ne détenons jamais de pièce d'identité, de selfie ni de numéro de carte, donc aucun ne peut fuiter. La [politique de confidentialité](https://webreaderapi.com/fr/privacy/) liste chaque élément et sa durée de conservation.

## Qui choisit un lecteur web sans KYC ?

Surtout des personnes pour qui la paperasse est la partie la plus lente quand on essaie un outil :

- **Développeurs indépendants** qui construisent un agent IA et veulent une clé en quelques minutes.
- **Petites équipes** sans carte d'entreprise, ou dans des pays où les paiements par carte vers des API étrangères échouent.
- **Projets autonomes et bots** financés par un portefeuille crypto plutôt qu'un compte bancaire.
- **Développeurs soucieux de la confidentialité** qui préfèrent partager le moins possible avec chaque fournisseur.

## Comment démarrer sans pièce d'identité ?

1. Créez un compte et conservez le numéro de compte.
2. Rechargez depuis 25 $US en BTC, USDT, USDC, ETH, SOL, LTC : envoyez le montant exact affiché sur le réseau indiqué, puis cliquez sur « I've sent the payment ». Le rechargement est crédité une fois confirmé.
3. Achetez un pack, par exemple 10 000 pages pour 3,75 $US, et copiez votre clé API.
4. Envoyez votre première URL à `https://webreaderapi.com/api/v1/read`, comme indiqué dans le [quick start](https://webreaderapi.com/fr/docs/).

## Combien coûte le lecteur web sans KYC ?

Les mêmes tarifs s'appliquent à chaque compte : 10 000 pages pour 3,75 $US, 100 000 pages pour 21,75 $US, jusqu'à 0,07 $US/1K pages sur le plus grand pack. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

Les packs s'achètent depuis un solde crypto rechargé d'au moins 25 $US. Prix en USD, fixés le 2026-10-22.

## Lecteur web sans KYC : questions fréquentes

### Puis-je utiliser WebReaderAPI sans carte bancaire ?

Oui, et en fait uniquement sans : les paiements se font en BTC, USDT, USDC, ETH, SOL, LTC. Aucune carte n'est enregistrée et rien ne se renouvelle automatiquement.

### Sans KYC, tout est-il permis ?

Non. Chaque requête suit robots.txt et s'arrête quand un site refuse, et la politique d'utilisation acceptable s'applique à chaque compte. La violer entraîne la suspension du compte.

### Me demanderez-vous des documents plus tard, par exemple au-delà d'un certain montant dépensé ?

Notre processus d'inscription et de recharge ne demande aucun document. Nous ne communiquons des informations aux autorités que lorsque la loi l'exige, comme l'indique la politique de confidentialité.

### Que se passe-t-il si je perds mon numéro de compte ?

Dans ce cas, le compte ne peut pas être récupéré, sauf si vous y avez ajouté un email. Conservez le numéro dans un gestionnaire de mots de passe et ajoutez un email si vous voulez une solution de secours.

### Un bot ou un agent peut-il payer ses propres crédits ?

Oui, tant que quelqu'un envoie la recharge depuis un wallet. Le compte fonctionne ensuite comme n'importe quel autre : achetez un pack, utilisez une clé, surveillez le solde avec `GET https://webreaderapi.com/api/v1/credits`.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# API PDF vers Markdown : envoyez un lien PDF, récupérez son texte en Markdown

> API PDF vers Markdown pour LLM et RAG : envoyez l'URL d'un PDF, récupérez son texte Markdown avec titres et tableaux, 100 pages, dès 0,07 $US/1K pages. Crypto.

- URL: https://webreaderapi.com/fr/pdf-to-markdown-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Rapports, articles, manuels et listes de prix sont souvent des PDF. Passez le lien au même endpoint que celui utilisé pour les pages web et récupérez le texte du document en Markdown, prêt à être découpé et vectorisé.

**Réponse rapide — Existe-t-il une API qui convertit un PDF depuis une URL en Markdown ?**

Oui. Avec **WebReaderAPI**, envoyez l'URL du PDF à `https://webreaderapi.com/api/v1/read` : l'API télécharge le fichier et renvoie son texte en Markdown, avec titres, paragraphes, listes et tableaux simples. Les fichiers jusqu'à 20 MB et 100 pages sont pris en charge, à 1 crédit par tranche de 10 pages entamée, à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payer en crypto.

## PDF vers Markdown en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Endpoint | `GET https://webreaderapi.com/api/v1/read?url=https://…/report.pdf` (le même que pour les pages web) |
| Limites | Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé |
| Sortie | Texte Markdown avec titres, paragraphes, listes et tableaux simples ; `format=text` pour le texte brut |
| Non pris en charge | PDF scannés sans couche de texte (pas d'OCR), fichiers protégés par mot de passe |
| robots.txt | S'applique aux liens PDF comme à toute autre page |
| Paiement | BTC, USDT, USDC, ETH, SOL, LTC, à partir d'une recharge de 25 $US ; sans KYC |

## Comment les pages d'un PDF sont-elles comptées ?

Un PDF coûte 1 crédit par tranche de 10 pages entamée. Une brochure de 4 pages coûte 1 crédit, un rapport de 25 pages 3 crédits et un manuel de 100 pages 10 crédits. La réponse indique le chiffre exact dans `credits_used`.

Les fichiers de plus de 20 MB ou de plus de 100 pages renvoient `422 unsupported_content` et ne consomment aucun crédit. Pour un document long, cherchez d'abord une version HTML du même contenu : elle est souvent moins chère et mieux structurée.

## À quoi ressemble le Markdown ?

Le convertisseur reconstruit l'ordre de lecture à partir de la couche de texte du PDF. Les lignes longues ou en gras au début d'une section deviennent des titres, les éléments à puces et numérotés deviennent des listes Markdown, et les tableaux à grille simple deviennent des tableaux Markdown.

Les en-têtes courants, pieds de page et numéros de page répétés sur chaque page sont supprimés, pour qu'ils ne coupent pas les phrases dans vos chunks. Les mises en page sur deux colonnes sont lues colonne par colonne. Les notes de bas de page restent en texte à l'endroit où la page les place.

*Python : lire un PDF et le découper en chunks par titre*

```python
import os
import re

import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/annual-report.pdf"},
    timeout=120,
)
resp.raise_for_status()
doc = resp.json()
chunks = [c.strip() for c in re.split(r"\n(?=#{1,3} )", doc["markdown"]) if c.strip()]
print(len(chunks), "chunks,", doc["credits_used"], "credit(s)")
for c in chunks[:3]:
    print(c.splitlines()[0])

```

## Quels PDF fonctionnent le mieux, et lesquels ne fonctionnent pas ?

Les PDF exportés depuis un traitement de texte, un site web ou un outil de publication fonctionnent le mieux : ils contiennent une couche de texte avec les polices et les positions. Les rapports annuels, articles de recherche, manuels produits, documents de politique et listes de prix entrent généralement dans cette catégorie.

Les documents scannés sont des images de pages et n'ont pas de couche de texte. WebReaderAPI n'effectue pas de reconnaissance optique de caractères : un scan renvoie donc peu ou pas de texte ; le champ `word_count` l'indique immédiatement. Les PDF protégés par mot de passe et chiffrés sont refusés avec `422 unsupported_content`, sans frais.

## Comment intégrer les PDF dans un pipeline RAG ?

Traitez-les comme des pages web. Lisez le PDF, découpez le Markdown selon ses titres, ajoutez l'URL source et le titre de la page aux métadonnées de chaque chunk, puis vectorisez. Conserver l'URL permet à votre assistant de citer le document utilisé.

Lorsqu'un crawl rencontre des liens vers des PDF sur le même domaine, il les lit avec les mêmes règles et les mêmes vérifications robots.txt. Voir le [guide RAG](https://webreaderapi.com/fr/use-cases/rag/) pour un exemple complet d'ingestion.

## Combien coûte la conversion d'un PDF ?

Les PDF puisent dans les mêmes crédits que les pages web : 1 crédit par tranche de 10 pages entamée. Avec 10 000 pages pour 3,75 $US, vous pouvez convertir environ 10 000 PDF courts ou 1 000 documents de 100 pages.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Scale | 500 000 pages | 50 $US | 0,10 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## API PDF vers Markdown : questions fréquentes

### Puis-je envoyer un fichier PDF au lieu d'un lien ?

Pas dans la version 1. L'API lit les PDF depuis une URL publique. Pour convertir un fichier privé, placez-le à une URL que vous contrôlez le temps de la requête.

### Extrait-il le texte des PDF scannés ?

Non. WebReaderAPI lit la couche de texte d'un PDF et n'effectue pas d'OCR. Un document scanné renvoie peu ou pas de texte, ce que le champ `word_count` indique.

### Les tableaux sont-ils conservés ?

Les tableaux à grille simple deviennent des tableaux Markdown. Les tableaux avec cellules fusionnées ou mises en page complexes sont conservés en texte dans l'ordre de lecture, que les modèles lisent encore bien.

### Un PDF est-il facturé en cas d'échec ?

Non. Les fichiers trop volumineux, trop longs, chiffrés ou refusés par le site ne sont pas facturés. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Tarifs de l'API web reader : des crédits de pages prépayés qui n'expirent jamais

> Tarifs WebReaderAPI : 3,75 $US pour 10 000 pages jusqu'à 0,07 $US/1K pages, des crédits qui n'expirent jamais, pages en échec gratuites. Sans KYC, crypto.

- URL: https://webreaderapi.com/fr/pricing/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un crédit lit une page ; une page qui nécessite un navigateur en coûte deux. Les pages en échec ou refusées par un site ne coûtent rien. Achetez un pack depuis votre solde crypto et utilisez-le à votre rythme. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.

**Réponse rapide — Combien coûte WebReaderAPI ?**

**WebReaderAPI** vend des crédits de pages prépayés : 10 000 pages pour 3,75 $US (0,38 $US/1K pages), 100 000 pages pour 21,75 $US, 1 000 000 pages pour 74,25 $US et 0,07 $US/1K pages à 5 millions, en octobre 2026. Une page lue avec un navigateur consomme deux crédits. Les pages en échec et les pages refusées par robots.txt sont gratuites, et les crédits n'expirent jamais. Sans KYC ; payez en crypto.

## Quel pack de crédits dois-je acheter ?

Six packs, la même API et les mêmes options dans chacun. Le prix par page baisse de 0,38 $US/1K pages sur le plus petit pack à 0,07 $US/1K pages sur le plus grand.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Scale | 500 000 pages | 50 $US | 0,10 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |
| Bulk | 5 000 000 pages | 350 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde. Comment fonctionne le paiement

## Comment les pages sont-elles comptées ?

Chaque réponse indique ce qu'elle a coûté en `credits_used`. Les règles :

- **Page statique : 1 crédit.** Le HTML de la page contenait son contenu.
- **Page qui a nécessité un navigateur : 2 crédits.** Avec `render=auto`, le navigateur ne s'exécute que si le HTML brut est presque vide ; `render=false` ne l'utilise jamais.
- **Pays choisi : +10 crédits.** Choisir le pays depuis lequel une page est lue coûte 10 crédits de plus, car la page est alors lue via une connexion résidentielle dans ce pays.
- **PDF : 1 crédit par bloc de 10 pages entamé.** Un rapport de 25 pages coûte 3 crédits.
- **Erreurs et refus : 0 crédit.** Les URLs invalides, les timeouts, les pages refusées par robots.txt ou par le site, et les fichiers que nous ne pouvons pas lire sont gratuits.
- **Vérifier votre solde : gratuit.** `GET https://webreaderapi.com/api/v1/credits` ne consomme aucun crédit.

## Les crédits inutilisés expirent-ils ?

Non. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez. Un pack acheté pour un crawl conserve sa valeur restante pour le suivant, et un agent inactif pendant un mois ne perd rien.

Si nous arrêtons un jour de vendre le service, les [conditions](https://webreaderapi.com/fr/terms/) vous accordent au moins 30 jours de préavis pour utiliser vos crédits ou transférer leur valeur. Une hausse de prix ne s'applique qu'aux packs achetés après sa publication.

## Quel pack correspond à ma charge de travail ?

Volumes typiques et pack qui les couvre. Comptez deux crédits pour les pages qui nécessitent un navigateur.

| Charge de travail | Pages | Pack suggéré |
| --- | --- | --- |
| Agent prototype ou crawl ponctuel d'un petit site | moins de 5 000 | 10 000 pages (3,75 $US) |
| Agent IA utilisé chaque jour par une petite équipe | 10 000 à 30 000 par mois | 50 000 pages (14,25 $US) |
| Index RAG de plusieurs sites de documentation, avec actualisations hebdomadaires | 30 000 à 80 000 | 100 000 pages (21,75 $US) |
| Produit qui lit des pages pour ses propres utilisateurs | 100 000 à 400 000 par mois | 500 000 pages (50 $US) |
| Corpus de recherche ou grande archive | 1 million et plus | 1 000 000 pages (74,25 $US) ou 5 000 000 pages (350 $US) |

## Comment ces prix se comparent-ils à ceux des autres API web reader ?

Prix pour 1 000 pages lorsque vous lisez 100 000 pages par mois, d'après la page tarifaire publique de chaque fournisseur. Le tableau complet, avec 21 API et trois volumes, se trouve sur [comparatif des tarifs d'API web reader](https://webreaderapi.com/fr/compare/web-reader-api-pricing/).

| Fournisseur et offre | Pages simples | Pages qui nécessitent un navigateur |
| --- | --- | --- |
| WebReaderAPI, 100 000 pages | 0,22 $US/1K pages | 2 crédits par page |
| Firecrawl Standard (99 $ pour 100 000 crédits) | $0.99 | 0,99 $ (chaque page rendue) |
| Olostep Standard (99 $) | $0.99 | 0,99 $ (chaque page rendue) |
| Crawl4AI Cloud Builder (99 $) | $0.50 | $0.99 |
| Scrape.do Hobby (29 $ pour 250 000 crédits) | $0.29 | 0,99 $ sur Pro |
| ScrapingBee Freelance (49 $) | $0.49 | 0,99 $ sur Startup |
| Exa contents | $1.00 | Aucune option de navigateur documentée |
| Tavily Extract (basique, avec paiement à l'usage) | $1.40 | 2,36 $ (avancé) |

*Prix vérifiés le 22 octobre 2026.*

Nous ne prétendons pas être les moins chers pour chaque volume ou chaque type de page. Sources : la page de tarifs de chaque fournisseur, listée sur la page de comparaison.

## Comment fonctionne le paiement

1. **Rechargez 25 $US ou plus** — Choisissez le montant et la coin (BTC, USDT, USDC, ETH, SOL, LTC). Le montant en crypto et son taux sont verrouillés pendant 30 minutes.
2. **Envoyez-le à l'adresse indiquée, sur le réseau exact** — La page de paiement affiche notre adresse de dépôt pour la coin et le réseau que vous avez choisis : BTC activé Bitcoin, USDT activé Tron (TRC-20) ou Ethereum (ERC-20), USDC activé Ethereum (ERC-20), ETH activé Ethereum, SOL activé Solana, LTC activé Litecoin. Envoyez uniquement cette coin sur ce réseau : les fonds envoyés sur un autre réseau ou dans une autre coin ne peuvent pas être récupérés. Les frais de réseau s'ajoutent au montant.
3. **Envoyez le montant exact indiqué, puis cliquez sur « J'ai envoyé le paiement »** — Chaque recharge a son propre montant exact (jusqu’aux dernières décimales) : c’est ainsi que nous retrouvons votre paiement et l’associons à votre compte.
4. **Crédité dès que votre paiement a été vérifié sur la blockchain** — Votre solde est crédité dès que nous avons vérifié la transaction sur la blockchain, une fois qu’elle a été confirmée par le réseau. Délais habituels de confirmation du réseau :
5. **Un seul solde pour tous vos crédits de pages** — Lorsque vous commencez par un pack, le rechargement équivaut à son prix (ou au minimum, si le pack est plus petit) ; les crédits sont ajoutés une fois le paiement crédité, et la clé API vous attend dans votre dashboard. Le reste demeure sur le solde pour les packs suivants. Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.

| Crypto | Réseau | Confirmations | Délai habituel |
| --- | --- | --- | --- |
| Bitcoin (BTC) | Bitcoin | 2 | ≈ 20 min |
| Tether (USDT) | Tron (TRC-20) | 20 | ≈ 1 min |
| Tether (USDT) | Ethereum (ERC-20) | 12 | ≈ 5 min |
| USD Coin (USDC) | Ethereum (ERC-20) | 12 | ≈ 5 min |
| Ethereum (ETH) | Ethereum | 12 | ≈ 5 min |
| Solana (SOL) | Solana | 1 | ≈ 1 min |
| Litecoin (LTC) | Litecoin | 6 | ≈ 15 min |

Vous avez fermé l'onglet ? La recharge en attente reste sous Facturation dans votre compte : ouvrez-la pour revoir l'adresse et le montant exact.

## Questions sur les tarifs

### Existe-t-il une offre gratuite ?

Non. Il n'y a pas d'offre gratuite : le plus petit pack est le moyen de tester, payé à partir de la recharge minimale, et le montant ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande sous 30 jours, en USDT ou USDC, tant qu'il n'est pas dépensé. Le pack 10 000 pages coûtent 3,75 $US et inclut toutes les options du plus grand pack.

### Pourquoi dois-je recharger 25 $US si un pack coûte moins ?

Chaque paiement passe par votre solde, et la recharge minimale est de 25 $US. Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.

### Puis-je obtenir un remboursement ?

Un pack de crédits acheté il y a moins de 72 heures est recrédité sur votre solde si moins de 20 % de ses crédits ont été utilisés. Si un pack ne fonctionne pas et que le support ne peut pas résoudre le problème sous 24 heures, la totalité est recréditée sur votre solde. Les recharges restent en solde et ne sont pas remboursées, sauf disposition légale contraire ; le montant ajouté uniquement pour atteindre la recharge minimale peut être renvoyé sur demande sous 30 jours, en USDT ou USDC, tandis que les crédits non utilisés. La [politique de remboursement](https://webreaderapi.com/fr/refunds/) contient des exemples concrets.

### Les pages JavaScript coûtent-elles toujours deux crédits ?

Seulement quand le navigateur s'exécute réellement. Avec `render=auto`, la plupart des pages d'actualité, de blog et de documentation sont lues depuis leur HTML pour un crédit ; le navigateur ne démarre que lorsque ce HTML contient trop peu de texte. Le champ `rendered` vous indique ce qui s'est produit.

### Avec quelles cryptomonnaies puis-je payer ?

BTC, USDT, USDC, ETH, SOL, LTC. USDT fonctionne sur TRC-20 ou ERC-20, et USDC sur ERC-20. La [page des paiements en crypto](https://webreaderapi.com/fr/crypto-payments/) explique chaque étape.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Politique de confidentialité

> Politique de confidentialité de WebReaderAPI : nous journalisons les noms d'hôte, jamais les URL complètes ni le contenu des pages, pendant 30 jours.

- URL: https://webreaderapi.com/fr/privacy/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un web reader voit deux types de données : les vôtres en tant que client, et les pages que vous lui demandez de lire. Cette politique couvre les deux, dans cet ordre.

**Réponse rapide — Que conserve WebReaderAPI à mon sujet et au sujet des pages que je lis ?**

**WebReaderAPI** conserve votre numéro de compte, une adresse e-mail facultative, vos enregistrements de paiement et de crédits, et des logs de requêtes qui contiennent le nom d'hôte de chaque page, jamais l'URL complète ni son contenu, pendant 30 jours. Nous ne conservons aucune copie des pages que vous lisez. Nous ne demandons ni pièce d'identité ni carte, et nous ne vendons ni ne partageons vos données.

## Quelles données collectons-nous à votre sujet ?

Uniquement ce que l'exploitation du service exige :

- **Compte :** votre numéro de compte, et une adresse e-mail si vous choisissez d'en ajouter une.
- **Paiements :** les recharges, leurs identifiants de transaction, les cryptomonnaies et réseaux, et les packs que vous achetez.
- **Usage :** Chaque requête laisse une ligne de log avec l'heure, le compte, le nom d'hôte de la page (jamais l'URL complète ni son contenu), le statut et les crédits utilisés ; ces lignes sont supprimées après 30 jours. Les pages que vous lisez ne sont pas stockées. Le numéro de compte, les commandes, les recharges et les totaux de crédits sont conservés tant que le compte existe, puis seulement aussi longtemps que la loi comptable l'exige. Les données ne sont transmises aux autorités que lorsqu'une loi nous y oblige.
- **Clés API :** stockées pour que nous puissions vérifier vos requêtes, révocables à tout moment.

## Que ne collectons-nous jamais ?

Nous ne collectons jamais de pièces d'identité, de selfies, de documents d'entreprise ni de numéros de carte, car nous n'en avons pas besoin. Connexion par numéro de compte ; l'email est facultatif.

Nous ne stockons jamais l'adresse complète des pages que vous lisez, leur contenu, ni le Markdown que nous vous renvoyons. Une fois la réponse partie de nos serveurs, le texte de la page a disparu de notre côté.

## Pourquoi conserver le nom d'hôte de chaque page ?

Pour deux raisons : vous montrer votre historique d'usage, et répondre aux propriétaires de sites qui signalent un problème avec notre crawler. Un nom d'hôte comme `example.com` suffit pour les deux, donc nous réduisons chaque URL à celui-ci avant d'écrire le log. Les logs sont supprimés après 30 jours.

## Qui voit les requêtes que nous faisons pour vous ?

Le site web que vous nous demandez de lire voit une requête provenant de notre infrastructure, avec notre user agent `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)`. Il ne voit ni votre compte, ni votre clé, ni votre identité. Lorsque vous utilisez l'option `country`, la requête part d'une adresse située dans ce pays via notre infrastructure, avec le même user agent.

Notre infrastructure ne reçoit que ce qui est nécessaire pour récupérer la page : l'URL et les options que vous avez choisies.

## Utilisez-vous des cookies ?

Les pages publiques n'utilisent aucun cookie publicitaire ni de suivi. L'espace client utilise le stockage nécessaire pour vous garder connecté et mémoriser vos choix d'interface, comme votre langue. Les pages de paiement affichent des adresses et des montants mais ne posent aucun traceur tiers.

## Partagez-vous ou divulguez-vous des données ?

Nous ne vendons ni ne louons aucune donnée. Les enregistrements ne sont transmis aux autorités qu'en cas d'obligation légale, et nous vous en informons lorsque la loi le permet. Les enregistrements de compte et de paiement sont conservés tant que votre compte est ouvert, puis uniquement aussi longtemps que les règles comptables l'exigent.

## Comment consulter ou supprimer mes données ?

Votre historique d'usage et vos paiements se trouvent dans l'espace client. Pour supprimer votre compte, demandez-le depuis l'espace client ou écrivez à support@webreaderapi.com avec un identifiant de commande ; nous ne vous demanderons ni votre numéro de compte ni une clé. La suppression du compte efface ses crédits, comme l'expliquent les [conditions](https://webreaderapi.com/fr/terms/).

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Politique de remboursement

> Politique de remboursement WebReaderAPI : packs de crédits remboursés sous 72 heures si moins de 20 % utilisés, crédit intégral si un pack ne fonctionne pas.

- URL: https://webreaderapi.com/fr/refunds/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Les remboursements vont sur votre solde, où ils restent et n'expirent jamais. Cette page donne la règle, trois exemples avec de vraies tailles de pack, et comment faire la demande.

**Réponse rapide — Puis-je obtenir un remboursement des crédits WebReaderAPI ?**

Oui, dans deux cas. Dans les 72 heures suivant l'achat, un pack de **WebReaderAPI** crédits retourne sur votre solde si vous en avez utilisé moins de 20 %. Un pack qui ne fonctionne pas, et que le support ne peut pas corriger sous 24 heures, est recrédité intégralement. Les recharges restent sur votre solde ; seule la part ajoutée pour atteindre le minimum de 25 $US peut être remboursée.

## Quelle est la règle exacte ?

Un pack de crédits acheté il y a moins de 72 heures est recrédité sur votre solde si moins de 20 % de ses crédits ont été utilisés. Si un pack ne fonctionne pas et que le support ne peut pas résoudre le problème sous 24 heures, la totalité est recréditée sur votre solde. Les recharges restent en solde et ne sont pas remboursées, sauf disposition légale contraire ; le montant ajouté uniquement pour atteindre la recharge minimale peut être renvoyé sur demande sous 30 jours, en USDT ou USDC, tandis que les crédits non utilisés.

Les demandes de remboursement sont traitées par une personne, et le montant apparaît sur votre solde une fois approuvé. Les requêtes en échec n'ont jamais besoin d'un remboursement, car elles n'utilisent aucun crédit. Cela inclut les pages refusées par robots.txt, par la préférence IA d'un site, ou par le site lui-même.

## Exemple 1 : un pack acheté par erreur

Vous achetez 100 000 pages pour 21,75 $US, lisez 3 000 pages pour tester, et décidez qu'un pack plus petit vous convient. Vous demandez le lendemain. Vous avez utilisé 3 % du pack, sous la limite de 20 % et dans les 72 heures, donc les 21,75 $US complets retournent sur votre solde. Vous pouvez ensuite acheter 10 000 pages pour 3,75 $US avec.

## Exemple 2 : un pack qui ne fonctionne pas

Vous achetez 50 000 pages pour 14,25 $US, et chaque requête renvoie une erreur de notre côté pour une raison que le support ne peut pas corriger sous 24 heures. Le pack est recrédité intégralement, quelle que soit la part que vous aviez tenté d'utiliser.

## Exemple 3 : la recharge minimum

Vous n'avez besoin que de 10 000 pages à 3,75 $US, mais la recharge minimum est de 25 $US. La différence reste sur votre solde pour de futurs packs. Si vous ne la dépensez pas, vous pouvez demander le remboursement de cette différence dans les 30 jours suivant le paiement, en USDT ou USDC. Rien d'autre dans une recharge n'est remboursé, sauf lorsque la loi l'exige.

## Comment demander un remboursement ?

Utilisez le formulaire de support dans l'espace client, ou écrivez à support@webreaderapi.com avec l'ID de commande affiché dans votre historique de commandes (jamais votre numéro de compte ni une clé API). Le support répond en moins de 12 heures ; une fois un remboursement approuvé, le montant apparaît sur votre solde.

## Pourquoi les remboursements vont-ils sur le solde ?

Parce que les paiements en crypto ne peuvent pas être annulés comme les paiements par carte, et renvoyer des coins coûte des frais de réseau à chaque fois. Un crédit sur le solde est immédiat et ne vous coûte rien. La seule exception, remboursée en stablecoins, est la part d'une recharge ajoutée uniquement pour atteindre le minimum, dans les 30 jours et si non dépensée. Les paiements ne sont pas remboursés autrement, sauf lorsque la loi l'exige.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Statut de WebReaderAPI : comment vérifier que l'API fonctionne

> API lecture pages web WebReaderAPI : vérifier l'endpoint crédits gratuit, comprendre chaque code d'erreur et savoir où les incidents sont annoncés.

- URL: https://webreaderapi.com/fr/status/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Quand une page ne revient pas, la cause est généralement le site web, parfois le réseau, et rarement nous. Cette page montre comment distinguer les cas, en quelques secondes et sans dépenser de crédit.

**Réponse rapide — Comment savoir si WebReaderAPI fonctionne ?**

Appelez `GET https://webreaderapi.com/api/v1/credits` avec votre clé : c'est gratuit, et une réponse normale signifie que l'API et votre clé fonctionnent. Si une page échoue, le code d'erreur vous indique pourquoi, et **WebReaderAPI** ne facture rien pour cela. Les incidents de notre côté sont consignés sur le [changelog](https://webreaderapi.com/fr/changelog/) avec leur date.

## Quel est le health check le plus rapide ?

L'endpoint de crédits. Il répond sans récupérer aucun site web, donc il ne teste que notre côté : l'authentification, l'API et votre compte.

*curl : vérifier l'API et vos crédits restants*

```bash
curl -s https://webreaderapi.com/api/v1/credits -H "Authorization: Bearer $WEBREADER_API_KEY"

```

## Quelles erreurs viennent du site web, et lesquelles viennent de nous ?

Le code d'erreur indique où se situe le problème. Aucune de ces erreurs n'utilise de crédit.

| Code | Où se situe le problème | Que faire |
|---|---|---|
| `blocked_by_robots` | Le robots.txt du site refuse notre crawler | Rien : le site a dit non |
| `blocked_by_site_policy` | Le site déclare `ai-input=no` | Rien : le site a dit non |
| `target_refused` | Le site a répondu 403, 429, un challenge ou un login | Réessayez plus tard, ou demandez l'accès au site |
| `fetch_failed` | DNS, TLS, connexion, ou une page 404/410 | Vérifiez l'URL ; réessayez plus tard |
| `fetch_timeout` | Le site n'a pas répondu à temps | Réessayez avec un `timeout` plus long |
| `concurrency_limit` | Trop de requêtes simultanées depuis votre compte | Ralentissez ou demandez une limite plus élevée |
| `invalid_api_key`, `insufficient_credits` | Votre clé ou votre solde | Vérifiez le dashboard |

La [page des erreurs](https://webreaderapi.com/fr/docs/errors/) détaille chaque cas, avec une boucle de retry.

## Pourquoi n'y a-t-il pas de chiffre de disponibilité en direct ici ?

Parce que nous n'en avons pas encore mesuré sur un échantillon public, et un chiffre inventé vous induirait en erreur. Le succès d'une lecture dépend surtout du site lu, donc un simple pourcentage dirait peu de choses. Une fois que nous publierons des chiffres, ils viendront avec la méthode, l'échantillon et la date.

## Où les incidents sont-ils annoncés ?

Sur le [changelog](https://webreaderapi.com/fr/changelog/), avec la date, les endpoints concernés et ce qui a été fait. Si vous voyez des erreurs répétées de notre côté (des codes autres que ceux causés par le site cible), écrivez à support@webreaderapi.com avec l'heure de la requête et le code d'erreur.

## Statut : questions fréquentes

### Vérifier mes crédits coûte-t-il quelque chose ?

Non. `GET https://webreaderapi.com/api/v1/credits` n'utilise jamais de crédit, donc vous pouvez l'appeler depuis un health check aussi souvent que vous voulez, dans la limite de votre concurrence.

### Une page échoue chez moi mais s'ouvre dans mon navigateur. Pourquoi ?

Généralement parce que le site traite les robots différemment des humains : il peut refuser notre crawler dans robots.txt ou répondre aux requêtes automatisées par une page de challenge. Nous renvoyons sa réponse et ne facturons rien. Le code d'erreur et `target_status` montrent ce que le site a envoyé.

### Les lectures en échec sont-elles facturées ?

Non. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Conditions d'utilisation

> Conditions d'utilisation WebReaderAPI : compte, crédits de pages sans expiration, recharges en crypto, règles robots.txt, remboursements et responsabilité.

- URL: https://webreaderapi.com/fr/terms/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Ces conditions couvrent le site web, l'espace client et l'API. Chaque section répond à une question, et rien d'important n'est caché dans une note de bas de page.

**Réponse rapide — Que disent les conditions de WebReaderAPI en bref ?**

Vous payez en crypto des crédits de pages prépayés pour l'API de lecture de pages web **WebReaderAPI**, après une recharge d'au moins 25 $US. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez. Chaque requête respecte le robots.txt du site cible, et la [Politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/) fait partie de ces conditions. Le service est vendu par SerpGoat LLC.

## 1. Qui est lié par ces conditions ?

Vous et SerpGoat LLC, qui exploite WebReaderAPI. « Vous » désigne le titulaire d'un compte, une personne ou une organisation. Créer un compte, payer une recharge ou appeler l'API signifie que vous acceptez ces conditions et la [Politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/).

## 2. Que fait le service ?

WebReaderAPI récupère les pages web publiques et les fichiers PDF que vous indiquez et renvoie leur contenu en Markdown, en texte brut ou en HTML nettoyé, via `https://webreaderapi.com/api/v1/read`, `https://webreaderapi.com/api/v1/batch` et `https://webreaderapi.com/api/v1/crawl`.

Les sites web décident de ce que contiennent leurs pages et si les robots peuvent les lire. Nous ne contrôlons pas, ne corrigeons pas et ne garantissons pas le contenu que nous renvoyons. Une même URL peut donner un résultat différent d'une requête à l'autre.

## 3. Comment fonctionnent les comptes et les clés API ?

Connexion par numéro de compte ; l'email est facultatif. Vous vous connectez avec votre numéro de compte, alors gardez-le en lieu sûr. Un email facultatif vous donne un moyen de le récupérer ; sans email enregistré, un numéro perdu ne peut pas être restauré.

Vous pouvez créer plusieurs clés et révoquer n'importe laquelle depuis le dashboard. Chaque requête envoyée avec l'une de vos clés utilise vos crédits, peu importe qui l'envoie, alors gardez vos clés privées et révoquez toute clé qui fuit. Un compte par personne ou organisation.

## 4. Comment les crédits sont-ils comptés et quand expirent-ils ?

1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée. Choisir le pays depuis lequel une page est lue coûte 10 crédits de plus, car la page est alors lue via une connexion résidentielle dans ce pays. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

Les crédits prépayés n'expirent jamais : les pages non utilisées restent sur votre compte jusqu'à ce que vous les utilisiez. Les crédits ne sont perdus que si vous supprimez votre compte ou si nous le fermons pour une violation de ces conditions. Si nous arrêtons de vendre le service, nous vous prévenons au moins 30 jours à l'avance pour que vous puissiez utiliser vos crédits restants ou transférer leur valeur vers un autre produit.

## 5. Comment fonctionnent les paiements ?

Les prix sont en dollars US sur la [page de tarifs](https://webreaderapi.com/fr/pricing/). Vous rechargez un solde en BTC, USDT, USDC, ETH, SOL, LTC, avec un minimum de 25 $US, et achetez des packs de crédits depuis ce solde. Envoyez le montant exact indiqué sur le réseau indiqué, puis cliquez sur « J'ai envoyé le paiement » ; le paiement est associé par son montant exact et crédité une fois confirmé sur la blockchain.

Votre solde conserve sa valeur sans date d'expiration. Quand un pack coûte moins que la recharge minimale, la partie excédentaire peut être demandée en retour sous 30 jours, en USDT ou USDC, tant qu'elle n'est pas dépensée ; les autres recharges ne sont pas remboursées sauf si la loi l'exige. Les frais de réseau sont payés par l'expéditeur.

## 6. Puis-je obtenir un remboursement ?

Oui, sur votre solde, dans deux cas : un pack utilisé à moins de 20 % dans les 72 heures suivant l'achat, et un pack qui ne fonctionne pas et que le support ne peut pas réparer en un jour. La [politique de remboursement](https://webreaderapi.com/fr/refunds/) énonce la règle complète, avec des exemples détaillés.

## 7. Quelles règles s'appliquent aux pages que je lis ?

Notre crawler applique trois règles à chaque requête, et elles ne peuvent pas être désactivées. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées. Si un site déclare Content-Signal: ai-input=no dans son robots.txt, nous ne lisons pas ses pages pour vous. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall.

Vous êtes responsable de l'usage que vous faites du contenu que vous recevez, y compris des droits de ses propriétaires. La [Politique d'utilisation acceptable](https://webreaderapi.com/fr/acceptable-use/) liste les usages interdits.

## 8. Y a-t-il des limites de volume ou de vitesse ?

Chaque compte a une limite du nombre de pages lues en simultané ; votre dashboard l'affiche, et le support peut l'augmenter. Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay. Jusqu'à 100 URLs par job batch. Nous pouvons ralentir ou suspendre les requêtes vers un même site web pour le protéger, par exemple en respectant son `Crawl-delay`.

## 9. Quand pouvez-vous suspendre mon compte ?

Quand nous constatons une violation de ces conditions ou de la politique d'utilisation acceptable, quand un paiement est annulé ou frauduleux, ou quand la loi l'exige. Nous vous en donnons la raison lorsque la loi le permet, et une personne examine les faits avant toute suspension.

## 10. Que garantissez-vous ?

Nous fournissons le service tel quel. Nous ne garantissons pas qu'une page donnée puisse être lue, qu'un site acceptera nos requêtes, ni que le service fonctionnera sans interruption. Les requêtes échouées et les pages refusées par un site ne sont pas facturées, ce qui limite votre coût quand une page ne peut pas être lue.

## 11. Quelle est votre responsabilité ?

Là où la loi le permet, notre responsabilité totale pour toute réclamation est limitée aux montants que vous nous avez payés dans les 12 mois précédant l'événement qui l'a causée. Nous ne sommes pas responsables des pertes indirectes, comme les profits manqués ou les données perdues. Rien dans ces conditions ne limite une responsabilité que la loi ne nous permet pas de limiter.

## 12. Comment ces conditions changent-elles ?

Nous datons chaque version et consignons les changements dans le [changelog](https://webreaderapi.com/fr/changelog/). Un changement qui réduit vos droits s'applique aux crédits achetés après la publication du changement. Les questions vont à support@webreaderapi.com.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# API page web vers Markdown : le contenu principal de toute URL, prêt pour un modèle

> API page web vers Markdown pour LLM et agents IA : toute URL en Markdown propre avec titre, auteur et date, depuis 0,07 $US/1K pages. Sans KYC, en crypto.

- URL: https://webreaderapi.com/fr/url-to-markdown-api/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Passez une URL et récupérez l'article en Markdown : titres, paragraphes, listes, tableaux et liens conservés ; menus, bannières de cookies, publicités et pieds de page supprimés. Avec le titre, l'auteur, la date et la langue de la page.

**Réponse rapide — Quelle API convertit une page web en Markdown propre pour un LLM ?**

Une API page web vers Markdown récupère une page, conserve son contenu principal et le renvoie en Markdown. **WebReaderAPI** le fait en une seule requête : `GET https://webreaderapi.com/api/v1/read?url=…` renvoie l'article avec ses titres, listes, tableaux et liens, plus le titre, l'auteur, la date et le nombre de mots, pour un crédit par page à partir de 0,07 $US/1K pages en octobre 2026. robots.txt est respecté. Sans KYC ; payez en crypto.

## API URL vers Markdown en un coup d'œil

| Attribut | Valeur |
| --- | --- |
| Endpoint | `GET https://webreaderapi.com/api/v1/read?url=…` (ou `POST` avec un corps JSON) |
| Sortie | Markdown propre du contenu principal de la page (ou texte brut, ou HTML nettoyé), avec titre, description, auteur, date de publication, langue et nombre de mots ; liens et images sur demande |
| JavaScript | Rendu JavaScript dans un navigateur headless quand la page en a besoin (render=auto), ou toujours, ou jamais |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Budget de tokens | `max_chars` réduit le Markdown à la longueur que votre modèle peut prendre |
| robots.txt | Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées |
| Prix | 3,75 $US pour 10 000 pages, 21,75 $US pour 100 000 pages, à partir de 0,07 $US/1K pages à 5 000 000 pages |
| Paiement | BTC, USDT, USDC, ETH, SOL, LTC, à partir d'une recharge de 25 $US ; sans KYC |

## Pourquoi convertir les pages web en Markdown avant de les donner à un modèle ?

Le Markdown conserve la structure dont un modèle a besoin et supprime le balisage dont il n'a pas besoin. Une page d'article typique embarque navigation, scripts, balises de tracking, bandeaux cookies et widgets d'articles liés autour de quelques centaines de mots de texte. Envoyée en HTML brut, la plupart des tokens que vous payez sont du balisage.

Le Markdown conserve les titres en `#`, les listes en `-`, les tableaux en barres verticales et les liens en `[text](url)`. Un modèle peut toujours voir quelle phrase appartient à quelle section, citer le lien source et découper le texte en chunks selon ses titres. Le même texte en prose simple perd cette structure ; le même texte en HTML coûte bien plus de tokens.

## Que conserve l'API, et que supprime-t-elle ?

Avec `main_content=true`, la valeur par défaut, l'API conserve la partie de la page pour laquelle le lecteur est venu et supprime le reste.

| Conservé | Supprimé |
|---|---|
| Titre et headings | Navigation du site et menus |
| Paragraphes, citations et listes | Bandeaux cookies et de consentement |
| Tableaux, en tableaux Markdown | Publicités et widgets sponsorisés |
| Blocs de code, avec leur langage quand affiché | Barres latérales et listes d'articles liés |
| Liens à l'intérieur du texte | Footers et mentions légales |
| Images, uniquement avec `include_images=true` | Boutons de partage et formulaires de commentaire |

Définissez `main_content=false` pour convertir plutôt toute la page, par exemple une page d'accueil ou une liste de produits où tout compte. Définissez `format=text` pour du texte brut sans Markdown, ou `format=html` pour du HTML nettoyé du contenu principal.

*curl : une page en Markdown, coupée à 20 000 caractères*

```bash
curl -G "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/blog/pour-over-coffee" \
  -d format=markdown -d max_chars=20000
```

*Python : lire une page et afficher ses métadonnées et son Markdown*

```python
import os

import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/blog/pour-over-coffee", "format": "markdown"},
    timeout=90,
)
resp.raise_for_status()
page = resp.json()
print(page["title"], "|", page.get("author"), "|", page.get("published_at"))
print(page["word_count"], "words,", page["credits_used"], "credit(s)")
print(page["markdown"][:500])

```

## Et les pages construites avec JavaScript ?

De nombreuses pages n'envoient presque pas de texte dans leur premier HTML et construisent le contenu dans le navigateur. Avec `render=auto`, la valeur par défaut, l'API lit d'abord le HTML brut ; s'il contient trop peu de texte, elle ouvre la page dans un navigateur headless et lit le résultat. La réponse indique ce qui s'est produit dans `rendered`.

Une page qui a nécessité le navigateur coûte deux crédits au lieu d'un. Si vous savez qu'un site en a toujours besoin, définissez `render=true` ; si vous ne voulez que ce que le serveur envoie, définissez `render=false` et ne payez jamais le second crédit.

## Que se passe-t-il quand un site ne veut pas être lu ?

Nous respectons son choix et vous n'êtes pas facturé. Notre crawler s'identifie comme `WebReaderAPI` et vérifie robots.txt avant chaque lecture. Une page interdite pour notre token, ou pour tous les robots, renvoie `403 blocked_by_robots`. Un site qui déclare `Content-Signal: ai-input=no` renvoie `403 blocked_by_site_policy`.

Si le site refuse la requête d'une autre manière, comme un statut 403, une page de challenge ou un mur de connexion, vous recevez `502 target_refused` avec le statut propre au site. Si un site refuse notre requête, nous renvoyons sa réponse : nous ne résolvons jamais de CAPTCHA, ne nous connectons pas à des comptes et ne cherchons pas à contourner un blocage ou un paywall. Notre [page crawler](https://webreaderapi.com/fr/bot/) explique tout cela aux propriétaires de sites, avec le User-Agent exact.

## De combien de pages mon projet aura-t-il besoin ?

Comptez un crédit par page, deux pour les pages qui nécessitent le navigateur. Quelques volumes typiques :

- **Un agent IA** qui lit 5 pages par tâche et exécute 100 tâches par jour lit environ 15 000 pages par mois : 50 000 pages (14,25 $US) durent plus de trois mois.
- **Un index RAG** de trois sites de documentation de 2 000 pages chacun, c'est 6 000 pages, puis une actualisation hebdomadaire des pages modifiées.
- **Un corpus de recherche** de 400 000 articles de presse et de blog tient dans 500 000 pages (50 $US).

Les crédits n'expirent jamais, donc un pack acheté pour un crawl ponctuel conserve sa valeur restante pour des tâches ultérieures.

## Combien coûte l'API URL vers Markdown ?

10 000 pages coûtent 3,75 $US, 100 000 pages coûtent 21,75 $US et 1 000 000 pages coûtent 74,25 $US, à la date d'octobre 2026. Les pages en échec et les pages refusées par robots.txt sont gratuites. Voir [tous les packs](https://webreaderapi.com/fr/pricing/).

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Volume | 1 000 000 pages | 74,25 $US | 0,07 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## API URL vers Markdown : questions fréquentes

### Le Markdown conserve-t-il les tableaux et les blocs de code ?

Oui. Les tableaux HTML deviennent des tableaux Markdown, et les blocs de code restent délimités, avec leur langage quand la page l'indique. Les tableaux très complexes, comme ceux à cellules fusionnées, sont aplatis ligne par ligne.

### Puis-je obtenir toute la page plutôt que l'article ?

Oui. Définissez `main_content=false` et l'API convertit tout ce qui se trouve sur la page, y compris la navigation et le footer. Cela convient aux pages d'accueil, aux pages de catégorie et aux listes de produits, où le détecteur de contenu principal supprimerait des parties utiles.

### Comment garder les pages dans la fenêtre de contexte de mon modèle ?

Utilisez `max_chars`, entre 1 000 et 500 000 caractères, pour couper le Markdown à une longueur définie. Le champ `word_count` vous indique la longueur de l'article complet, pour que votre agent puisse décider s'il doit lire davantage.

### Peut-il lire des pages derrière une connexion ou un paywall ?

Non. WebReaderAPI lit uniquement les pages publiques. Il ne se connecte jamais à des comptes et ne tente jamais de contourner un paywall ou un blocage ; ces pages renvoient le refus du site et ne sont pas facturées.

### Ai-je besoin d'une pièce d'identité ou d'une carte pour obtenir une clé ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni documents d'entreprise, ni carte. Connexion par numéro de compte ; l'email est facultatif. Vous rechargez depuis 25 $US en BTC, USDT, USDC, ETH, SOL, LTC.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Que pouvez-vous construire avec une API de lecture web ?

> API de lecture web : fetch pour agents IA, ingestion RAG, surveillance des pages et export vers Markdown, à partir de 0,07 $US/1K pages.

- URL: https://webreaderapi.com/fr/use-cases/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Quatre usages représentent l'essentiel de ce que les gens font avec le texte propre d'une page : donner à un agent un moyen de lire, alimenter une base de connaissances, surveiller les changements de pages et convertir le contenu d'un site en Markdown. Chacun a sa propre page avec du code et les coûts.

**Réponse rapide — À quoi sert une API de lecture web ?**

Les équipes utilisent une API de lecture web pour donner aux agents IA un outil de fetch, pour ingérer des sites dans des index RAG, pour surveiller les changements de pages publiques et pour convertir leurs propres sites web en Markdown. **WebReaderAPI** couvre les quatre avec une seule clé : `/read` pour une page, `/batch` pour une liste, `/crawl` pour un site, à un crédit par page à partir de 0,07 $US/1K pages en octobre 2026. Sans KYC ; payez en crypto.

## Quel est votre cas d'usage ?

- **[Agents IA](https://webreaderapi.com/fr/use-cases/ai-agents/)** — Un outil read_url pour Claude, Cursor, OpenClaw, n8n ou votre propre agent, avec une limite de longueur par page.
- **[Ingestion RAG](https://webreaderapi.com/fr/use-cases/rag/)** — Crawlez de la documentation et des blogs vers des chunks Markdown qui conservent leurs titres et l'URL source.
- **[Surveillance des modifications](https://webreaderapi.com/fr/use-cases/monitoring/)** — Lisez les pages de tarifs, les politiques et les changelogs selon un planning et récupérez les différences sous forme de texte.
- **[Site web en Markdown](https://webreaderapi.com/fr/use-cases/website-to-markdown/)** — Exportez votre propre site en fichiers Markdown pour une migration, une sauvegarde ou votre propre assistant.
- **[PDF](https://webreaderapi.com/fr/pdf-to-markdown-api/)** — Des rapports, articles et manuels depuis un lien, convertis en texte Markdown.
- **[llms.txt](https://webreaderapi.com/fr/guides/llms-txt-generator/)** — Construisez un fichier llms.txt pour votre propre site à partir d'un crawl, avec une ligne par page.

## Quel endpoint et combien de pages chaque cas d'usage nécessite-t-il ?

Volumes typiques pour une petite équipe, pour dimensionner un premier pack. Un crédit par page, deux lorsque la page nécessite un navigateur.

| Cas d'usage | Endpoint | Pages typiques par mois |
| --- | --- | --- |
| Agent qui lit 5 pages par tâche, 100 tâches par jour | `/read` | Environ 15 000 |
| Index RAG de 3 sites de documentation, actualisé chaque semaine | `/crawl`, puis `/batch` | 6 000 pour le construire, quelques centaines par semaine ensuite |
| Surveillance quotidienne de 200 pages concurrentes et de politiques | `/batch` | Environ 6 000 |
| Export d'un site de 2 000 pages, une fois | `/crawl` | 2 000, en une fois |

## Quel problème ces quatre cas d'usage ont-ils en commun ?

Dans les quatre cas, il faut la partie lisible d'une page, pas sa mise en page. Un agent gaspille des tokens sur les menus ; un index classe le boilerplate ; un outil de veille déclenche de fausses alertes quand une pub change ; une migration recopie les bannières cookies dans le nouveau site. L'extraction du contenu principal résout le même problème à chaque fois.

Ils partagent aussi les mêmes limites. Les pages derrière un login ou un paywall sont hors de portée, et les sites qui refusent robots.txt sont ignorés et non facturés. Nous respectons robots.txt : notre crawler s'identifie comme WebReaderAPI, suit les règles écrites pour lui ou pour tous les robots, et ne lit pas une page qu'un site interdit. Les pages refusées ne sont pas facturées.

## Comment choisir entre /read, /batch et /crawl ?

Utilisez l'outil le plus simple qui fait le travail.

- **`/read`** renvoie une page de façon synchrone. Il convient aux agents, qui décident page par page quoi lire ensuite.
- **`/batch`** lit jusqu'à 100 URLs que vous connaissez déjà, en tâche de fond. Il convient aux listes de veille et aux rafraîchissements.
- **`/crawl`** découvre et lit un site entier à partir d'une URL de départ, jusqu'à 10 000 pages, en suivant son sitemap et son robots.txt. Il convient aux premiers builds et aux exports.

Les trois acceptent les mêmes options, comme `format`, `main_content`, `render` et `max_chars`, et sont facturés de la même façon.

## Combien coûtera un premier projet ?

La plupart des premiers projets tiennent dans un petit pack. Un agent prototype, un index de documentation unique ou une liste de surveillance de quelques centaines de pages utilise quelques milliers à quinze mille crédits par mois. 10 000 pages coûtent 3,75 $US et 50 000 pages coûtent 14,25 $US, en octobre 2026.

Les crédits n'expirent jamais, donc acheter le plus grand pack pour un projet susceptible de grandir ne coûte rien de plus pendant un mois calme. Les pages en échec et les pages refusées par robots.txt sont gratuites.

## Packs pour un premier projet

Commencez petit ; les crédits se reportent sans date limite. 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Cas d'usage : questions fréquentes

### Puis-je utiliser une seule clé pour plusieurs projets ?

Oui, ou créez une clé par projet pour voir l'usage séparément et révoquer l'une sans toucher aux autres. Créez plusieurs clés API, par exemple une par agent ou par projet, et révoquez n'importe laquelle depuis votre dashboard.

### Quel cas d'usage nécessite le rendu JavaScript ?

Tous ceux qui lisent des applications web modernes, des sites de documentation en single-page ou des pages qui chargent du contenu après la première réponse. Avec `render=auto`, l'API ne fait le rendu que lorsque le HTML brut contient trop peu de texte.

### Y a-t-il un cas d'usage pour lequel WebReaderAPI n'est pas fait ?

Oui : la collecte de données personnelles sur des personnes privées, la lecture de contenu derrière un login ou un paywall, et tout ce qui exige de contourner le refus d'un site. Notre [Acceptable Use Policy](https://webreaderapi.com/fr/acceptable-use/) liste les règles.

### Ai-je besoin d'une pièce d'identité pour commencer ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni document. Une recharge commence à 25 $US, en BTC, USDT, USDC, ETH, SOL, LTC.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Outil de récupération web pour agents IA : lire les pages en Markdown propre

> Outil de récupération web pour agents IA : lisez toute page publique en Markdown via MCP, OpenAI tools, LangChain ou n8n, à partir de 0,07 $US/1K pages.

- URL: https://webreaderapi.com/fr/use-cases/ai-agents/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Un agent qui sait chercher mais pas lire répond à partir de snippets. Donnez-lui un outil qui transforme n'importe quelle URL publique en Markdown court et propre, et il peut lire la source, la citer et la référencer, dans la limite d'un budget que vous fixez.

**Réponse rapide — Quelle est la meilleure façon de donner un outil de récupération web à un agent IA ?**

Enveloppez une API de lecture de pages web dans un outil qui prend une URL et renvoie le contenu principal de la page en Markdown, coupé à une longueur définie. **WebReaderAPI** fait la lecture, rend le JavaScript quand nécessaire, respecte robots.txt et facture un crédit par page à partir de 0,07 $US/1K pages à la date d'octobre 2026. Du code d'outil prêt à l'emploi couvre MCP, OpenAI function calling, LangChain, n8n et OpenClaw. Sans KYC ; crypto.

## WebReaderAPI comme outil d'agent

| Attribut | Valeur |
| --- | --- |
| Outil | `read_url(url, max_chars)` appelant `https://webreaderapi.com/api/v1/read` |
| Renvoie | Le Markdown du contenu principal, plus le titre, l'auteur, la date et le nombre de mots |
| Limite de longueur | `max_chars`, de 1 000 à 500 000 caractères par page |
| Pages JavaScript | Rendu JavaScript dans un navigateur headless quand la page en a besoin (render=auto), ou toujours, ou jamais |
| Refus | Renvoyés sous forme d'erreurs claires, jamais facturés |
| Intégrations | [MCP](https://webreaderapi.com/fr/docs/mcp/), [OpenAI](https://webreaderapi.com/fr/docs/openai/), [LangChain et LlamaIndex](https://webreaderapi.com/fr/docs/langchain/), [n8n](https://webreaderapi.com/fr/docs/n8n/), [OpenClaw](https://webreaderapi.com/fr/docs/openclaw/) |
| Prix | 3,75 $US pour 10 000 pages ; les crédits n'expirent jamais |

## Pourquoi un agent a-t-il besoin d'un reader plutôt que du HTML brut ?

Parce que le HTML brut consomme la fenêtre de contexte avec des éléments dont le modèle n'a pas besoin. Un article de presse ou une page de documentation arrive entouré de navigation, de scripts, de bannières de consentement et de liens connexes. Transmis tel quel, il sature la conversation et pousse le modèle à citer des menus.

Un reader résout trois problèmes d'un coup. Il ne conserve que le contenu principal, il rend les pages qui restent vides tant que JavaScript ne s'exécute pas, et il convertit les PDF en texte. L'agent reçoit un bloc compact de Markdown avec un titre et une date qu'il peut citer.

## Pourquoi les outils de fetch intégrés échouent-ils parfois ?

Surtout parce que les sites refusent le trafic automatisé. Depuis le 1er juillet 2025, Cloudflare bloque par défaut les crawlers IA pour les nouveaux domaines, et à partir du 15 septembre 2026, ses presets bloquent le trafic « Agent » sur les pages financées par la publicité des nouveaux domaines. Les outils intégrés des agents de code et des assistants rencontrent ces refus comme n'importe quel autre client.

D'autres échecs sont techniques. La documentation d'OpenClaw, consultée le 22 octobre 2026, indique que son outil web_fetch intégré extrait le contenu avec Readability, n'exécute pas JavaScript et limite la sortie à 20 000 caractères. Les pages construites dans le navigateur, les documents longs, les serveurs lents et les rate limits font échouer ces outils. Un reader qui rend les pages règle le cas JavaScript ; le cache et la patience règlent le reste. Les refus relèvent du propriétaire du site. Notre [guide des erreurs 403 de web fetch](https://webreaderapi.com/fr/guides/web-fetch-403-errors/) explique chaque cas.

## Pourquoi l'outil s'appelle-t-il read_url et non web_fetch ?

Pour éviter un conflit avec les outils que les agents ont déjà. Claude Code et OpenClaw embarquent tous deux un outil intégré nommé `web_fetch`. Un second outil portant le même nom désoriente le modèle sur celui qu'il appelle. Nommer le nôtre `read_url` laisse les deux disponibles : l'agent peut utiliser son fetcher intégré pour des vérifications rapides et `read_url` lorsqu'il a besoin de Markdown propre, de PDF ou de pages JavaScript.

Les définitions d'outils de nos pages de documentation utilisent toutes ce nom, vous pouvez donc passer d'un framework à l'autre sans modifier vos prompts.

*Python : un outil read_url compact avec une limite de longueur*

```python
import os

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}


def read_url(url: str, max_chars: int = 12000) -> str:
    """Return a web page as Markdown for a model, or a short reason it was not read."""
    resp = requests.get(API, headers=HEADERS, params={"url": url, "max_chars": max_chars}, timeout=90)
    data = resp.json()
    if resp.status_code != 200:
        err = data.get("error", {})
        return "Not read (" + err.get("code", "error") + "): " + err.get("message", "")
    head = "# " + (data.get("title") or url) + "\nSource: " + data["final_url"]
    if data.get("published_at"):
        head += " | Published: " + data["published_at"]
    return head + "\n\n" + data["markdown"]


if __name__ == "__main__":
    print(read_url("https://example.com/blog/pour-over-coffee", max_chars=2000)[:500])

```

## Comment un agent doit-il décider quoi lire ?

Donnez-lui un budget et une règle. Trois habitudes maîtrisent les coûts et le contexte :

- **Lire peu, lire bien.** Deux à quatre sources par question suffisent généralement pour répondre avec des citations.
- **Limiter chaque page.** Commencez avec `max_chars` autour de 10 000 à 15 000 caractères ; augmentez-le seulement quand le `word_count` montre que la réponse se trouve probablement plus bas.
- **Signaler les refus.** Quand une page n'est pas lue, laissez le modèle le dire et passer à une autre source au lieu de réessayer.

L'outil ci-dessus renvoie les refus sous forme d'une phrase simple, pour que le modèle puisse les expliquer à l'utilisateur.

## Combien coûte l'exploitation d'un agent sur WebReaderAPI ?

Un crédit par page, deux lorsque la page nécessite un navigateur. Un assistant qui répond à 100 questions par jour et lit 4 pages pour chacune lit environ 12 000 pages par mois. 50 000 pages (14,25 $US) couvrent cela pendant quatre mois, en octobre 2026.

Les crédits n'expirent jamais, un agent très sollicité une semaine et inactif la suivante ne gaspille donc pas de quota mensuel. Les pages qui échouent ou que robots.txt refuse ne coûtent rien.

## Quel pack convient à un agent ?

Prototypez sur 10 000 pages ; passez à 50 000 pages ou 100 000 pages quand l'agent sert de vrais utilisateurs. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Agents IA : questions fréquentes

### Puis-je ajouter WebReaderAPI à Claude Desktop ou Cursor ?

Oui, via un petit serveur MCP qui expose `read_url`. La [page MCP](https://webreaderapi.com/fr/docs/mcp/) contient le code et l'extrait de configuration ; votre clé API reste dans une variable d'environnement.

### Est-ce compatible avec OpenClaw ?

Oui, en tant que serveur MCP à côté du web_fetch intégré d'OpenClaw. La [page OpenClaw](https://webreaderapi.com/fr/docs/openclaw/) montre les commandes issues de la documentation d'OpenClaw elle-même.

### L'agent peut-il lire les pages qui bloquent les bots IA ?

Non. Si robots.txt interdit la page, l'API renvoie `blocked_by_robots` ; si le site refuse, elle renvoie `target_refused` avec le statut du site. Aucun des deux n'est facturé, et nous ne cherchons jamais à contourner le refus.

### Comment empêcher une page longue de remplir la fenêtre de contexte ?

Définissez `max_chars`. Le Markdown est coupé à cette longueur, et `word_count` indique à l'agent la longueur de la page complète, pour qu'il puisse en demander davantage seulement si nécessaire.

### Ai-je besoin d'une carte ou d'une pièce d'identité ?

Non. WebReaderAPI ne demande ni pièce d'identité, ni selfie, ni documents, ni carte. Le paiement se fait en BTC, USDT, USDC, ETH, SOL, LTC, avec un dépôt minimum de 25 $US.

## Sources

1. [Communiqué de presse : crawlers IA bloqués par défaut](https://www.cloudflare.com/press-releases/2025/cloudflare-just-changed-how-ai-crawlers-scrape-the-internet-at-large/) — Cloudflare (2025-07-01)
2. [Blog : nouveaux réglages par défaut pour les crawlers et agents IA](https://blog.cloudflare.com/accountable-mixed-use-ai-crawlers/) — Cloudflare (2026-09-15)
3. [Outil de récupération de page web](https://docs.openclaw.ai/tools/web-fetch.md) — OpenClaw (read 2026-10-22)

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Surveillance des modifications de sites web : diff des pages publiques en Markdown propre

> Surveillez les pages web publiques : lisez tarifs, politiques et changelogs en Markdown, comparez le texte et alertez. À partir de 0,07 $US/1K pages.

- URL: https://webreaderapi.com/fr/use-cases/monitoring/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Comparer le HTML brut déclenche une alerte à chaque changement de publicité ou de token. Comparer le contenu principal en Markdown ne signale que ce qu'un lecteur remarquerait : un nouveau prix, une clause reformulée, une nouvelle entrée de changelog.

**Réponse rapide — Comment surveiller les modifications de contenu des pages web ?**

Lisez chaque page selon un planning en Markdown de son contenu principal, stockez le texte et comparez-le à la version précédente ; alertez uniquement quand le texte change. **WebReaderAPI** lit jusqu'à 100 URLs par job batch, supprime publicités et menus pour qu'ils ne déclenchent pas de fausses alertes, et facture un crédit par page à partir de 0,07 $US/1K pages, en octobre 2026. Sans KYC ; payez en crypto.

## Monitoring avec WebReaderAPI

| Attribut | Valeur |
| --- | --- |
| Endpoint | `POST https://webreaderapi.com/api/v1/batch`, puis `GET https://webreaderapi.com/api/v1/jobs/{job_id}` |
| Taille du batch | Jusqu'à 100 URLs par job batch |
| Ce qui est comparé | Le Markdown du contenu principal, sans publicités, menus ni bannières |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Volume d'exemple | 200 pages vérifiées par jour = environ 6 000 pages par mois |
| Prix | 3,75 $US pour 10 000 pages ; les crédits n'expirent jamais |

## Qu'est-ce qui mérite d'être surveillé ?

Les pages dont la formulation compte pour votre activité et qui changent sans prévenir :

- **Pages de tarifs** des fournisseurs et des concurrents, pour repérer les nouvelles offres et les mouvements de prix.
- **Conditions, politiques de confidentialité et de remboursement** dont vous dépendez, pour repérer les clauses qui changent.
- **Changelogs et notes de version** des outils sur lesquels vous vous appuyez, pour réagir aux breaking changes.
- **Pages de documentation** vers lesquelles votre produit renvoie, pour corriger rapidement une consigne erronée.
- **Avis publics** des régulateurs ou des organismes de normalisation de votre secteur.

Limitez la liste aux pages publiques. Les profils personnels et les pages derrière un login sont hors périmètre.

## Pourquoi diffuser du Markdown plutôt que du HTML ?

Parce que le HTML change sans arrêt sans que le contenu change. Publicités en rotation, jetons de session, horodatages en pied de page et balisage d'A/B test font différer deux chargements de la même page. Un diff sur le HTML transforme ce bruit en alertes, et les gens arrêtent de les lire.

Le Markdown du contenu principal élimine l'essentiel du bruit avant la comparaison. Il reste le texte qu'une personne lit : titres, paragraphes, listes et tableaux. Un diff sur ce texte est court, lisible et mérite une alerte.

*Python : vérifier une liste de pages et afficher ce qui a changé*

```python
import difflib
import json
import os
import pathlib
import time

import requests

API = "https://webreaderapi.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
STORE = pathlib.Path("snapshots.json")
URLS = [
    "https://example.com/pricing",
    "https://example.com/legal/terms",
    "https://example.com/changelog",
]

old = json.loads(STORE.read_text(encoding="utf-8")) if STORE.exists() else {}
job = requests.post(API + "/batch", headers=HEADERS, json={"urls": URLS}, timeout=60).json()
results, cursor, delay = [], None, 5
while True:
    params = {"cursor": cursor} if cursor else {}
    page = requests.get(API + "/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=60).json()
    results += page.get("results", [])
    cursor = page.get("next_cursor")
    if page["status"] == "done" and not cursor:
        break
    if not cursor:
        time.sleep(delay)
        delay = min(delay * 2, 60)

new = dict(old)
for item in results:
    if "markdown" not in item:
        print("not read:", item["url"], item.get("error", {}).get("code"))
        continue
    before = old.get(item["url"], "")
    if before and before != item["markdown"]:
        diff = difflib.unified_diff(before.splitlines(), item["markdown"].splitlines(), lineterm="", n=0)
        print("CHANGED:", item["url"])
        print("\n".join(list(diff)[:40]))
    new[item["url"]] = item["markdown"]
STORE.write_text(json.dumps(new, ensure_ascii=False), encoding="utf-8")

```

## À quelle fréquence vérifier, et avec quelle politesse ?

Aussi souvent que la page change réellement, et pas plus. Le quotidien convient aux pages de tarifs et aux changelogs ; l'hebdomadaire convient aux politiques et à la documentation. Une page lue toutes les heures vous apprend rarement plus qu'une lecture par jour, et elle coûte 24 fois plus cher.

WebReaderAPI respecte robots.txt pour chaque page et honore le `Crawl-delay` d'un site dans les crawl jobs. Les pages que le site interdit sont ignorées et non facturées, donc un site strict disparaît simplement de votre rapport. Demandez au propriétaire si vous avez besoin d'accéder à une page qui refuse robots.

## Combien coûte la surveillance ?

Un crédit par page et par vérification. Quelques exemples aux prix d'octobre 2026 :

- **50 pages, tous les jours :** environ 1 500 pages par mois. 10 000 pages (3,75 $US) durent plus de six mois.
- **200 pages, tous les jours :** environ 6 000 pages par mois. 50 000 pages (14,25 $US) durent environ huit mois.
- **1 000 pages, toutes les semaines :** environ 4 300 pages par mois, proche du cas précédent.

Les pages qui nécessitent un navigateur consomment deux crédits ; réglez `render=false` pour les pages dont vous savez qu'elles sont en HTML simple, afin de rester à un crédit.

## Quel pack convient à la surveillance ?

Multipliez les pages par les vérifications par mois, puis choisissez un pack qui dure quelques mois. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Surveillance des changements : questions fréquentes

### WebReaderAPI envoie-t-il des alertes ?

Non. Il lit les pages et renvoie du Markdown ; votre script compare les versions et envoie l'alerte par email, chat ou ticket. Le code ci-dessus affiche les lignes modifiées comme point de départ.

### Comment éviter les fausses alertes dues aux dates et aux compteurs ?

Comparez le Markdown du contenu principal, pas le HTML, et supprimez avant le diff les lignes dont vous savez qu'elles changent à chaque chargement, comme « mis à jour il y a 5 minutes ». La plupart des éléments en rotation sont déjà retirés par l'extraction du contenu principal.

### Puis-je surveiller des pages qui nécessitent JavaScript ?

Oui. Avec `render=auto`, les pages vides sans JavaScript sont rendues dans un navigateur headless pour deux crédits. Les pages qui fonctionnent sans JavaScript restent à un crédit.

### Puis-je surveiller un site entier plutôt qu'une liste de pages ?

Oui : lancez un crawl job plutôt qu'un batch, puis comparez page par page. Pour les grands sites, comparez d'abord les dates `lastmod` du sitemap et ne relisez que les pages qui ont bougé.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Pages web pour le RAG : transformer des sites en Markdown propre et découpable

> Crawlez docs et blogs en Markdown propre pour vos pipelines RAG, découpage par titre, URLs sources. Dès 0,07 $US/1K pages, sans KYC, paiement crypto.

- URL: https://webreaderapi.com/fr/use-cases/rag/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

La recherche opère sur ce que vous mettez dans l'index. Un Markdown propre avec titres, métadonnées et URL source donne de meilleurs chunks, moins de tokens gaspillés et des réponses qui peuvent citer leur page.

**Réponse rapide — Comment ingérer des pages web dans un pipeline RAG ?**

Lisez chaque page en Markdown de son contenu principal, découpez-la selon ses titres, associez l'URL source et le titre à chaque chunk, puis embeddez et stockez. **WebReaderAPI** s'occupe de la lecture : une requête par page, ou un crawl job pour un site entier jusqu'à 10 000 pages, à un crédit par page dès 0,07 $US/1K pages en octobre 2026. robots.txt est respecté. Sans KYC ; payez en crypto.

## Ingestion RAG avec WebReaderAPI

| Attribut | Valeur |
| --- | --- |
| Site entier | `POST https://webreaderapi.com/api/v1/crawl` : Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay |
| Liste d'URLs | `POST https://webreaderapi.com/api/v1/batch` : Jusqu'à 100 URLs par job batch |
| Par page | Markdown du contenu principal, titre, auteur, date, langue, nombre de mots |
| PDF | Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé |
| Facturation | 1 crédit = 1 page lue sans navigateur ; 2 crédits quand la page nécessite un navigateur pour exécuter JavaScript. Une requête qui échoue, ou qu'un robots.txt de site refuse, n'est pas facturée |
| Prix | 14,25 $US pour 50 000 pages ; les crédits n'expirent jamais |

## Pourquoi un Markdown propre donne-t-il de meilleurs résultats de recherche ?

Les chunks composés de boilerplate se retrouvent mal. Quand une page est découpée avec ses menus, son texte de cookies et son pied de page encore présents, beaucoup de chunks contiennent les mêmes mots de navigation, et la recherche vectorielle les renvoie pour des questions sans rapport. L'extraction du contenu principal supprime ce bruit avant l'embedding.

Les titres comptent tout autant. Un chunk qui commence par `## Refund policy` porte son sujet avec lui, si bien que l'embedding et le modèle qui le lira ensuite savent de quoi il parle. Le texte brut perd ce signal ; le HTML brut le cache sous le balisage.

## À quoi ressemble un pipeline d'ingestion ?

Cinq étapes, quel que soit le vector store que vous utilisez :

1. **Collectez les URL.** Crawlez le site, ou envoyez la liste que vous avez déjà en un batch.
2. **Lisez en Markdown.** Gardez `main_content=true` pour les articles et la documentation ; utilisez `false` pour les pages de listing.
3. **Découpez par titre.** Séparez sur `#`, `##` et `###`, puis coupez les sections longues à votre limite de taille avec un petit chevauchement.
4. **Ajoutez les métadonnées.** Stockez `url`, `title`, `published_at` et le chemin de titres avec chaque chunk, pour que les réponses puissent citer leur source.
5. **Rafraîchissez.** Relisez les pages dont le `lastmod` du sitemap a changé, et supprimez les chunks des pages qui renvoient désormais une erreur.

*Python : lire des pages et les découper en chunks avec leur source*

```python
import os
import re

import requests

API = "https://webreaderapi.com/api/v1/read"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
URLS = [
    "https://docs.example.com/getting-started",
    "https://docs.example.com/billing",
]


def chunks_for(url, max_len=2000):
    page = requests.get(API, headers=HEADERS, params={"url": url}, timeout=90).json()
    if "markdown" not in page:
        return []
    out = []
    for section in re.split(r"\n(?=#{1,3} )", page["markdown"]):
        section = section.strip()
        heading = section.splitlines()[0] if section else ""
        for start in range(0, len(section), max_len):
            out.append({
                "text": section[start:start + max_len],
                "url": page.get("final_url", url),
                "title": page.get("title"),
                "heading": heading,
            })
    return out


all_chunks = [c for u in URLS for c in chunks_for(u)]
print(len(all_chunks), "chunks ready to embed")

```

## Combien coûte la construction et le rafraîchissement d'un index ?

La construction coûte un crédit par page, deux pour les pages qui nécessitent un navigateur. Le rafraîchissement ne coûte que les pages que vous relisez. Trois exemples, aux prix d'octobre 2026 :

- **Le centre d'aide d'un produit** de 800 pages, rafraîchi chaque mois pour les pages modifiées (environ 10 %) : 800 crédits une fois, puis environ 80 par mois. 10 000 pages (3,75 $US) durent des années.
- **Dix sites de documentation** de 2 000 pages chacun, rafraîchis chaque semaine à 5 % : 20 000 crédits, puis environ 4 000 par mois. 50 000 pages (14,25 $US) couvrent la construction et sept mois de rafraîchissements.
- **Une archive de presse** de 300 000 articles qui ne changent jamais : 300 000 crédits une fois, ce qui tient dans 500 000 pages (50 $US).

L'embedding et le stockage sont facturés par vos propres fournisseurs et ne sont pas inclus.

## Puis-je indexer des sites qui ne veulent pas être indexés ?

Pas via WebReaderAPI. Les pages interdites par robots.txt pour notre crawler, ou pour tous les robots, sont ignorées et non facturées ; les sites qui déclarent `Content-Signal: ai-input=no` ne sont pas lus pour vous. Pour vos propres sites ou des sites partenaires qui bloquent les robots, demandez au propriétaire d'autoriser `WebReaderAPI` dans robots.txt ; notre [page crawler](https://webreaderapi.com/fr/bot/) indique les lignes à ajouter.

Cela compte aussi pour vos utilisateurs. Un assistant RAG qui cite ses sources est plus utile quand ces sources ont accepté d'être lues.

## Quel pack convient à un projet RAG ?

Comptez les pages pour construire l'index, ajoutez le rafraîchissement mensuel, et choisissez le pack qui couvre quelques mois. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |
| Scale | 500 000 pages | 50 $US | 0,10 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Ingestion RAG : questions fréquentes

### Quelle taille de chunk dois-je utiliser ?

Découpez d'abord sur les titres, puis coupez les sections plus longues qu'environ 500 à 1 000 tokens avec un petit chevauchement. Les chunks basés sur les titres gardent un seul sujet chacun, ce qui donne généralement de meilleurs résultats de retrieval que des fenêtres de taille fixe sur toute la page.

### Est-ce que WebReaderAPI crée des embeddings ou stocke des vecteurs ?

Non. WebReaderAPI lit les pages et renvoie du Markdown avec des métadonnées. Vous faites l'embedding avec le modèle de votre choix et stockez dans votre propre base de données vectorielle ; la [page LangChain et LlamaIndex](https://webreaderapi.com/fr/docs/langchain/) montre les deux.

### Comment garder l'index à jour ?

Relisez uniquement les pages qui ont changé. La plupart des sitemaps indiquent une date `lastmod` par URL ; comparez-la avec votre dernière lecture et envoyez les URL modifiées en un batch. Les pages qui échouent désormais doivent être retirées de l'index.

### Puis-je inclure des PDF du même site ?

Oui. Un crawl lit les liens PDF du même domaine avec les mêmes vérifications robots.txt. Les fichiers PDF jusqu'à 20 MB et 100 pages sont convertis en Markdown, à 1 crédit par bloc de 10 pages entamé.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.


---

# Convertir votre site web en Markdown : le crawler et exporter chaque page

> Convertissez votre site en Markdown : explorez-le et exportez chaque page avec front matter pour une migration ou votre assistant. Sans KYC.

- URL: https://webreaderapi.com/fr/use-cases/website-to-markdown/
- Dernière mise à jour: 2026-10-22
- Éditeur: WebReaderAPI (https://webreaderapi.com)

Passer à un générateur de site statique, une plateforme de documentation ou une base de connaissances commence souvent par une question : comment récupérer mes pages en Markdown propre ? Un crawl le fait en une seule tâche, avec titres, dates et URL conservés dans le front matter.

**Réponse rapide — Comment convertir tout mon site web en Markdown ?**

Crawlez votre site, lisez le contenu principal de chaque page en Markdown, et écrivez un fichier `.md` par page avec son titre, son URL et sa date dans le front matter. **WebReaderAPI** crawle jusqu'à 10 000 pages par tâche, suit votre sitemap et votre robots.txt, et facture un crédit par page à partir de 0,07 $US/1K pages aux prix d'octobre 2026. Un script Python ci-dessous écrit les fichiers. Sans KYC ; payez en crypto.

## Export du site web avec WebReaderAPI

| Attribut | Valeur |
| --- | --- |
| Endpoint | `POST https://webreaderapi.com/api/v1/crawl`, résultats de `GET https://webreaderapi.com/api/v1/jobs/{job_id}` |
| Portée | Crawl d'un seul site web par job, jusqu'à 10 000 pages, en suivant son sitemap, son robots.txt et son Crawl-delay |
| Par page | Markdown du contenu principal, plus titre, description, auteur, date et langue |
| Pages entières | `main_content=false` conserve la navigation et les pieds de page quand vous en avez besoin |
| Votre robots.txt | Doit autoriser `WebReaderAPI` pour les pages que vous exportez |
| Prix | 3,75 $US pour 10 000 pages ; les crédits n'expirent jamais |

## Quand un export Markdown est-il utile ?

Chaque fois que le contenu doit quitter le système qui le rend. Cas courants :

- **Migrations.** Passer d'un CMS à un générateur de site statique ou à une plateforme de documentation qui stocke les pages en Markdown.
- **Sauvegardes.** Une archive lisible de vos pages publiées qui ne dépend d'aucune base de données ni d'aucun thème.
- **Votre propre assistant.** Alimenter le texte de votre site dans un bot d'aide ou une recherche interne, avec chaque chunk lié à sa page.
- **Audits.** Lire toutes vos pages en texte brut pour repérer des affirmations obsolètes, des formulations cassées ou du contenu dupliqué.

Dans chaque cas, vous voulez les mots et la structure, pas le thème autour.

*Python : crawler votre site dans des fichiers Markdown avec front matter*

```python
import os
import pathlib
import time
from urllib.parse import urlparse

import requests

API = "https://webreaderapi.com/api/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]}
SITE = "https://www.example.com/"
OUT = pathlib.Path("export")


def target_path(url):
    path = urlparse(url).path.strip("/") or "index"
    return OUT / (path + ".md")


def front_matter(page):
    fields = {"title": page.get("title", ""), "source": page["final_url"], "date": page.get("published_at") or ""}
    lines = ["---"] + [key + ": " + repr(value) for key, value in fields.items()] + ["---", ""]
    return "\n".join(lines)


job = requests.post(API + "/crawl", headers=HEADERS, json={"url": SITE, "limit": 2000, "max_depth": 5}, timeout=60).json()
cursor, delay, written = None, 5, 0
while True:
    params = {"cursor": cursor} if cursor else {}
    batch = requests.get(API + "/jobs/" + job["job_id"], headers=HEADERS, params=params, timeout=60).json()
    for page in batch.get("results", []):
        if "markdown" not in page:
            continue
        dest = target_path(page["final_url"])
        dest.parent.mkdir(parents=True, exist_ok=True)
        dest.write_text(front_matter(page) + page["markdown"] + "\n", encoding="utf-8")
        written += 1
    cursor = batch.get("next_cursor")
    if batch["status"] == "done" and not cursor:
        break
    if not cursor:
        time.sleep(delay)
        delay = min(delay * 2, 60)
print(written, "files in", OUT)

```

## Comment conserver l'arborescence des dossiers et les URL ?

Reproduisez le chemin de l'URL dans le chemin du fichier, comme le fait le script : `/guides/setup/` devient `export/guides/setup.md`. Gardez l'URL d'origine dans le front matter comme `source`, pour pouvoir mettre en place des redirections après la migration et vérifier que rien n'a été perdu.

Les liens dans le Markdown pointent toujours vers vos URL actuelles. Après le déménagement, remplacez le domaine ou le préfixe de chemin en une passe, puis testez un échantillon de pages. Les tableaux et les blocs de code restent en Markdown, donc la plupart des générateurs statiques les rendent sans modifications.

## Et si mon propre robots.txt bloque les crawlers ?

Autorisez notre token le temps de l'export. WebReaderAPI ne lit que ce que robots.txt permet pour `WebReaderAPI` ou pour tous les robots, y compris sur votre propre site. Ajoutez un groupe comme `User-agent: WebReaderAPI` avec `Allow: /`, lancez le crawl, puis retirez-le si vous le souhaitez.

Notre [page crawler](https://webreaderapi.com/fr/bot/) indique les lignes exactes et le User-Agent que les logs de votre serveur afficheront. Les pages qui restent interdites sont ignorées et non facturées.

## Combien coûte un export ?

Un crédit par page, deux pour les pages qui nécessitent un navigateur pour afficher leur texte. Un site de 2 000 pages rendu côté serveur coûte 2 000 crédits une fois ; le même site en application JavaScript peut coûter jusqu'à 4 000. Les deux tiennent dans 10 000 pages pour 3,75 $US, aux prix d'octobre 2026.

Un site de 50 000 pages nécessite plusieurs tâches, découpées par section avec `include_paths`, et tient dans 100 000 pages (21,75 $US). Les crédits qui restent après l'export restent sur votre compte pour des rafraîchissements ultérieurs.

## Quel pack couvre mon export ?

Comptez vos pages, doublez le nombre si le site nécessite JavaScript pour s'afficher, puis choisissez le pack au-dessus. Les crédits n'expirent jamais.

| Offre | Quantité | Prix | Prix par unité |
| --- | --- | --- | --- |
| Test | 10 000 pages | 3,75 $US | 0,38 $US/1K pages |
| Starter | 50 000 pages | 14,25 $US | 0,28 $US/1K pages |
| Build | 100 000 pages | 21,75 $US | 0,22 $US/1K pages |

Dans chaque offre: Extraction du contenu principal · Rendu JavaScript si nécessaire · Pages en échec et refusées non facturées · Les crédits n'expirent jamais

**Avant de payer**

- Recharge minimum 25 $US. Rechargez une fois en crypto, puis achetez n'importe quelle offre depuis votre solde.
- Votre solde n'a pas de date d'expiration et peut acheter des crédits de page à tout moment. Si un pack coûte moins que le dépôt minimum, le montant que vous avez ajouté uniquement pour atteindre ce minimum peut être renvoyé sur demande dans les 30 jours suivant le paiement, en USDT ou USDC, tant que vous ne l'avez pas dépensé. Tout autre solde n'est pas remboursé, sauf si la loi en dispose autrement.
- Crédité dès que votre paiement a été vérifié sur la blockchain. Délai habituel de confirmation du réseau : BTC ≈ 20 min · USDT TRC-20 ≈ 1 min · USDT ERC-20 ≈ 5 min · USDC ERC-20 ≈ 5 min · ETH ≈ 5 min · SOL ≈ 1 min · LTC ≈ 15 min

## Site web vers Markdown : questions fréquentes

### Puis-je exporter la page entière, menus et pied de page inclus ?

Oui. Activez `main_content=false` dans les options de crawl et chaque fichier contient la page complète convertie en Markdown. La plupart des migrations préfèrent le contenu principal uniquement, car le nouveau thème fournit sa propre navigation.

### Les images sont-elles téléchargées ?

Non. Avec `include_images=true`, les liens des images restent dans le Markdown avec leur texte alternatif ; téléchargez les fichiers eux-mêmes avec votre propre script si la migration en a besoin.

### Puis-je exporter un site qui ne m'appartient pas ?

Uniquement les pages publiques autorisées par son robots.txt, et seulement pour des usages permis par ses conditions et la loi. Pour une migration ou une sauvegarde, exportez vos propres sites ou des sites dont le propriétaire est d'accord.

### Quelle taille de site un job peut-il traiter ?

Jusqu'à 10 000 pages par job de crawl, dans un même domaine. Découpez les sites plus grands par section avec `include_paths` et lancez plusieurs jobs.

---

WebReaderAPI: WebReaderAPI est une API de lecture de pages web pour agents IA qui transforme toute page web publique en Markdown propre, payable en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 0,07 $US/1K pages n'expirent jamais, et robots.txt est respecté. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.