# Dokumentacja endpointu read: GET i POST /read

> Dokumentacja endpointu read: każdy parametr GET i POST /read, od format i render po country i max_chars, z przykładami. Od 0,07 USD/1K stron, bez KYC.

- URL: https://webreaderapi.com/pl/docs/read/
- Ostatnia aktualizacja: 2026-10-22
- Wydawca: WebReaderAPI (https://webreaderapi.com)

`/read` pobiera jedną publiczną stronę, wyodrębnia jej główną treść i zwraca ją jako Markdown, czysty tekst lub oczyszczony HTML. Ta strona wymienia każdy parametr, jego wartość domyślną i koszt.

**Szybka odpowiedź — Jakie parametry przyjmuje endpoint read WebReaderAPI?**

Endpoint `/read` w **WebReaderAPI** wymaga jednego parametru, `url`. Opcjonalne wybierają wynik (`format`), ile strony zachować (`main_content`), czy uruchomić przeglądarkę (`render`), linki i obrazy, kraj odczytu, limit znaków i timeout. Zwykła strona kosztuje 1 kredyt, 2 z przeglądarką, od 0,07 USD/1K stron według stanu na październik 2026. Bez KYC; płatność kryptowalutą.

## /read at a glance

| Atrybut | Wartość |
| --- | --- |
| Metody | `GET` z parametrami zapytania lub `POST` z ciałem JSON używającym tych samych nazw |
| URL | `https://webreaderapi.com/api/v1/read` |
| Wymagane | `url`: adres http lub https, do 2 048 znaków |
| Domyślny wynik | Markdown głównej treści |
| Rozliczanie | 1 kredyt = 1 odczytana strona bez przeglądarki; 2 kredyty, gdy strona wymaga przeglądarki do wyrenderowania JavaScript. Zapytanie, które się nie powiedzie lub które zostanie odrzucone przez robots.txt witryny, nie jest obciążane opłatą |
| Kraj | Wybór kraju, z którego czytana jest strona, dolicza 10 kredytów, ponieważ strona jest wtedy czytana przez połączenie rezydencjalne w tym kraju |
| PDF | Pliki PDF do 20 MB i 100 stron są konwertowane do Markdown, po 1 kredycie za każdy rozpoczęty blok 10 stron |
| Tożsamość crawlera | `WebReaderAPI/1.0 (+https://webreaderapi.com/bot/)` |

## Odczyt jednej strony (GET)

`GET /api/v1/read`

Pobiera jedną publiczną stronę i zwraca jej główną treść jako Markdown wraz z metadanymi strony. Parametry trafiają do query stringa, zakodowane URL-em. Przykład odczytuje wpis na blogu; identyfikatory, daty i wartości są przykładowe.

Uwierzytelnianie: klucz API w nagłówku `Authorization: Bearer API_KEY`.

**Parametry**

| Nazwa | W | Typ | Wymagane | Opis |
| --- | --- | --- | --- | --- |
| `url` | query | string | Tak | Strona do odczytu: http lub https, maksymalnie 2 048 znaków. Adresy prywatne, lokalne i metadanych chmurowych są odrzucane. |
| `format` | query | string | Nie | `markdown` (domyślnie), `text` (czysty tekst, bez znaczników) lub `html` (oczyszczony HTML treści). |
| `main_content` | query | boolean | Nie | `true` (domyślnie) zachowuje tylko artykuł lub główną treść; `false` konwertuje całą stronę, łącznie z menu i stopką. |
| `render` | query | string | Nie | `auto` (domyślnie) uruchamia przeglądarkę tylko wtedy, gdy surowy HTML zawiera zbyt mało tekstu; `true` zawsze; `false` nigdy. Wyrenderowana strona kosztuje 2 kredyty. |
| `include_links` | query | boolean | Nie | `true` dodaje listę `links` z `{url, text}`. Domyślnie `false`. |
| `include_images` | query | boolean | Nie | `true` zachowuje obrazy jako `![alt](src)` w Markdown. Domyślnie `false`. |
| `country` | query | string | Nie | Dwuliterowy kod kraju (ISO 3166-1 alpha-2). Strona jest odczytywana z adresu w tym kraju, za 10 dodatkowych kredytów (połączenie rezydencjalne). |
| `max_chars` | query | integer | Nie | Obcina wynik na tej liczbie znaków, od 1 000 do 500 000. Przydatne, aby zmieścić się w kontekście modelu. |
| `timeout` | query | integer | Nie | Liczba sekund oczekiwania na stronę, od 5 do 60. Domyślnie 30. |
| `api_key` | query | string | Nie | Twój klucz, jeśli nie wysyłasz nagłówka `Authorization`. |

**Odpowiedź** `200`

```json
{
  "url": "https://example.com/blog/first-post",
  "final_url": "https://example.com/blog/first-post",
  "status_code": 200,
  "fetched_at": "2026-10-22T09:41:12Z",
  "rendered": false,
  "credits_used": 1,
  "title": "Our first post",
  "description": "Why we started this blog and what comes next.",
  "language": "en",
  "author": "Jane Doe",
  "published_at": "2026-10-01",
  "site_name": "Example Blog",
  "markdown": "# Our first post\n\nWe started this blog to share what we learn...\n\n## What comes next\n\n- A post every month\n- Notes from our team",
  "word_count": 612
}
```

*curl*

```bash
curl -sG "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  --data-urlencode "url=https://example.com/blog/first-post" \
  -d format=markdown -d max_chars=20000
```

*Python*

```python
import os
import requests

resp = requests.get(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    params={"url": "https://example.com/blog/first-post", "max_chars": 20000},
    timeout=70,
)
resp.raise_for_status()
print(resp.json()["markdown"][:300])
```

*Node.js*

```javascript
const params = new URLSearchParams({ url: 'https://example.com/blog/first-post', max_chars: '20000' });
const res = await fetch(`https://webreaderapi.com/api/v1/read?${params}`, {
  headers: { Authorization: `Bearer ${process.env.WEBREADER_API_KEY}` },
});
const page = await res.json();
console.log(page.markdown.slice(0, 300));
```

## Odczyt jednej strony (POST)

`POST /api/v1/read`

Ten sam endpoint, te same parametry, wysłane jako treść JSON. Wybierz POST, gdy URL jest bardzo długi lub gdy Twój klient HTTP łatwiej buduje JSON niż łańcuchy zapytań. Odpowiedź jest identyczna jak w formie GET.

Uwierzytelnianie: klucz API w nagłówku `Authorization: Bearer API_KEY`.

**Treść zapytania**

| Pole | Typ | Wymagane | Opis |
| --- | --- | --- | --- |
| `url` | string | Tak | Strona do odczytu. |
| `format`, `main_content`, `render`, `include_links`, `include_images`, `country`, `max_chars`, `timeout` | mixed | Nie | Jak w tabeli GET powyżej, z typami JSON: wartości logiczne jako `true`/`false`, liczby bez cudzysłowów. |

*Przykład: a JavaScript-heavy page, read from Germany, with its links*

```json
{
  "url": "https://example.com/app/pricing",
  "render": "true",
  "country": "de",
  "include_links": true,
  "max_chars": 30000
}
```

**Odpowiedź** `200`

```json
{
  "url": "https://example.com/app/pricing",
  "final_url": "https://example.com/de/app/pricing",
  "status_code": 200,
  "fetched_at": "2026-10-22T09:44:03Z",
  "rendered": true,
  "credits_used": 3,
  "title": "Pricing",
  "language": "de",
  "markdown": "# Pricing\n\n| Plan | Price |\n|---|---|\n| Basic | ... |",
  "word_count": 214,
  "links": [
    {
      "url": "https://example.com/de/contact",
      "text": "Contact"
    }
  ]
}
```

*curl*

```bash
curl -s "https://webreaderapi.com/api/v1/read" \
  -H "Authorization: Bearer $WEBREADER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://example.com/app/pricing", "render": "true", "country": "de", "include_links": true}'
```

*Python*

```python
import os
import requests

resp = requests.post(
    "https://webreaderapi.com/api/v1/read",
    headers={"Authorization": "Bearer " + os.environ["WEBREADER_API_KEY"]},
    json={"url": "https://example.com/app/pricing", "render": "true", "country": "de", "include_links": True},
    timeout=70,
)
print(resp.json()["credits_used"], "credits")
```

*Node.js*

```javascript
const res = await fetch('https://webreaderapi.com/api/v1/read', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.WEBREADER_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ url: 'https://example.com/app/pricing', render: 'true', country: 'de', include_links: true }),
});
console.log((await res.json()).credits_used);
```

## Który format wyjściowy wybrać?

Wybierz `markdown` dla modeli językowych i RAG: nagłówki, listy, tabele i linki zostają, a tekst pozostaje zwięzły. Wybierz `text`, gdy tylko liczysz słowa, klasyfikujesz lub wyszukujesz, a znaczniki byłyby szumem. Wybierz `html`, gdy Twój własny pipeline już parsuje HTML i chcesz tylko pozbyć się zbędnych elementów.

Pola metadanych są takie same we wszystkich trzech formatach. Zmienia się tylko nazwa pola treści: `markdown`, `text` lub `html`.

## Kiedy ustawić main_content na false?

Ustaw `false`, gdy potrzebujesz części wokół artykułu. Przykłady to nawigacja strony do zmapowania jej sekcji, stopka z danymi prawnymi lub kontaktowymi albo strona produktu, której specyfikacja znajduje się w panelu bocznym.

Przy domyślnym `true` ekstraktor zachowuje główny blok treści i usuwa nawigację, banery cookie, reklamy, przyciski udostępniania i stopki. Tego właśnie chcą większość agentów i pipeline'ów RAG, a często zmniejsza to stronę do ułamka jej rozmiaru HTML.

## Jak render=auto decyduje o użyciu przeglądarki?

Najpierw pobiera surowy HTML, co jest szybkie i kosztuje 1 kredyt. Jeśli ten HTML zawiera zbyt mało czytelnego tekstu, typowo aplikacja budująca stronę w JavaScript, ładuje stronę ponownie w przeglądarce headless i wywołanie kosztuje 2 kredyty. Odpowiedź mówi, która ścieżka została użyta: `rendered` to `true` lub `false`.

Ustaw `render=false`, gdy wiesz, że strona serwuje pełny HTML i chcesz stały koszt. Ustaw `render=true` dla aplikacji jednostronicowych, aby pominąć pierwszą próbę.

## Co zmieniają country i max_chars?

`country` odczytuje stronę z adresu w podanym kraju, z tym samym User-Agent. Użyj go dla stron, których ceny, język lub dostępność zmieniają się w zależności od kraju. Dodaje 10 kredytów, ponieważ strona jest wtedy odczytywana przez połączenie residential, i nie można go użyć z krajami, w których usługa nie działa.

`max_chars` obcina wynik po podanej liczbie znaków. Nie zmienia ceny, ale chroni okno kontekstu agenta: 20 000 znaków to rozsądna wartość domyślna dla pojedynczej strony przekazywanej modelowi.

## Czy /read obsługuje pliki PDF?

Tak. Gdy URL zwraca PDF, tekst wraca jako Markdown w tym samym polu `markdown`. Pliki PDF do 20 MB i 100 stron są konwertowane do Markdown, po 1 kredycie za każdy rozpoczęty blok 10 stron. Zeskanowane PDF-y bez warstwy tekstowej zwracają mało tekstu lub wcale, ponieważ nie ma etapu rozpoznawania znaków.

## Endpoint read: najczęstsze pytania

### Czy /read podąża za przekierowaniami?

Tak, maksymalnie 5. Odpowiedź podaje adres, o który prosiłeś, w `url` i adres faktycznie odczytany w `final_url`. Przekierowanie na adres prywatny lub lokalny jest odrzucane.

### Czy mogę odczytać stronę wymagającą logowania?

Nie. Jeśli witryna odrzuci nasze zapytanie, zwracamy jej odpowiedź: nigdy nie rozwiązujemy CAPTCHA, nie logujemy się do kont ani nie próbujemy obejść blokady lub paywalla. Strony za logowaniem lub paywallem zwracają odmowę serwisu, a wywołanie jest bezpłatne.

### Czy sprawdzenie robots.txt odbywa się przy każdym wywołaniu?

Tak, na kopii robots.txt strony, która ma najwyżej 24 godziny. Zablokowany URL zwraca `403 blocked_by_robots` i nie zużywa kredytu.

### Ile stron mogę odczytać jednocześnie?

Każde konto ma limit liczby stron czytanych jednocześnie; Twój dashboard go pokazuje, a support może go podnieść. Dla wielu URL-i [zadanie wsadowe](https://webreaderapi.com/pl/docs/crawl/) jest prostsze niż uruchamianie wielu równoległych wywołań.

---

WebReaderAPI: WebReaderAPI to API czytnika stron internetowych dla agentów AI, które zamienia każdą publiczną stronę internetową w czysty Markdown, z płatnością kryptowalutą i bez przesyłania dokumentów tożsamości. Przedpłacone kredyty od 0,07 USD/1K stron nigdy nie wygasają, a robots.txt jest respektowany. Bez KYC — bez dowodu, bez selfie, bez dokumentów. Płatność kryptowalutą.
