# Vérifications de sites

> URL: https://foura.ai/fr/docs/api/site-checks
> Updated: 2026-11-11
> Index: https://foura.ai/llms.txt

Lorsqu'une cible exécute une vérification anti-bot avant d'accéder à la page demandée, FourA vous le signale. Chaque request qui en rencontre une renvoie un champ indiquant le système, si le contrôle a été validé et, le cas échéant, le jeton de validation que vous pouvez réutiliser pour que l'appel suivant l'ignore.

Cette page sert de référence pour ces champs. Pour les stratégies, consultez [Sites protégés](https://foura.ai/docs/guides/protected-sites).

## Emplacement du champ

| Endpoint | Champ | Présent si |
|----------|-------|------------|
| `POST /api/single/` | `defense` (objet) | Une vérification anti-bot a été reconnue sur la response |
| `POST /api/proxy/` | `defense` (objet) | Identique, signalé par la tentative ayant répondu |
| `POST /api/browser/` | `defenseSolved` (booléen) et `defenses` (objet) | Toujours, sur une page chargée. `defenseSolved` vaut `false` et `defenses` est vide si rien n'a été reconnu. |
| `POST /api/auto/` | `meta.solved` (booléen) | Sur chaque réponse dès que la séquence a démarré. `true` lorsqu'une vérification a été validée au cours de la séquence. Un corps non validé ou un hôte non résolu reçoit une réponse avant la séquence, sans `meta`. |

L'absence de champ signifie que rien n'a été reconnu. N'interprétez pas un `defense` manquant comme un échec.

Sur Single et Proxy, la notification nécessite `unblocker`, activé par défaut. Avec `unblocker: false`, vous demandez la page brute telle quelle, donc Single renvoie le challenge intact et Browser le restitue sans le résoudre.

## `defense` sur Single et Proxy

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "total_time": 3.61,
  "defense": {
    "vendor": "sgcaptcha",
    "solved": true,
    "present": ["sgcaptcha"],
    "ms": 3412,
    "hashes": 1048576,
    "complexity": 20,
    "cookie": "_I_=<clearance>"
  }
}
```

| Champ | Type | Description |
|-------|------|-------------|
| `vendor` | string | Le système concerné par cet enregistrement : celui qui a été validé ou le principal rencontré. Voir la liste des fournisseurs ci-dessous. |
| `solved` | boolean | `true` signifie que la vérification a été validée et que `data` est la page réelle. `false` signifie que `data` peut être la page de défi. |
| `present` | string[] | Tous les systèmes reconnus sur cette réponse. Peut contenir plus de noms que `vendor`, et des noms que personne ne valide encore. |
| `ms` | number | Millisecondes passées à valider la vérification. Présent uniquement en cas de validation. |
| `hashes` | number | Quantité de travail de calcul demandée par le défi. Présent uniquement en cas de validation. |
| `complexity` | number | Difficulté déclarée par le défi. Présent uniquement en cas de validation et si le défi en signale une. |
| `answers` | number | Nombre de réponses acceptées fournies, pour les défis qui en exigent plusieurs au lieu d'une seule. Présent uniquement en cas de validation. |
| `retry` | string | Présent lorsque le corps provient d'une nouvelle tentative plutôt que d'une validation : `refusal-cookies`, `amazon-continue`, `reddit-js-check` ou `verify-challenge`. Voir ci-dessous. |
| `cookie` | string | Le jar à rejouer : l'autorisation obtenue lors d'une validation, ou la session retournée par un refus. |

`solved: false` est le cas sur lequel baser votre logique. FourA ne présente jamais une page de défi comme du contenu, ce drapeau signale donc que le corps de la réponse nécessite une escalade plutôt qu'une analyse.

### `retry: "refusal-cookies"`

Certains sites ne proposent pas d'énigme. Ils refusent la première requête, définissent des cookies sur le refus et renvoient la vraie page à quiconque renvoie ces cookies. Les pages d'articles d'eBay en sont l'exemple de référence.

Lorsque cela se produit, FourA les renvoie pour vous et vous transmet la page. La réponse inclut alors `retry: "refusal-cookies"` :

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "defense": {
    "vendor": "akamai",
    "solved": false,
    "present": ["akamai"],
    "retry": "refusal-cookies",
    "cookie": "bm_sv=...; dp1=..."
  }
}
```

Lisez-le ainsi :

- **`solved` reste `false`.** Répondre à un handshake n'est pas résoudre un challenge, et cela ne change jamais le coût de l'appel. Vous êtes facturé pour la request effectuée.
- **`data` correspond au vrai contenu**, pas à une page de challenge. C'est le seul cas où `solved: false` ne signifie pas que le body nécessite une escalade, et c'est la raison d'être de ce champ.
- **`cookie` est la session transmise par le site.** Rejouez-la comme vous rejoueriez une autorisation, et les pages suivantes contourneront le refus.
- Un retry et une résolution peuvent tous deux survenir sur une même request. Si la réponse du retry s'est avérée être un challenge que FourA peut résoudre, vous obtenez `solved: true` avec les champs propres au fournisseur **et** `retry: "refusal-cookies"` à leurs côtés.

`vendor` indique `unknown` lorsqu'un retry a généré le contenu et qu'aucun système n'a été reconnu durant le processus. `present` est alors un tableau vide.

### `retry: "amazon-continue"`

Amazon répond parfois avec un contrôle de robot à un clic : une petite page vous invitant à cliquer pour continuer vos achats, avec la réponse déjà préremplie. Avec `unblocker` activé (par défaut), Single et Proxy cliquent sur ce bouton depuis la même sortie, au sein de votre `timeout_ms`, et demandent à nouveau votre page avec les cookies définis. Lorsque la page s'ouvre, la response contient `retry: "amazon-continue"` :

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "defense": {
    "vendor": "akamai",
    "solved": false,
    "present": ["akamai", "amazon"],
    "retry": "amazon-continue",
    "cookie": "ak_bmsc=...; ..."
  }
}
```

Interprétez cela comme une nouvelle tentative de cookies de refus. `solved` reste `false`, `data` est la page réelle, la request effectuée vous est facturée, et `cookie` est le jar à rejouer sur les pages suivantes. Cherchez `amazon` dans `present` plutôt que dans `vendor`: la page de vérification définit souvent un cookie que FourA reconnaît également, et `vendor` nomme le premier système de la liste.

La version image de cette même vérification, où une personne doit lire la réponse, est signalée et laissée telle quelle. Il en va de même pour un clic qui ne fait que réafficher la vérification. Dans les deux cas, cette page n'est pas facturée (voir [Tarification](#what-it-costs)).

### `retry: "reddit-js-check"`

Reddit répond parfois par une vérification de page légère: une petite page contenant un formulaire masqué et un script qui remplit ce formulaire. Lorsque `unblocker` est activé (par défaut), Single et Proxy soumettent ce formulaire sur la même sortie, au sein de votre `timeout_ms`, et demandent à nouveau votre page avec les cookies définis. Lorsque cela ouvre la page, la response contient `retry: "reddit-js-check"`:

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "defense": {
    "vendor": "reddit",
    "solved": false,
    "present": ["reddit"],
    "retry": "reddit-js-check",
    "cookie": "edgebucket=...; ..."
  }
}
```

Interprétez cela comme une nouvelle tentative `amazon-continue`. `solved` reste `false`, `data` correspond à la vraie page, vous êtes facturé pour la request effectuée, et `cookie` est le jar à rejouer sur les pages suivantes. Lorsque la vérification persiste, FourA laisse la page telle qu'elle est arrivée, et cette page n'est pas facturée.

### `retry: "verify-challenge"`

Certains sites s'ouvrent avec leur propre page de vérification intermédiaire: un indicateur de chargement et un script qui vous redirige vers la page une fois le contrôle terminé. Avec `unblocker` activé (par défaut), Single et Proxy effectuent cette vérification sur la même sortie, au sein de votre `timeout_ms`, puis demandent à nouveau votre page avec le cookie ainsi défini. Lorsque cela permet d'accéder à la page, la response contient `retry: "verify-challenge"`:

```json
{
  "status": 200,
  "data": "<!doctype html>...",
  "defense": {
    "vendor": "verify-challenge",
    "solved": false,
    "present": ["verify-challenge"],
    "retry": "verify-challenge",
    "cookie": "token=..."
  }
}
```

Considérez cela comme une tentative de réessai de type `reddit-js-check`. `solved` reste `false`, `data` est la véritable page, vous êtes facturé pour la request effectuée, et `cookie` est le jar à rejouer sur les pages suivantes. Lorsque la page de vérification revient sans réponse, elle n'est pas facturée.

## `defenses` sur Browser

```json
{
  "status": 200,
  "body": "<!doctype html>...",
  "userAgent": "Mozilla/5.0...",
  "defenseSolved": true,
  "defenses": {
    "present": ["cloudflare"],
    "cleared": ["cloudflare"]
  }
}
```

| Champ | Type | Description |
|-------|------|-------------|
| `defenseSolved` | boolean | `true` lorsqu'un système a été rencontré pendant le chargement et que son autorisation est conservée sur la page finale. Il s'agit de l'indicateur qui détermine si l'appel coûte 5 ou 10 crédits. |
| `defenses.present` | string[] | Chaque système reconnu à n'importe quel moment du chargement de la page, pas seulement sur la réponse finale. Une vérification est un événement passé, et au moment où la vraie page arrive, la réponse au challenge a disparu depuis longtemps. |
| `defenses.cleared` | string[] | Les systèmes dont la page finale conserve l'autorisation. |

Un nom présent dans `present` qui n'atteint jamais `cleared` correspond à un système que FourA a reconnu sans obtenir d'autorisation pour celui-ci: un système qu'il ne peut pas encore résoudre, ou l'un des rares cas que Browser gère autrement (voir [Ce qui est résolu aujourd'hui](#what-gets-cleared-today)). Ceux-ci n'augmentent jamais le prix d'un appel.

## Fournisseurs

| Valeur `vendor` | Le système |
|----------------|-----------|
| `cloudflare` | Challenges Cloudflare et gestion des bots |
| `sgcaptcha` | Vérification de site de SiteGround |
| `datadome` | DataDome |
| `perimeterx` | PerimeterX |
| `akamai` | Akamai Bot Manager |
| `incapsula` | Imperva Incapsula |
| `awswaf` | Challenge AWS WAF |
| `ebay-splashui` | Challenge propre à eBay |
| `reddit` | Pages de vérification et de refus propres à Reddit |
| `verify-challenge` | Page de vérification propre à un site qui vous redirige une fois sa vérification terminée |
| `amazon` | Vérification robot d'Amazon |
| `hcaptcha` | hCaptcha |
| `recaptcha` | reCAPTCHA |
| `unknown` | Aucun système n'a été reconnu. N'apparaît qu'aux côtés de `retry`, où l'enregistrement existe pour signaler la nouvelle tentative plutôt qu'un fournisseur. |

### Ce qui est résolu aujourd'hui

| Endpoint | Résout |
|----------|--------|
| Single, Proxy | `sgcaptcha`, `ebay-splashui`. Tous deux sont computationnels plutôt que visuels, aucun navigateur n'est donc impliqué. |
| Browser | `cloudflare`, `sgcaptcha` |

Quelques autres sont traités sans validation d'autorisation formelle. Single et Proxy cliquent sur le bouton unique de vérification robot d'Amazon et le signalent sous `retry: "amazon-continue"`, soumettent la vérification de page légère de Reddit et la signalent sous `retry: "reddit-js-check"`, et complètent la page de vérification propre d'un site en la signalant sous `retry: "verify-challenge"`. Browser attend jusqu'à 10 secondes que cette même page de vérification effectue la redirection. Browser clique sur le bouton d'Amazon, et attend que la page de capteur d'Akamai, la page de challenge d'AWS WAF, la vérification d'appareil de DataDome ou la page de challenge propre à eBay charge la page suivante d'elle-même, puis renvoie cette page. Si cette page n'arrive jamais, Browser renvoie celle qu'il détenait, au sein de votre `timeout_ms`. Sur Browser, ces noms apparaissent dans `defenses.present`, jamais dans `cleared`, et l'appel coûte 5.

Tout le reste de la liste est reconnu et signalé, rien de plus. Cette répartition évolue à mesure que FourA apprend à en résoudre davantage, consultez donc `solved` plutôt que de vous baser sur ce tableau.

Deux remarques sur les cas limites:

- `hcaptcha` et `recaptcha` sont également des widgets de formulaire ordinaires. Ils ne sont signalés que lorsque la response vous a réellement bloqué (403, 429 ou 503), de sorte qu'une page de paiement avec un widget de vérification dans un formulaire ne signale pas de défense.
- Être derrière Cloudflare ne constitue pas une défense. `cloudflare` apparaît lorsqu'un véritable challenge ou un artefact de gestion des bots est présent sur la response, et non pas simplement parce qu'un site utilise Cloudflare.

## Rejouer une clearance

`defense.cookie` est la raison d'être de ce champ. Une clearance est liée à la sortie qui l'a obtenue et au User-Agent qui l'a obtenue, rejouez-la donc via la même paire et la vérification ne s'exécutera pas à nouveau.

```python
import requests

API = "https://eu.api.foura.ai"
H = {"X-API-Key": "YOUR_API_KEY", "Content-Type": "application/json"}

# 1) First call pays for the clear.
first = requests.post(f"{API}/api/proxy/", headers=H, json={
    "maxTries": 5,
    "request": {"method": "GET", "url": "https://example.com/catalog"},
}).json()

defense = first.get("defense", {})
if defense.get("solved"):
    clearance = defense["cookie"]
    exit_id = first["proxy"]

    # 2) Follow-up pages skip the check: same exit, same clearance.
    for page in range(2, 6):
        r = requests.post(f"{API}/api/single/", headers=H, json={
            "method": "GET",
            "url": f"https://example.com/catalog?page={page}",
            "proxy": exit_id,
            "headers": [["Cookie", clearance]],
        }).json()
        print(page, r["status"])
```

Le premier appel supporte le coût de la résolution. Chaque rejeu est une requête ordinaire au tarif standard.

Trois éléments peuvent invalider un rejeu :

1. **Une sortie différente.** Épinglez l'ID de proxy renvoyé par la réponse résolue. Consultez [Réutiliser un proxy sur plusieurs requêtes](https://foura.ai/docs/how-to/reuse-a-proxy).
2. **Un User-Agent différent.** Les réponses Browser renvoient le `userAgent` utilisé. Renvoyez-le avec le cookie.
3. **L'expiration.** Les autorisations ont leur propre durée de validité, définie par la cible. Celle de SiteGround dure environ 30 jours pour l'ensemble du site; une autorisation Cloudflare est généralement beaucoup plus courte. Considérez une autorisation comme un cache : lorsque les rejeux recommencent à renvoyer des challenges, effectuez un nouvel appel complet et récupérez le nouveau jeton.

## Tarification

Une vérification résolue modifie uniquement le prix sur Browser :

| Moteur | Base | Défense résolue |
|--------|------|-----------------|
| Single | 1 (2 avec `unblocker`) | Aucun changement |
| Proxy | 2 (4 avec `unblocker`) | Aucun changement |
| Browser | 5 | 10 |

Browser facture 10 crédits uniquement lorsque le résolveur était activé et qu'un système a été réellement contourné. Un système reconnu mais non résolu coûte 5 crédits, soit le même tarif qu'une page sans aucune vérification.

Une page de vérification ou de refus reconnue par FourA et renvoyée avec un code HTTP 200 (par exemple la vérification robot d'Amazon, la page de vérification de Reddit ou la page de challenge d'eBay) n'est facturée sur aucun endpoint. Les réponses Single, Proxy et Browser l'indiquent dans `X-FourA-Check-Page`.

## Associer avec `validate`

`defense` vous indique qu'un contrôle a été rencontré. `validate` indique à FourA à quoi ressemble la vraie page, ce qui permet à une requête d'échouer au lieu de vous renvoyer une page intermédiaire contenant un code HTTP 200.

```json
{
  "method": "GET",
  "url": "https://example.com/product/42",
  "validate": {
    "data": {"accept": ["Add to cart"], "fail": ["Just a moment"]}
  }
}
```

Sur `POST /api/auto/`, `validate` empêche l'escalade d'accepter une page de challenge et de la considérer comme terminée.

## Liens associés

- [Sites protégés](https://foura.ai/docs/guides/protected-sites) : Quel moteur utiliser pour chaque niveau de protection
- [Endpoints API](https://foura.ai/docs/api/endpoints) : Référence des requêtes et réponses pour les quatre endpoints
- [Réutiliser un proxy entre les requêtes](https://foura.ai/docs/how-to/reuse-a-proxy) : Épingler la sortie à laquelle une autorisation est liée
- [Smart Fetch (Auto)](https://foura.ai/docs/guides/smart-fetch) : Comment `meta.solved` s'intègre dans l'escalade
- [Headers de réponse](https://foura.ai/docs/api/response-headers) : Où apparaît le coût en crédits d'un appel
