# Pagina web in Markdown con curl e jq

> Converti pagine web in Markdown dal terminale con curl e jq: salva pagine, elenca link, esegui batch. Con 0,07 USD/1K pagine, senza KYC.

- URL: https://webreaderapi.com/it/docs/curl/
- Ultimo aggiornamento: 2026-10-22
- Editore: WebReaderAPI (https://webreaderapi.com)

Tutto ciò che fa l'API sta in un one-liner da shell. Queste ricette usano curl per chiamare l'API e jq per estrarre i campi dal JSON, con una versione PowerShell per Windows alla fine.

**Risposta rapida — Come faccio a convertire una pagina web in Markdown dalla riga di comando?**

Esegui `curl -sG https://webreaderapi.com/api/v1/read --data-urlencode "url=…"` con la tua chiave in un header `Authorization: Bearer`, poi passa la risposta a `jq -r .markdown`. **WebReaderAPI** restituisce il contenuto principale della pagina come Markdown con i suoi metadati. Una pagina semplice usa 1 credito, da 0,07 USD/1K pagine a ottobre 2026. Senza KYC; paghi in criptovalute.

## Come configuro il terminale?

Installa curl e jq, che la maggior parte dei sistemi Linux e macOS ha già, ed esporta la tua chiave una volta per sessione. Ogni ricetta qui sotto la legge da `$WEBREADER_API_KEY`, così la chiave non compare mai nella cronologia della shell come parte di un comando.

Usa `-G` con `--data-urlencode` per le richieste GET: curl codifica l'indirizzo della pagina per te, cosa che conta perché gli indirizzi contengono `?`, `&` e `=` propri.

*Imposta la chiave e salva una pagina come file .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
```

## Come vedo cosa ha restituito una chiamata e quanto è costata?

Chiedi a jq i metadati invece del contenuto. `final_url` mostra dove hanno portato i redirect, `rendered` ti dice se è stato usato un browser, e `credits_used` è quanto è costata la chiamata. Se la risposta è un errore, lo stesso filtro stampa i campi `null`; stampa `.error` per leggere il codice e il messaggio.

*Solo i metadati, o l'errore se c'è*

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

## Come elenco i link di una pagina?

Aggiungi `include_links=true` e trasforma la lista `links` in righe separate da tabulazione. Ottieni così una mappa rapida dei link in uscita di una pagina, che puoi ordinare, filtrare con grep o passare a un job in batch.

*Link come testo e URL, uno per riga*

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

## Come leggo una pagina JavaScript o un PDF?

Aggiungi `-d render=true` per una pagina che costruisce il suo contenuto con JavaScript; costa quindi 2 crediti. Un PDF non richiede nulla di speciale: invia il suo URL e il testo torna in `markdown`. I file PDF fino a 20 MB e 100 pagine vengono convertiti in Markdown, a 1 credito per ogni blocco di 10 pagine iniziato.

*Una pagina renderizzata, poi 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
```

## Come eseguo un job in batch dalla shell?

Invia un body JSON con i tuoi URL a `/batch`, conserva il `job_id`, poi leggi il job. Un piccolo loop attende finché il job è `done` e stampa il titolo o il codice di errore di ogni pagina. Per i job lunghi, segui `next_cursor` come mostrato nella [pagina batch e crawl](https://webreaderapi.com/it/docs/crawl/).

*Batch di tre URL, poi attendi il risultato*

```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)"'
```

## Come controllo i miei crediti?

Chiama `/credits`; è gratuito. Restituisce `credits_remaining`, `credits_used_today` e il tuo `concurrency_limit`. I crediti prepagati non scadono mai: le pagine non utilizzate restano sul tuo account finché non le usi.

*Crediti rimanenti*

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

## Qual è la versione PowerShell su Windows?

`Invoke-RestMethod` analizza il JSON per te, quindi jq non serve. Costruisci la query con `[uri]::EscapeDataString` per codificare l'indirizzo della pagina, e passa la chiave in una tabella headers.

*PowerShell: salva una pagina*

```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: domande frequenti

### Perché il mio URL con & fallisce?

Perché la shell o curl lo dividono. Metti tra virgolette l'intero argomento `url=…` e passalo con `--data-urlencode`, come nelle ricette sopra; curl poi codifica `&`, `?` e `=` dentro l'indirizzo della pagina.

### Come vedo lo stato HTTP di un errore?

Aggiungi `-w '\n%{http_code}\n'` per stamparlo dopo il body, oppure `-i` per vedere tutti gli header. Il `error.code` del body è il valore stabile da testare negli script.

### Una chiamata fallita viene fatturata?

No. 1 credito = 1 pagina letta senza browser; 2 crediti quando la pagina richiede un browser per eseguire JavaScript. Una richiesta che fallisce, o che il robots.txt di un sito rifiuta, non viene addebitata.

---

WebReaderAPI: WebReaderAPI è un'API web reader per agenti AI che converte qualsiasi pagina web pubblica in Markdown pulito, con pagamento in criptovalute e senza caricare documenti d'identità. I crediti prepagati da 0,07 USD/1K pagine non scadono mai e robots.txt viene rispettato. Senza KYC — niente documento, niente selfie, niente documenti. Paga in criptovalute.