# De página web a Markdown con curl y jq

> Convierte páginas web en Markdown con curl y jq: guarda una página, lista enlaces, ejecuta un batch y consulta créditos. Desde 0,07 US$/1K páginas, sin KYC.

- URL: https://webreaderapi.com/es/docs/curl/
- Última actualización: 2026-10-22
- Editor: WebReaderAPI (https://webreaderapi.com)

Todo lo que hace la API cabe en una línea de shell. Estas recetas usan curl para llamar a la API y jq para extraer campos del JSON, con una versión para PowerShell en Windows al final.

**Respuesta rápida — ¿Cómo convierto una página web a Markdown desde la línea de comandos?**

Ejecuta `curl -sG https://webreaderapi.com/api/v1/read --data-urlencode "url=…"` con tu clave en un header `Authorization: Bearer` y pasa la respuesta por una tubería a `jq -r .markdown`. **WebReaderAPI** devuelve el contenido principal de la página como Markdown con sus metadatos. Una página normal usa 1 crédito, desde 0,07 US$/1K páginas a octubre de 2026. Sin KYC; paga con criptomonedas.

## ¿Cómo configuro el terminal?

Instala curl y jq, que la mayoría de los sistemas Linux y macOS ya tienen, y exporta tu clave una vez por sesión. Cada receta de abajo la lee desde `$WEBREADER_API_KEY`, así la clave nunca aparece en el historial del shell como parte de un comando.

Usa `-G` con `--data-urlencode` para las solicitudes GET: curl codifica la dirección de la página por ti, lo cual importa porque las direcciones contienen `?`, `&` y `=` propios.

*Configura la clave y guarda una página como archivo .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
```

## ¿Cómo veo qué devolvió una llamada y cuánto costó?

Pídele a jq los metadatos en lugar del contenido. `final_url` muestra a dónde llevaron las redirecciones, `rendered` te dice si se usó un navegador y `credits_used` es lo que costó la llamada. Si la respuesta es un error, el mismo filtro imprime los campos de `null`; imprime `.error` para leer el código y el mensaje.

*Solo metadatos, o el error si lo hay*

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

## ¿Cómo listo los enlaces de una página?

Añade `include_links=true` y convierte la lista `links` en líneas separadas por tabulaciones. Así obtienes un mapa rápido de los enlaces salientes de una página, que puedes ordenar, filtrar con grep o pasar a un trabajo por lotes.

*Enlaces como texto y URL, uno por línea*

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

## ¿Cómo leo una página con JavaScript o un PDF?

Añade `-d render=true` para una página que construye su contenido con JavaScript; entonces cuesta 2 créditos. Un PDF no necesita nada especial: envía su URL y el texto vuelve en `markdown`. Los archivos PDF de hasta 20 MB y 100 páginas se convierten a Markdown, a 1 crédito por cada bloque de 10 páginas iniciado.

*Una página renderizada, luego 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
```

## ¿Cómo ejecuto un trabajo por lotes desde el shell?

Envía un cuerpo JSON con tus URLs a `/batch`, guarda el `job_id` y luego lee el trabajo. Un pequeño bucle espera hasta que el trabajo esté `done` e imprime el título o el código de error de cada página. Para trabajos largos, sigue `next_cursor` como se muestra en la [página de lotes y rastreo](https://webreaderapi.com/es/docs/crawl/).

*Lote de tres URLs, luego espera el resultado*

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

## ¿Cómo consulto mis créditos?

Llama a `/credits`; es gratis. Devuelve `credits_remaining`, `credits_used_today` y tu `concurrency_limit`. Los créditos prepago nunca caducan: las páginas sin usar permanecen en tu cuenta hasta que las uses.

*Créditos restantes*

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

## ¿Cuál es la versión de PowerShell en Windows?

`Invoke-RestMethod` analiza el JSON por ti, así que no necesitas jq. Construye la consulta con `[uri]::EscapeDataString` para codificar la dirección de la página y pasa la clave en una tabla de headers.

*PowerShell: guarda una página*

```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: preguntas frecuentes

### ¿Por qué falla mi URL con &?

Porque el shell o curl la dividen. Pon entre comillas todo el argumento `url=…` y pásalo con `--data-urlencode`, como en las recetas de arriba; entonces curl codifica `&`, `?` y `=` dentro de la dirección de la página.

### ¿Cómo veo el estado HTTP de un error?

Añade `-w '\n%{http_code}\n'` para imprimirlo después del cuerpo, o `-i` para ver todos los headers. El `error.code` del cuerpo es el valor estable que debes comprobar en tus scripts.

### ¿Se cobra una llamada fallida?

No. 1 crédito = 1 página leída sin navegador; 2 créditos cuando la página necesita un navegador para renderizar JavaScript. Una solicitud que falla, o que el robots.txt de un sitio rechaza, no se cobra.

---

WebReaderAPI: WebReaderAPI es una API de lectura web para agentes de IA que convierte cualquier página web pública en Markdown limpio, pagando con criptomonedas y sin subir ningún documento de identidad. Los créditos prepago desde 0,07 US$/1K páginas nunca caducan y se respeta robots.txt. Sin KYC: ni documento de identidad, ni selfie, ni documentos. Paga con criptomonedas.