# Extract endpoint: leggi gli URL che il tuo agente ha già

> Endpoint Extract: invia da 1 a 20 URL che hai già e ricevi il contenuto principale di ogni pagina in Markdown, 1 credito per ogni 3 URL. Senza KYC, cripto.

- URL: https://llmwebsearch.com/it/docs/extract/
- Ultimo aggiornamento: 2026-10-22
- Editore: LLMWebSearch (https://llmwebsearch.com)

A volte l'agente ha già i link: un utente li ha incollati, una ricerca precedente li ha elencati o un documento li cita. `/extract` legge quelle pagine e ne restituisce il contenuto principale, con lo stesso reader e le stesse regole di `/search`.

**Risposta rapida — Come leggo pagine web di cui ho già gli URL?**

Invia fino a 20 URL a `POST https://llmwebsearch.com/api/v1/extract`. **LLMWebSearch** legge ogni pagina pubblica e ne restituisce il contenuto principale in Markdown o testo semplice, con uno stato per ogni URL. La fatturazione è di 1 credito per ogni gruppo di 3 pagine lette iniziato, da 1,20 USD/1K ricerche per credito di ricerca a ottobre 2026. robots.txt viene rispettato. Senza KYC; paghi in criptovalute.

## /extract at a glance

| Attributo | Valore |
| --- | --- |
| Metodo | `POST` con un body JSON |
| URL | `https://llmwebsearch.com/api/v1/extract` |
| Input | `urls`: da 1 a 20 indirizzi http o https |
| Output | Contenuto principale per URL, in `markdown` (predefinito) o `text` |
| Fatturazione | Leggere pagine di cui hai già gli URL costa 1 credito per ogni gruppo iniziato di 3 pagine restituite con contenuto, fino a 20 URL per chiamata; gli URL rifiutati o falliti non vengono contati |
| robots.txt | Il nostro reader rispetta robots.txt: si presenta come LLMWebSearch, segue le regole che un sito scrive per lui o per tutti i robot, e lascia fuori il contenuto di qualsiasi pagina che non gli è permesso leggere |
| Page reader | `LLMWebSearch/1.0 (+https://llmwebsearch.com/bot/)` |

## Leggi una lista di URL

`POST /api/v1/extract`

Recupera ogni URL in parallelo e restituisce il contenuto principale, nell'ordine in cui li hai inviati. Ogni elemento ha il proprio `content_status`, così una pagina rifiutata non fa fallire la chiamata. L'esempio legge tre pagine; titoli e valori sono illustrativi.

Autenticazione: chiave API nell'header `Authorization: Bearer API_KEY`.

**Body della richiesta**

| Campo | Tipo | Obbligatorio | Descrizione |
| --- | --- | --- | --- |
| `urls` | string[] | Sì | Da 1 a 20 indirizzi http o https. Gli indirizzi privati, locali e di metadata cloud vengono rifiutati. |
| `format` | string | No | `markdown` (predefinito) o `text`. |
| `max_chars` | integer | No | Limite di lunghezza del contenuto di ogni pagina, da 500 a 50.000 caratteri. Predefinito 6.000. |

*Esempio: three pages, longer content*

```json
{
  "urls": [
    "https://docs.example.com/security/key-rotation",
    "https://blog.example.org/key-rotation-checklist",
    "https://example.com/changelog"
  ],
  "max_chars": 20000
}
```

**Risposta** `200`

```json
{
  "credits_used": 1,
  "results": [
    {
      "url": "https://docs.example.com/security/key-rotation",
      "title": "Rotating API keys",
      "content_status": "ok",
      "content": "# Rotating API keys\n\n## Zero-downtime rotation\n\n1. Create a second key...",
      "word_count": 948
    },
    {
      "url": "https://blog.example.org/key-rotation-checklist",
      "content_status": "blocked_by_robots"
    },
    {
      "url": "https://example.com/changelog",
      "title": "Changelog",
      "content_status": "ok",
      "content": "# Changelog\n\n## 2026-10-20\n\n- New export format...",
      "word_count": 2204
    }
  ]
}
```

*curl*

```bash
curl -s "https://llmwebsearch.com/api/v1/extract" \
  -H "Authorization: Bearer $LLMWEBSEARCH_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["https://docs.example.com/security/key-rotation", "https://example.com/changelog"], "max_chars": 20000}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://llmwebsearch.com/api/v1/extract",
    headers={"Authorization": "Bearer " + os.environ["LLMWEBSEARCH_API_KEY"]},
    json={"urls": ["https://docs.example.com/security/key-rotation", "https://example.com/changelog"]},
    timeout=60,
)
for page in resp.json()["results"]:
    print(page["url"], page["content_status"], page.get("word_count", 0))
```

*Node.js*

```javascript
const res = await fetch('https://llmwebsearch.com/api/v1/extract', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.LLMWEBSEARCH_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ urls: ['https://docs.example.com/security/key-rotation', 'https://example.com/changelog'] }),
});
for (const page of (await res.json()).results) console.log(page.url, page.content_status);
```

## Quando devo usare extract invece di read in una ricerca?

Usa extract quando gli URL non provengono dalla ricerca che stai eseguendo. Un utente incolla un link, un documento cita tre fonti, oppure una prima ricerca con `read=0` ha permesso al modello di scegliere quali pagine meritano una lettura completa.

Usa `read` dentro `/search` quando vuoi semplicemente leggere i risultati principali nella stessa chiamata. È una sola richiesta invece di due, e fino a 3 pagine sono incluse nel singolo credito della ricerca.

## Come vengono fatturate le chiamate extract?

Un credito per ogni gruppo di 3 pagine lette iniziato. Il conteggio usa le pagine che tornano con contenuto: un URL rifiutato da robots.txt o dal sito, o che non si carica, non viene contato.

| Pagine lette | Crediti |
|---|---|
| da 1 a 3 | 1 |
| da 4 a 6 | 2 |
| da 7 a 9 | 3 |
| 19 o 20 | 7 |

La risposta indica sempre il totale in `credits_used`. Una chiamata in cui nessuna pagina è stata letta non costa nulla.

## Cosa mi dice ogni elemento della risposta?

Ogni elemento ripete il `url` che hai inviato e fornisce un `content_status`. Con `ok` ottieni anche la pagina `title`, il suo `content` principale e i suoi `word_count`. Altrimenti lo status indica il motivo: `blocked_by_robots`, `blocked_by_site_policy`, `target_refused` con `target_status` del sito, `fetch_failed`, `fetch_timeout` o `unsupported_content`.

Gli elementi mantengono l'ordine della tua lista `urls`, così puoi abbinarli sia per indice che per URL. La pagina [formato della risposta](https://llmwebsearch.com/it/docs/response/) descrive ogni status.

## Quali URL vengono rifiutati prima di qualsiasi fetch?

Gli indirizzi che puntano a reti private, alla macchina locale o a servizi di metadata cloud vengono rifiutati. Questo impedisce a chiunque di usare il nostro reader per raggiungere sistemi interni. Viene rifiutato anche un redirect che porta a un indirizzo di questo tipo, e vengono seguiti al massimo 5 redirect.

L'indirizzo deve usare `http` o `https`. Una chiamata in cui `urls` è vuoto, contiene più di 20 voci o include un indirizzo malformato restituisce `400 invalid_parameter`, senza costi.

## extract segue le stesse regole della ricerca?

Sì. È lo stesso reader, che si presenta come `LLMWebSearch/1.0 (+https://llmwebsearch.com/bot/)`. Un sito che imposta Content-Signal: ai-input=no nel suo robots.txt tiene le sue pagine fuori dal contenuto dei tuoi risultati. Quando un sito respinge il nostro reader, il risultato torna senza contenuto e con lo status del sito: non risolviamo mai CAPTCHA, non accediamo agli account e non aggiriamo un blocco o un paywall.

Le pagine che richiedono un login, o che stanno dietro un paywall, tornano senza contenuto. Indica all'agente un'altra fonte, oppure una pagina che puoi leggere con la tua sessione del browser.

## Endpoint extract: domande frequenti

### Quali tipi di file può leggere?

Le pagine web sono ciò per cui è costruito. Un link a un video, a un archivio o a un altro file senza testo leggibile torna come `unsupported_content`, e quell'URL non viene conteggiato nel prezzo.

### Un URL inviato due volte viene letto due volte?

Invia ogni URL una sola volta. Se una lista può contenere duplicati, rimuovili prima dalla tua parte, così i risultati corrispondono alla tua lista uno a uno.

### Il rendering JavaScript ha un costo extra?

No. Quando una pagina richiede un browser per mostrare il suo testo, viene renderizzata senza costi aggiuntivi.

### extract può leggere una pagina a cui sono loggato?

No. Il reader non accede mai agli account e non invia tuoi cookie. Quando un sito respinge il nostro reader, il risultato torna senza contenuto e con lo status del sito: non risolviamo mai CAPTCHA, non accediamo agli account e non aggiriamo un blocco o un paywall.

---

LLMWebSearch: LLMWebSearch è un'API di ricerca web per agenti AI che restituisce risultati classificati con il contenuto delle pagine principali in Markdown, pagata in criptovalute senza caricare documenti d'identità. I crediti prepagati da 1,20 USD/1K ricerche non scadono mai. Senza KYC — niente documento, niente selfie, niente documenti. Paghi in criptovalute.