# Search-endpoint-referentie: POST en GET /search

> Search-endpoint-referentie: elke parameter van POST en GET /search, van read en max_chars tot topic, time_range en domeinfilters. Zonder KYC, crypto.

- URL: https://llmwebsearch.com/nl/docs/search/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: LLMWebSearch (https://llmwebsearch.com)

`/search` voert een live webzoekopdracht uit, rangschikt tot 20 resultaten en leest de pagina's achter de eerste resultaten. Deze pagina somt elke parameter op, de standaardwaarde, de limieten en wat die doet met de prijs.

**Snel antwoord — Welke parameters accepteert het search-endpoint van LLMWebSearch?**

Het `/search`-endpoint van **LLMWebSearch** heeft alleen `q` nodig. Optionele parameters bepalen hoeveel resultaten er terugkomen (`max_results`), hoeveel pagina's er worden gelezen (`read`), het inhoudsformaat en de lengte, nieuws of web, een tijdbereik, het land en de taal, en domeinen die je wilt behouden of uitsluiten. Tot 3 pagina's lezen kost 1 credit, vanaf US$ 1,20/1K zoekopdrachten per oktober 2026. Zonder KYC; betalen met crypto.

## /search at a glance

| Attribuut | Waarde |
| --- | --- |
| Methoden | `POST` met een JSON-body, of `GET` met dezelfde namen in de query string |
| URL | `https://llmwebsearch.com/api/v1/search` |
| Vereist | `q`: 1 tot 400 tekens; zoekoperatoren worden doorgegeven zoals ze zijn geschreven |
| Standaardwaarden | 5 resultaten, de eerste 3 gelezen, Markdown tot 6.000 tekens per pagina |
| Facturering | Eén credit betaalt één zoekopdracht: tot 20 gerangschikte resultaten, waarbij de pagina's van de eerste 3 worden gelezen en als Markdown teruggegeven. Het lezen van 4 tot 10 pagina's kost 2 credits. Een call die op een fout eindigt, kost niets |
| Resultaten | De resultaten komen uit een live webzoekopdracht die op het moment van je call wordt uitgevoerd, in de volgorde waarin de zoekmachine ze rangschikt; niets komt uit een oude index |
| Filters | Kies het land en de taal van de resultaten, een tijdsbereik (afgelopen dag, week, maand of jaar), web- of nieuwsresultaten, en domeinen die je wilt opnemen of uitsluiten |
| Pagina-lezer | `LLMWebSearch/1.0 (+https://llmwebsearch.com/bot/)` |

## Zoek op het web en lees de topresultaten (POST)

`POST /api/v1/search`

Voert een live webzoekopdracht uit en retourneert gerangschikte resultaten. De pagina's van de eerste `read` resultaten worden parallel opgehaald en hun hoofdinhoud wordt in `content` geretourneerd. Het voorbeeld vraagt hoe je API-sleutels roteert; titels, datums en waarden zijn ter illustratie.

Authenticatie: API-sleutel in de header `Authorization: Bearer API_KEY`.

**Request body**

| Field | Type | Vereist | Beschrijving |
| --- | --- | --- | --- |
| `q` | string | Ja | De zoekopdracht, 1 tot 400 tekens. Aanhalingstekens en operatoren zoals `site:` blijven zoals ze zijn geschreven. |
| `max_results` | integer | Nee | Aantal gerangschikte resultaten, 1 tot 20. Standaard 5. |
| `read` | integer | Nee | Hoeveel van de eerste resultaten worden gelezen en met hun inhoud geretourneerd, 0 tot 10. Standaard 3. Vanaf 4 kost de aanroep 2 credits. |
| `format` | string | Nee | `markdown` (standaard) of `text` voor de paginainhoud. |
| `max_chars` | integer | Nee | Lengtelimiet van de inhoud van elke pagina, 500 tot 50.000 tekens. Standaard 6.000. |
| `topic` | string | Nee | `web` (standaard) of `news`. |
| `time_range` | string | Nee | `day`, `week`, `month` of `year`. Geen standaardwaarde: elke datum. |
| `country` | string | Nee | Tweeletterige landcode (ISO 3166-1 alpha-2) voor waar de zoekopdracht wordt uitgevoerd. Standaard `us`. |
| `language` | string | Nee | Taal van de resultaten, zoals `en`, `de` of `pt-BR`. Standaard `en`. |
| `include_domains` | string[] | Nee | Tot 20 domeinen; alleen resultaten van deze domeinen en hun subdomeinen worden behouden. |
| `exclude_domains` | string[] | Nee | Tot 20 domeinen waarvan de resultaten worden weggelaten. |

*Voorbeeld: 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
}
```

*Voorbeeld: 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
}
```

**Response** `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);
```

## Zoek op het web (GET)

`GET /api/v1/search`

Dezelfde zoekopdracht met de parameters in de query string, URL-gecodeerd. Lijsten zoals `include_domains` worden geschreven als één kommagescheiden waarde. Handig voor een snelle test of voor tools die alleen GET-requests versturen. Het voorbeeld vraagt alleen om resultaten (`read=0`).

Authenticatie: API-sleutel in de header `Authorization: Bearer API_KEY`.

**Parameters**

| Naam | In | Type | Vereist | Beschrijving |
| --- | --- | --- | --- | --- |
| `q` | query | string | Ja | De zoekopdracht, URL-gecodeerd, 1 tot 400 tekens. |
| `max_results` | query | integer | Nee | 1 tot 20. Standaard 5. |
| `read` | query | integer | Nee | 0 tot 10. Standaard 3; 4 of meer kost 2 credits. |
| `format` | query | string | Nee | `markdown` (standaard) of `text`. |
| `max_chars` | query | integer | Nee | 500 tot 50.000 per pagina. Standaard 6.000. |
| `topic` | query | string | Nee | `web` (standaard) of `news`. |
| `time_range` | query | string | Nee | `day`, `week`, `month` of `year`. |
| `country` | query | string | Nee | ISO 3166-1 alpha-2-code. Standaard `us`. |
| `language` | query | string | Nee | Taalcode. Standaard `en`. |
| `include_domains` | query | string | Nee | Door komma's gescheiden lijst, tot 20 domeinen. |
| `exclude_domains` | query | string | Nee | Door komma's gescheiden lijst, tot 20 domeinen. |
| `api_key` | query | string | Nee | Je API-sleutel, als je de header `Authorization` niet meestuurt. |

**Response** `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));
```

## Hoe krijg ik resultaten zonder enige paginainhoud?

Zet `read` op `0`. Elk resultaat komt dan terug met de titel, URL, host, snippet en datum, en `content_status: "not_requested"`. De response is veel kleiner, wat helpt wanneer de agent alleen hoeft te bepalen welke links relevant zijn.

De prijs blijft 1 credit, hetzelfde als het lezen van maximaal 3 pagina's. Een veelvoorkomend patroon is een zoekopdracht met `read=0` om een shortlist te maken, en daarna een [extract-aanroep](https://llmwebsearch.com/nl/docs/extract/) op de twee of drie URL's die het model heeft gekozen.

## Wanneer kost een zoekopdracht 2 credits?

Wanneer `read` tussen 4 en 10 ligt. Meer pagina's lezen kost meer werk aan onze kant, dus de prijs verdubbelt één keer en blijft op 2 credits tot het maximum van 10 pagina's.

`credits_used` in elke response laat zien wat de aanroep heeft gekost. Een pagina die niet kon worden gelezen, door een robots.txt-regel of een weigering, verlaagt of verhoogt die prijs niet. Als je meestal maar een paar volledige pagina's nodig hebt, houd dan `read` op 3 en roep `/extract` aan voor de spaarzame extra pagina.

## Hoe zoek ik recent nieuws?

Stuur `topic: "news"` en een `time_range` mee. De resultaten komen dan uit nieuwsartikelen, en `time_range` houdt alleen die uit de afgelopen `day`, `week`, `month` of `year`. `published_at` wordt ingevuld wanneer het artikel of het zoekresultaat een datum vermeldt.

Dezelfde freshness-filter werkt met `topic: "web"`. Het is nuttig voor vragen zoals recente releases of prijswijzigingen, waar een oude pagina het model zou misleiden.

*Nieuws van de afgelopen week, top 3 artikelen gelezen*

```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}'
```

## Hoe beperk ik resultaten tot bepaalde sites?

Zet ze in `include_domains`, tot 20 items. Alleen resultaten waarvan de host een van die domeinen is, of een van hun subdomeinen, worden behouden: `example.com` matcht ook `docs.example.com`. Gebruik `exclude_domains` andersom, bijvoorbeeld om je eigen site uit de resultaten te halen.

In een POST-body zijn beide velden JSON-arrays. In een GET-verzoek schrijf je ze als één door komma's gescheiden waarde. De zoekopdracht zelf kan ook een operator `site:` bevatten; die wordt zoals geschreven doorgegeven aan de zoekopdracht.

## Wat veranderen land en taal?

`country` bepaalt waar de zoekopdracht draait, met een tweeletterige code zoals `us`, `de` of `br`. Rangschikkingen verschillen per land, vooral voor lokale diensten, prijzen en regelgeving. `language` bepaalt de taal van de resultaten, zoals `en`, `fr` of `pt-BR`.

Beide staan standaard op de Verenigde Staten en Engels. Zet ze samen wanneer de agent werkt voor gebruikers in één markt: een Duitse gebruiker die naar belastingregels vraagt, wil `country: "de"` en `language: "de"`.

## Hoeveel paginatekst komt er terug?

Tot `max_chars` tekens per pagina, standaard 6.000 en overal tussen 500 en 50.000. De limiet beschermt het contextvenster van het model: drie pagina's van 6.000 tekens is ongeveer 4.500 tokens Engels.

`word_count` telt de volledig geëxtraheerde tekst, vóór de afkap, zodat je kunt zien wanneer een pagina is ingekort. Wanneer een antwoord één lang document nodig heeft, zoek dan eerst met een lage limiet en haal die pagina daarna apart op via `/extract` met een hogere limiet. Op een trage pagina wordt niet eindeloos gewacht: na 15 seconden komt die terug als `fetch_timeout`, zonder inhoud.

## Search-endpoint: veelgestelde vragen

### Moet ik POST of GET gebruiken?

POST in code, omdat JSON-arrays en lange zoekopdrachten eenvoudiger zijn in een body. GET is geschikt voor een snelle test in een terminal of een tool die alleen query strings verstuurt. Beide retourneren dezelfde response en kosten hetzelfde.

### Kan ik om meer dan 20 resultaten vragen?

Nee. 20 is het maximum per aanroep. Agents hebben zelden meer nodig: een tweede zoekopdracht met een herformuleerde query levert meestal betere bronnen op dan een lange lijst.

### Worden de pagina's na elkaar gelezen?

Nee, parallel. Een pagina die niet binnen 15 seconden antwoordt, wordt zonder inhoud teruggegeven, als `fetch_timeout`, zodat één trage site niet de hele response ophoudt.

### Welke zoekmachine levert de resultaten?

De resultaten komen uit een live webzoekopdracht die op het moment van je call wordt uitgevoerd, in de volgorde waarin de zoekmachine ze rangschikt; niets komt uit een oude index. We publiceren niet welke upstream-providers de zoekopdracht uitvoeren.

---

LLMWebSearch: LLMWebSearch is een webzoek-API voor AI-agents die gerangschikte resultaten teruggeeft met de inhoud van de belangrijkste pagina's als Markdown, betaald met crypto zonder ID-upload. Voorafbetaalde credits vanaf US$ 1,20/1K zoekopdrachten verlopen nooit. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.