# Référence du endpoint de recherche : POST et GET /search

> Endpoint de recherche : les paramètres POST et GET /search, de read et max_chars à topic, time_range et filtres de domaines. Paiement en crypto.

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

`/search` lance une recherche web en direct, classe jusqu'à 20 résultats et lit les pages derrière les premiers. Cette page liste chaque paramètre, sa valeur par défaut, ses limites et son effet sur le prix.

**Réponse rapide — Quels paramètres prend le endpoint de recherche LLMWebSearch ?**

Le endpoint `/search` de **LLMWebSearch** ne nécessite que `q`. Les paramètres facultatifs définissent le nombre de résultats renvoyés (`max_results`), le nombre de pages lues (`read`), le format et la longueur du contenu, actualités ou web, une plage temporelle, le pays et la langue, ainsi que les domaines à conserver ou à exclure. Lire jusqu'à 3 pages coûte 1 crédit, à partir de 1,20 $US/1K requêtes en octobre 2026. Sans KYC ; paiement en crypto.

## /search at a glance

| Attribut | Valeur |
| --- | --- |
| Méthodes | `POST` avec un corps JSON, ou `GET` avec les mêmes noms dans la chaîne de requête |
| URL | `https://llmwebsearch.com/api/v1/search` |
| Requis | `q` : 1 à 400 caractères ; les opérateurs de recherche sont transmis tels quels |
| Valeurs par défaut | 5 résultats, les 3 premiers lus, Markdown jusqu'à 6 000 caractères par page |
| Facturation | Un crédit paie une recherche : jusqu'à 20 résultats classés, avec les pages des 3 premiers lues et renvoyées en Markdown. Lire 4 à 10 pages coûte 2 crédits. Un appel qui se termine sur une erreur ne coûte rien |
| Résultats | Les résultats proviennent d'une recherche web lancée au moment de votre appel, dans l'ordre où le moteur de recherche les classe ; rien ne vient d'un ancien index |
| Filtres | Choisissez le pays et la langue des résultats, une plage temporelle (jour, semaine, mois ou année écoulés), des résultats web ou news, et des domaines à inclure ou à exclure |
| Lecteur de pages | `LLMWebSearch/1.0 (+https://llmwebsearch.com/bot/)` |

## Rechercher sur le web et lire les meilleurs résultats (POST)

`POST /api/v1/search`

Lance une recherche web en direct et renvoie des résultats classés. Les pages des `read` premiers résultats sont récupérées en parallèle et leur contenu principal est renvoyé en `content`. L'exemple demande comment faire tourner des clés API ; les titres, dates et valeurs sont illustratifs.

Authentification : clé API dans l’en-tête `Authorization: Bearer API_KEY`.

**Corps de la requête**

| Champ | Type | Requis | Description |
| --- | --- | --- | --- |
| `q` | string | Oui | La requête de recherche, de 1 à 400 caractères. Les guillemets et les opérateurs comme `site:` sont conservés tels quels. |
| `max_results` | integer | Non | Nombre de résultats classés, de 1 à 20. Valeur par défaut 5. |
| `read` | integer | Non | Combien parmi les premiers résultats sont lus et renvoyés avec leur contenu, de 0 à 10. Valeur par défaut 3. À partir de 4, l'appel coûte 2 crédits. |
| `format` | string | Non | `markdown` (par défaut) ou `text` pour le contenu de la page. |
| `max_chars` | integer | Non | Limite de longueur du contenu de chaque page, de 500 à 50 000 caractères. Par défaut 6 000. |
| `topic` | string | Non | `web` (par défaut) ou `news`. |
| `time_range` | string | Non | `day`, `week`, `month` ou `year`. Pas de valeur par défaut : n'importe quelle date. |
| `country` | string | Non | Code pays à deux lettres (ISO 3166-1 alpha-2) pour le lieu d'exécution de la recherche. Valeur par défaut `us`. |
| `language` | string | Non | Langue des résultats, comme `en`, `de` ou `pt-BR`. Valeur par défaut `en`. |
| `include_domains` | string[] | Non | Jusqu'à 20 domaines ; seuls les résultats de ces domaines et de leurs sous-domaines sont conservés. |
| `exclude_domains` | string[] | Non | Jusqu'à 20 domaines dont les résultats sont exclus. |

*Exemple: five results, the top three read as Markdown*

```json
{
  "q": "how to rotate api keys without downtime",
  "max_results": 5,
  "read": 3,
  "max_chars": 6000
}
```

*Exemple: news of the past week from two sites, nothing read*

```json
{
  "q": "open source license change",
  "topic": "news",
  "time_range": "week",
  "include_domains": [
    "news.example.com",
    "example.org"
  ],
  "read": 0
}
```

**Réponse** `200`

```json
{
  "query": "how to rotate api keys without downtime",
  "created_at": "2026-10-22T10:15:04Z",
  "credits_used": 1,
  "results": [
    {
      "position": 1,
      "title": "Rotating API keys",
      "url": "https://docs.example.com/security/key-rotation",
      "host": "docs.example.com",
      "snippet": "Create a second key, deploy it everywhere, then revoke the first one.",
      "published_at": "2026-09-30",
      "content_status": "ok",
      "content": "# Rotating API keys\n\n## Zero-downtime rotation\n\n1. Create a second key.\n2. Deploy it to every service.\n3. Revoke the old key.",
      "word_count": 948
    },
    {
      "position": 2,
      "title": "Key rotation checklist",
      "url": "https://blog.example.org/key-rotation-checklist",
      "host": "blog.example.org",
      "snippet": "Keep two keys active during the switch and alert on the old one.",
      "content_status": "blocked_by_robots"
    },
    {
      "position": 3,
      "title": "Secrets management basics",
      "url": "https://security.example.net/secrets-basics",
      "host": "security.example.net",
      "snippet": "Never commit keys to a repository.",
      "published_at": "2026-06-12",
      "content_status": "ok",
      "content": "# Secrets management basics\n\n**Never** commit keys to a repository...",
      "word_count": 1310
    },
    {
      "position": 4,
      "title": "API key best practices",
      "url": "https://dev.example.com/api-key-best-practices",
      "host": "dev.example.com",
      "snippet": "Scope each key to one service and one environment.",
      "content_status": "not_requested"
    }
  ]
}
```

*curl*

```bash
curl -s "https://llmwebsearch.com/api/v1/search" \
  -H "Authorization: Bearer $LLMWEBSEARCH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"q": "how to rotate api keys without downtime", "max_results": 5, "read": 3}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://llmwebsearch.com/api/v1/search",
    headers={"Authorization": "Bearer " + os.environ["LLMWEBSEARCH_API_KEY"]},
    json={"q": "how to rotate api keys without downtime", "max_results": 5, "read": 3},
    timeout=60,
)
resp.raise_for_status()
for r in resp.json()["results"]:
    print(r["position"], r["content_status"], r["url"])
```

*Node.js*

```javascript
const res = await fetch('https://llmwebsearch.com/api/v1/search', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.LLMWEBSEARCH_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ q: 'how to rotate api keys without downtime', max_results: 5, read: 3 }),
});
const { results } = await res.json();
for (const r of results) console.log(r.position, r.content_status, r.url);
```

## Rechercher sur le web (GET)

`GET /api/v1/search`

La même recherche avec les paramètres dans la chaîne de requête, encodés en URL. Les listes comme `include_domains` s'écrivent en une seule valeur séparée par des virgules. Pratique pour un test rapide ou pour les outils qui n'envoient que des requêtes GET. L'exemple ne demande que des résultats (`read=0`).

Authentification : clé API dans l’en-tête `Authorization: Bearer API_KEY`.

**Paramètres**

| Nom | Dans | Type | Requis | Description |
| --- | --- | --- | --- | --- |
| `q` | query | string | Oui | La requête de recherche, encodée pour URL, de 1 à 400 caractères. |
| `max_results` | query | integer | Non | De 1 à 20. Valeur par défaut : 5. |
| `read` | query | integer | Non | De 0 à 10. Valeur par défaut : 3 ; à partir de 4, cela coûte 2 crédits. |
| `format` | query | string | Non | `markdown` (par défaut) ou `text`. |
| `max_chars` | query | integer | Non | De 500 à 50 000 par page. Valeur par défaut : 6 000. |
| `topic` | query | string | Non | `web` (par défaut) ou `news`. |
| `time_range` | query | string | Non | `day`, `week`, `month` ou `year`. |
| `country` | query | string | Non | Code ISO 3166-1 alpha-2. Valeur par défaut : `us`. |
| `language` | query | string | Non | Code de langue. Valeur par défaut : `en`. |
| `include_domains` | query | string | Non | Liste séparée par des virgules, jusqu’à 20 domaines. |
| `exclude_domains` | query | string | Non | Liste séparée par des virgules, jusqu’à 20 domaines. |
| `api_key` | query | string | Non | Votre clé, lorsque vous n’envoyez pas l’en-tête `Authorization`. |

**Réponse** `200`

```json
{
  "query": "postgres connection pooling",
  "created_at": "2026-10-22T10:21:47Z",
  "credits_used": 1,
  "results": [
    {
      "position": 1,
      "title": "Connection pooling explained",
      "url": "https://docs.example.com/db/pooling",
      "host": "docs.example.com",
      "snippet": "A pool keeps a few database connections open and lends them to requests.",
      "content_status": "not_requested"
    },
    {
      "position": 2,
      "title": "Sizing a connection pool",
      "url": "https://blog.example.org/pool-size",
      "host": "blog.example.org",
      "snippet": "Start small: the right size depends on cores and disk, not on traffic.",
      "published_at": "2026-03-04",
      "content_status": "not_requested"
    }
  ]
}
```

*curl*

```bash
curl -sG "https://llmwebsearch.com/api/v1/search" \
  -H "Authorization: Bearer $LLMWEBSEARCH_API_KEY" \
  --data-urlencode "q=postgres connection pooling" \
  -d max_results=10 -d read=0
```

*Python*

```python
import os
import requests

resp = requests.get(
    "https://llmwebsearch.com/api/v1/search",
    headers={"Authorization": "Bearer " + os.environ["LLMWEBSEARCH_API_KEY"]},
    params={"q": "postgres connection pooling", "max_results": 10, "read": 0},
    timeout=60,
)
print([r["url"] for r in resp.json()["results"]])
```

*Node.js*

```javascript
const params = new URLSearchParams({ q: 'postgres connection pooling', max_results: '10', read: '0' });
const res = await fetch(`https://llmwebsearch.com/api/v1/search?${params}`, {
  headers: { Authorization: `Bearer ${process.env.LLMWEBSEARCH_API_KEY}` },
});
console.log((await res.json()).results.map((r) => r.url));
```

## Comment obtenir des résultats sans aucun contenu de page ?

Définissez `read` sur `0`. Chaque résultat revient alors avec son titre, son URL, son hôte, son snippet et sa date, ainsi que `content_status: "not_requested"`. La réponse est bien plus petite, ce qui aide quand l’agent doit seulement choisir quels liens comptent.

Le prix reste à 1 crédit, comme pour la lecture de 3 pages maximum. Un schéma courant consiste à lancer une recherche `read=0` pour présélectionner, puis à faire un [appel extract](https://llmwebsearch.com/fr/docs/extract/) sur les deux ou trois URLs retenues par le modèle.

## Quand une recherche coûte-t-elle 2 crédits ?

Quand `read` est compris entre 4 et 10. Lire plus de pages demande plus de travail de notre côté, donc le prix double une fois, et reste à 2 crédits jusqu’au maximum de 10 pages.

`credits_used` dans chaque réponse indique ce qu’a coûté l’appel. Une page qui n’a pas pu être lue, à cause d’une règle robots.txt ou d’un refus, ne fait ni baisser ni augmenter ce prix. Si vous n’avez besoin que de quelques pages complètes la plupart du temps, gardez `read` à 3 et appelez `/extract` pour la page supplémentaire occasionnelle.

## Comment rechercher des actualités récentes ?

Envoyez `topic: "news"` et un `time_range`. Les résultats proviennent alors d’articles d’actualité, et `time_range` ne garde que ceux des derniers `day`, `week`, `month` ou `year`. `published_at` est renseigné lorsque l’article ou le résultat de recherche indique une date.

Le même filtre de fraîcheur fonctionne avec `topic: "web"`. Il est utile pour des questions telles que des sorties récentes ou des changements de prix, où une page ancienne induirait le modèle en erreur.

*Actualités de la semaine passée, 3 articles les plus pertinents lus*

```bash
curl -s "https://llmwebsearch.com/api/v1/search" \
  -H "Authorization: Bearer $LLMWEBSEARCH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"q": "database release security fix", "topic": "news", "time_range": "week", "read": 3}'
```

## Comment limiter les résultats à certains sites ?

Listez-les dans `include_domains`, jusqu’à 20 entrées. Seuls les résultats dont l’hôte est l’un de ces domaines, ou l’un de leurs sous-domaines, sont conservés : `example.com` correspond aussi à `docs.example.com`. Utilisez `exclude_domains` dans l’autre sens, par exemple pour exclure votre propre site des résultats.

Dans un corps POST, les deux champs sont des tableaux JSON. Dans une requête GET, écrivez-les comme une seule valeur séparée par des virgules. La requête elle-même peut aussi contenir un opérateur `site:` ; il est transmis à la recherche tel quel.

## Que changent le pays et la langue ?

`country` définit où la recherche est lancée, avec un code à deux lettres tel que `us`, `de` ou `br`. Les classements varient selon le pays, surtout pour les services locaux, les prix et les réglementations. `language` définit la langue des résultats, par exemple `en`, `fr` ou `pt-BR`.

Les deux ont pour valeur par défaut les États-Unis et l’anglais. Définissez-les ensemble quand l’agent travaille pour des utilisateurs d’un même marché : un utilisateur allemand qui pose une question sur les règles fiscales veut `country: "de"` et `language: "de"`.

## Quelle quantité de texte de page est renvoyée ?

Jusqu’à `max_chars` caractères par page, 6 000 par défaut et entre 500 et 50 000. Ce plafond protège la fenêtre de contexte du modèle : trois pages à 6 000 caractères représentent environ 4 500 tokens en anglais.

`word_count` compte tout le texte extrait, avant la troncature, ce qui vous permet de voir quand une page a été coupée. Quand une réponse nécessite un seul long document, faites d’abord une recherche avec un plafond bas, puis récupérez cette page seule via `/extract` avec un plafond plus élevé. Une page lente n’est pas attendue indéfiniment : après 15 secondes, elle revient avec `fetch_timeout`, sans contenu.

## Endpoint de recherche : questions fréquentes

### Faut-il utiliser POST ou GET ?

POST dans le code, car les tableaux JSON et les requêtes longues sont plus simples dans un corps. GET convient à un test rapide dans un terminal ou à un outil qui n’envoie que des chaînes de requête. Les deux renvoient la même réponse et coûtent pareil.

### Puis-je demander plus de 20 résultats ?

Non. 20 est le maximum par appel. Les agents en ont rarement besoin de plus : une seconde recherche avec une requête reformulée apporte généralement de meilleures sources qu’une longue liste.

### Les pages sont-elles lues l’une après l’autre ?

Non, en parallèle. Une page qui ne répond pas dans les 15 secondes est renvoyée sans contenu, avec `fetch_timeout`, pour qu’un site lent ne bloque pas toute la réponse.

### Quel moteur de recherche produit les résultats ?

Les résultats proviennent d'une recherche web lancée au moment de votre appel, dans l'ordre où le moteur de recherche les classe ; rien ne vient d'un ancien index. Nous ne publions pas quels fournisseurs en amont exécutent la recherche.

---

LLMWebSearch: LLMWebSearch est une API de recherche web pour agents IA qui renvoie des résultats classés avec le contenu des meilleures pages en Markdown, payée en crypto sans envoi de pièce d'identité. Les crédits prépayés à partir de 1,20 $US/1K requêtes n'expirent jamais. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payez en crypto.
