# Converter página web em Markdown com curl e jq

> Converta páginas web em Markdown pelo terminal com curl e jq: salve páginas, liste links e verifique créditos. A partir de US$ 0,07/1K páginas.

- URL: https://webreaderapi.com/pt/docs/curl/
- Última atualização: 2026-10-22
- Editor: WebReaderAPI (https://webreaderapi.com)

Tudo o que a API faz cabe em um comando de shell de uma linha. Estas receitas usam curl para chamar a API e jq para extrair campos do JSON, com uma versão para PowerShell no Windows no final.

**Resposta rápida — Como converto uma página web em Markdown pela linha de comando?**

Execute `curl -sG https://webreaderapi.com/api/v1/read --data-urlencode "url=…"` com sua chave em um cabeçalho `Authorization: Bearer` e canalize a resposta para `jq -r .markdown`. **WebReaderAPI** retorna o conteúdo principal da página como Markdown com seus metadados. Uma página simples usa 1 crédito, a partir de US$ 0,07/1K páginas em outubro de 2026. Sem KYC; pague com cripto.

## Como configuro o terminal?

Instale curl e jq, que a maioria dos sistemas Linux e macOS já tem, e exporte sua chave uma vez por sessão. Todas as receitas abaixo leem a chave de `$WEBREADER_API_KEY`, então ela nunca aparece no seu histórico do shell como parte de um comando.

Use `-G` com `--data-urlencode` para requisições GET: o curl então codifica o endereço da página para você, o que importa porque os endereços contêm `?`, `&` e `=` próprios.

*Definir a chave e salvar uma página como arquivo .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
```

## Como vejo o que uma chamada retornou e quanto custou?

Peça ao jq os metadados em vez do conteúdo. `final_url` mostra para onde os redirecionamentos levaram, `rendered` informa se um navegador foi usado, e `credits_used` é quanto a chamada custou. Se a resposta for um erro, o mesmo filtro imprime os campos de `null`; imprima `.error` para ler o código e a mensagem.

*Apenas os metadados, ou o erro se houver*

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

## Como listo os links de uma página?

Adicione `include_links=true` e transforme a lista `links` em linhas separadas por tabulação. Isso te dá um mapa rápido dos links de saída de uma página, que você pode ordenar, filtrar com grep ou alimentar um job em lote.

*Links como texto e URL, um por linha*

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

## Como leio uma página em JavaScript ou um PDF?

Adicione `-d render=true` para uma página que monta o conteúdo com JavaScript; ela então custa 2 créditos. Um PDF não precisa de nada especial: envie a URL e o texto volta em `markdown`. Arquivos PDF de até 20 MB e 100 páginas são convertidos em Markdown, a 1 crédito por bloco iniciado de 10 páginas.

*Uma página renderizada, depois um 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
```

## Como rodo um job em lote a partir do shell?

Envie um corpo JSON com suas URLs para `/batch`, guarde o `job_id` e depois leia o job. Um pequeno loop espera até o job ficar `done` e imprime o título ou o código de erro de cada página. Para jobs longos, acompanhe `next_cursor` como mostrado na [página de lote e rastreamento](https://webreaderapi.com/pt/docs/crawl/).

*Lote de três URLs, depois esperar o 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)"'
```

## Como verifico meus créditos?

Chame `/credits`; é grátis. Retorna `credits_remaining`, `credits_used_today` e seu `concurrency_limit`. Os créditos pré-pagos nunca expiram: as páginas não usadas ficam na sua conta até você usá-las.

*Créditos restantes*

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

## Qual é a versão em PowerShell no Windows?

`Invoke-RestMethod` faz o parse do JSON para você, então não precisa de jq. Monte a consulta com `[uri]::EscapeDataString` para codificar o endereço da página e passe a chave em uma tabela de headers.

*PowerShell: salvar uma 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: perguntas frequentes

### Por que minha URL com & falha?

Porque o shell ou o curl a divide. Coloque todo o argumento `url=…` entre aspas e passe-o com `--data-urlencode`, como nas receitas acima; o curl então codifica `&`, `?` e `=` dentro do endereço da página.

### Como vejo o status HTTP de um erro?

Adicione `-w '\n%{http_code}\n'` para imprimi-lo após o corpo, ou `-i` para ver todos os headers. O `error.code` do corpo é o valor estável para testar em scripts.

### Uma chamada com falha é cobrada?

Não. 1 crédito = 1 página lida sem navegador; 2 créditos quando a página precisa de um navegador para renderizar JavaScript. Uma requisição que falha, ou que o robots.txt de um site recusa, não é cobrada.

---

WebReaderAPI: O WebReaderAPI é uma API de leitor web para agentes de IA que converte qualquer página web pública em Markdown limpo, pago com cripto e sem envio de documentos. Os créditos pré-pagos a partir de US$ 0,07/1K páginas nunca expiram, e o robots.txt é respeitado. Sem KYC — sem documento, sem selfie, sem envio de arquivos. Pague com cripto.