Po co zamieniać strony na Markdown, zanim trafią do AI
Model językowy nie potrzebuje HTML-a. Typowa strona to w 80–90% menu, skrypty, stopka, banery cookies i atrybuty CSS, a sama treść artykułu to ułamek pliku. Jeśli wkleisz surowy HTML do promptu, płacisz za tokeny śmieci, a model gorzej trzyma się sensu tekstu.
Markdown zostawia to, co ważne dla modelu: nagłówki, akapity, listy, tabele i linki. Ta sama strona w Markdownie ma zwykle kilka do kilkunastu razy mniej tokenów niż w HTML-u, a struktura nagłówków pomaga potem dzielić tekst na fragmenty pod RAG.
W tym poradniku zbudujesz potok:
- URL (lista w arkuszu, RSS albo sitemapa),
- scraper, który renderuje stronę w przeglądarce i oddaje Markdown (Firecrawl albo Crawl4AI),
- n8n, który czyści tekst, przycina go do limitu i zapisuje,
- cel: plik
.md, baza wektorowa, streszczenie przez LLM albo wpis w CMS.
Jeśli nie wiesz, czym są tokeny ani RAG, zajrzyj najpierw do haseł Czym są tokeny w AI i Czym jest RAG.
Firecrawl czy Crawl4AI: co wybrać
Oba projekty robią to samo (URL na wejściu, Markdown na wyjściu), ale różnią się modelem płatności i tym, kto utrzymuje infrastrukturę.
| Firecrawl (chmura) | Firecrawl (self-host) | Crawl4AI (Docker) | |
|---|---|---|---|
| Licencja | usługa płatna | AGPL-3.0 | Apache 2.0 |
| Koszt | 1 kredyt za stronę | Twój serwer | Twój serwer |
| Darmowy start | 1000 kredytów / mies. | tak | tak |
| Utrzymanie | żadne | Docker + PostgreSQL | jeden kontener |
| Blokady anty-bot | proxy i fire-engine w cenie | brak fire-engine | to, co zdziała przeglądarka |
| Crawl całej domeny | tak, jednym wywołaniem | tak | wyłączony domyślnie w API |
| Najlepszy do | szybkiego startu, trudnych stron | firmowej sieci, prywatności | stałego, dużego wolumenu |
Ceny Firecrawl (listopad 2026): plan Free daje 1000 kredytów miesięcznie bez karty, Hobby kosztuje 19 USD miesięcznie za 5000 kredytów, a Standard 99 USD za 100 000. Zwykły scrape to 1 kredyt na stronę, ekstrakcja JSON przez LLM dolicza 4 kredyty. Niewykorzystane kredyty nie przechodzą na kolejny miesiąc. Aktualne stawki sprawdzisz na karcie Firecrawl.
Nasza rekomendacja: zacznij od darmowego planu Firecrawl, żeby w godzinę mieć działający potok w n8n. Gdy przekroczysz kilka tysięcy stron miesięcznie albo chcesz scrapować strony wewnętrzne, przenieś ten sam workflow na Crawl4AI na własnym VPS. W n8n zmienisz tylko adres i jedno pole w węźle HTTP Request.
Inne gotowe scrapery, np. Apify i Browserless, porównujemy w rankingu Web scraping i proxy.
Firecrawl: pierwszy Markdown w jednym zapytaniu
Załóż konto na firecrawl.dev i skopiuj klucz API (zaczyna się od fc-). Endpoint /v2/scrape przyjmuje adres i listę formatów, a oddaje treść w polu data.markdown:
curl -s -X POST https://api.firecrawl.dev/v2/scrape \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com/blog/artykul",
"formats": ["markdown"],
"onlyMainContent": true,
"excludeTags": ["nav", "footer", "aside", ".cookie-banner"],
"waitFor": 1000,
"maxAge": 0
}'Najważniejsze opcje:
| Opcja | Domyślnie | Co robi |
|---|---|---|
formats | ["markdown"] | co zwrócić: markdown, html, links, json i inne |
onlyMainContent | true | wycina nagłówek, menu i stopkę (filtr na poziomie HTML, bez LLM) |
excludeTags | brak | dodatkowe tagi lub selektory do usunięcia |
waitFor | 0 | ile ms czekać na doładowanie JS (max 60 000) |
timeout | 60000 | limit czasu całego żądania w ms |
maxAge | 2 dni | zwraca kopię z cache młodszą niż podany czas; 0 wymusza świeże pobranie |
Odpowiedź wygląda tak:
{
"success": true,
"data": {
"markdown": "# Tytuł artykułu\n\nPierwszy akapit treści...",
"metadata": {
"title": "Tytuł artykułu",
"description": "Opis z meta description",
"language": "pl",
"sourceURL": "https://example.com/blog/artykul",
"statusCode": 200
}
}
}Zwróć uwagę na dwa poziomy statusu: success: true mówi, że API zadziałało, a data.metadata.statusCode to kod odpowiedzi samej strony. Strona może zwrócić 404 albo 403, a Firecrawl i tak odda sukces (i policzy kredyt).
Cała sekcja serwisu: map i crawl
Gdy potrzebujesz wszystkich artykułów z bloga, masz dwie drogi. POST /v2/map zwraca listę adresów domeny (głównie z sitemapy) za 1 kredyt, a potem scrapujesz wybrane. POST /v2/crawl robi wszystko sam i liczy 1 kredyt za każdą stronę:
# 1. Start crawla: tylko /blog/, maksymalnie 50 stron
curl -s -X POST https://api.firecrawl.dev/v2/crawl \
-H "Authorization: Bearer $FIRECRAWL_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"url": "https://example.com",
"limit": 50,
"includePaths": ["^/blog/.*"],
"scrapeOptions": { "formats": ["markdown"], "onlyMainContent": true }
}'
# odpowiedź: {"success": true, "id": "123-456-789", "url": ".../v2/crawl/123-456-789"}
# 2. Status i wyniki (powtarzaj, aż status = "completed")
curl -s https://api.firecrawl.dev/v2/crawl/123-456-789 \
-H "Authorization: Bearer $FIRECRAWL_API_KEY"Wyniki crawla są dostępne przez API przez 24 godziny. includePaths i excludePaths to wyrażenia regularne dopasowywane do ścieżki adresu. Zawsze ustawiaj limit: domyślnie to 10 000 stron, czyli cały miesięczny pakiet za jednym kliknięciem.
Firecrawl na własnym serwerze
Kod Firecrawl jest otwarty (AGPL-3.0), więc to samo API postawisz u siebie na porcie 3002. Przypnij wersję do tagu wskazanego w oficjalnym przewodniku self-host:
git clone https://github.com/firecrawl/firecrawl.git
cd firecrawl
git checkout <tag z przewodnika self-host> # nie buduj z gałęzi main
cat > .env <<'EOF'
USE_DB_AUTHENTICATION=false
POSTGRES_USER=postgres
POSTGRES_PASSWORD=zmien-na-co-najmniej-32-losowe-znaki
POSTGRES_DB=postgres
EOF
docker compose up --build -d
curl http://localhost:3002/v0/health/readiness # {"status":"ok"}Wersja self-host nie ma silnika fire-engine z chmury. Bez niego nie działają zrzuty ekranu, akcje na stronie (klikanie, przewijanie) ani obchodzenie zabezpieczeń anty-bot. Ekstrakcja przez LLM wymaga podpięcia dostawcy zgodnego z API OpenAI albo Ollamy. USE_DB_AUTHENTICATION=false wyłącza klucze API, więc taki serwer trzymaj wyłącznie w zaufanej sieci.
Crawl4AI: własny serwer w Dockerze
Crawl4AI to biblioteka Pythona z gotowym serwerem HTTP w obrazie Dockera. Aktualna wersja to 0.9.5 z 14 października 2026, wydanie poprawiające bezpieczeństwo. Starszych wersji 0.8.x nie wystawiaj do sieci.
Potrzebujesz maszyny z co najmniej 4 GB RAM dla kontenera (każda karta przeglądarki to kilkaset MB). Wystarczy mały VPS, ten sam, na którym stoi n8n. Instalację n8n na VPS opisaliśmy w poradniku n8n na VPS z Dockerem i Caddy.
# Token jest obowiązkowy, jeśli serwer ma być dostępny spoza kontenera
export CRAWL4AI_API_TOKEN="$(openssl rand -hex 32)"
echo "$CRAWL4AI_API_TOKEN" # zapisz go, przyda się w n8n
docker run -d \
--name crawl4ai \
-p 127.0.0.1:11235:11235 \
--shm-size=1g \
-e CRAWL4AI_API_TOKEN="$CRAWL4AI_API_TOKEN" \
--restart unless-stopped \
unclecode/crawl4ai:0.9.5
curl http://localhost:11235/healthOd wersji 0.9.0 uwierzytelnianie jest włączone domyślnie. Bez zmiennej CRAWL4AI_API_TOKEN serwer słucha tylko na 127.0.0.1 wewnątrz kontenera, więc opublikowany port odpowiada zerwaniem połączenia. To najczęstszy powód, dla którego „Docker działa, a curl nie”. Każde żądanie poza GET /health musi mieć nagłówek Authorization: Bearer <token>.
Endpoint /md
Do zamiany strony na Markdown służy POST /md:
curl -s -X POST http://localhost:11235/md \
-H "Authorization: Bearer $CRAWL4AI_API_TOKEN" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/blog/artykul", "f": "fit"}'Pole f wybiera filtr treści:
f | Co dostajesz |
|---|---|
fit (domyślnie) | treść główna po odcięciu menu i boksów (PruningContentFilter) |
raw | cała strona zamieniona na Markdown, bez filtrowania |
bm25 | tylko fragmenty pasujące do zapytania z pola q |
llm | treść wybrana przez model językowy wg instrukcji z q (wymaga skonfigurowanego dostawcy LLM po stronie serwera) |
Pole c steruje cache: "0" (domyślnie) zawsze pobiera stronę od nowa, "1" pozwala użyć zapisanej kopii. Odpowiedź:
{
"url": "https://example.com/blog/artykul",
"filter": "fit",
"query": null,
"cache": "0",
"markdown": "# Tytuł artykułu\n\nPierwszy akapit treści...",
"success": true
}Do wielu adresów naraz służy POST /crawl (do 100 adresów w polu urls). Głęboki crawl po linkach jest w API domyślnie wyłączony (zmienna CRAWL4AI_ALLOW_DEEP_CRAWL=true), a adresy z sieci prywatnej są blokowane, dopóki nie ustawisz CRAWL4AI_ALLOW_INTERNAL_URLS=true.
n8n i Crawl4AI w jednym docker-compose
Jeśli n8n i Crawl4AI stoją na tym samym serwerze, połącz je wspólną siecią Dockera. Wtedy n8n woła scraper po nazwie usługi (http://crawl4ai:11235), a scraper nie ma żadnego portu otwartego na świat:
services:
n8n:
image: docker.n8n.io/n8nio/n8n:latest
restart: unless-stopped
ports:
- "127.0.0.1:5678:5678"
volumes:
- n8n_data:/home/node/.n8n
crawl4ai:
image: unclecode/crawl4ai:0.9.5
restart: unless-stopped
shm_size: "1g"
environment:
- CRAWL4AI_API_TOKEN=${CRAWL4AI_API_TOKEN}
# bez sekcji ports: serwer widzi tylko n8n w tej samej sieci Dockera
deploy:
resources:
limits:
memory: 4g
volumes:
n8n_data:Token trzymaj w pliku .env obok docker-compose.yml (CRAWL4AI_API_TOKEN=...), nie w samym pliku compose. Limit pamięci chroni n8n przed sytuacją, w której scraper z dziesięcioma kartami przeglądarki zjada cały RAM serwera. Ile pamięci potrzebuje sam n8n, liczymy w poradniku Ile RAM potrzebuje n8n.
Workflow w n8n: od listy adresów do plików .md
Workflow ma pięć węzłów:
- Trigger: Schedule Trigger (np. codziennie o 6:00) albo Manual Trigger do testów.
- Źródło adresów: Google Sheets, RSS Read albo węzeł Code z listą URL-i. Każdy element musi mieć pole
url. - Loop Over Items z rozmiarem partii 1–5 i węzłem Wait (1–2 s) w pętli. Nie zasypuj scrapera setką żądań naraz.
- HTTP Request do scrapera (konfiguracja niżej).
- Code: czyszczenie Markdownu, potem zapis (Write Binary File, Google Drive, Notion albo wektoryzacja).
Węzeł HTTP Request
Najszybciej: w węźle HTTP Request kliknij Import cURL i wklej polecenie curl z poprzednich sekcji. n8n sam ustawi metodę, adres i body. Potem popraw dwie rzeczy:
- Uwierzytelnianie: zamiast klucza w nagłówku utwórz poświadczenie Header Auth z nazwą
Authorizationi wartościąBearer <klucz>. Klucz nie wyląduje wtedy w eksporcie workflow. - Adres strony: w body JSON zamień stały adres na wyrażenie
{{ $json.url }}.
| Ustawienie | Firecrawl | Crawl4AI |
|---|---|---|
| Method | POST | POST |
| URL | https://api.firecrawl.dev/v2/scrape | http://crawl4ai:11235/md |
| Body | {"url": "{{ $json.url }}", "formats": ["markdown"], "onlyMainContent": true} | {"url": "{{ $json.url }}", "f": "fit"} |
| Gdzie jest treść | data.markdown | markdown |
| Timeout (Options) | 90 000 ms | 90 000 ms |
W Options węzła włącz też Retry On Fail (2–3 próby, odstęp 5 s) i ustaw On Error: Continue (using error output). Jedna niedziałająca strona nie zatrzyma wtedy całej listy, a błędy trafią osobną ścieżką, np. do arkusza do ręcznego przejrzenia.
W n8n znajdziesz też gotowy węzeł Firecrawl, ale HTTP Request ma jedną przewagę: ten sam workflow przełączysz na Crawl4AI, zmieniając adres i body.
Czyszczenie Markdownu przed modelem
Nawet z onlyMainContent i filtrem fit w tekście zostają resztki: obrazki, linki do udostępniania, „Przejdź do treści”, banery cookies. Węzeł Code poniżej działa z odpowiedzią obu scraperów, usuwa te resztki, przycina tekst do limitu i dokleja nagłówek z tytułem, źródłem i datą (front matter):
// n8n, węzeł Code, tryb "Run Once for All Items".
// Działa z odpowiedzią Firecrawl (data.markdown) i Crawl4AI /md (markdown).
const MAX_CHARS = 40000; // ok. 10 tys. tokenów, bezpiecznie dla większości modeli
const KEEP_LINKS = false; // true = zostaw adresy linków w treści
const JUNK_LINES = [
/^skip to (main )?content$/i,
/^przejdź do (treści|zawartości)$/i,
/akceptuj(ę)? (wszystkie )?(pliki )?cookies?/i,
/^(udostępnij|share)( na)?:?$/i,
];
function clean(md) {
let text = md
.replace(/!\[[^\]]*\]\([^)]*\)/g, '') // obrazki
.replace(/\[\s*\]\([^)]*\)/g, ''); // puste linki
if (!KEEP_LINKS) {
text = text.replace(/\[([^\]]+)\]\((?:[^()]|\([^)]*\))*\)/g, '$1'); // [tekst](url) -> tekst
}
return text
.split('\n')
.map((line) => line.replace(/\s+$/, ''))
.filter((line) => !JUNK_LINES.some((re) => re.test(line.trim())))
.join('\n')
.replace(/\n{3,}/g, '\n\n')
.trim();
}
return $input.all().map(({ json }) => {
const raw = json.data?.markdown ?? json.markdown ?? '';
const meta = json.data?.metadata ?? {};
const url = meta.sourceURL ?? json.url ?? '';
const title = meta.title ?? (raw.match(/^#\s+(.+)$/m)?.[1] ?? url);
let body = clean(raw);
const truncated = body.length > MAX_CHARS;
if (truncated) body = body.slice(0, MAX_CHARS);
const doc = [
'---',
'title: "' + title.replace(/"/g, "'") + '"',
'source: ' + url,
'fetched: ' + new Date().toISOString().slice(0, 10),
'---',
'',
body,
].join('\n');
return {
json: {
url,
title,
chars: body.length,
approxTokens: Math.round(body.length / 4),
truncated,
empty: body.length < 200,
markdown: doc,
},
};
});Pole empty oznacza strony, z których zostało mniej niż 200 znaków. To zwykle sygnał, że strona doładowuje treść skryptem i trzeba zwiększyć waitFor, albo że scraper trafił na stronę z blokadą. Za węzłem Code wstaw If na {{ $json.empty }} i kieruj takie przypadki do ponownej próby albo do listy błędów.
approxTokens to przybliżenie (ok. 4 znaki na token). Polski tekst zwykle zużywa więcej tokenów na znak niż angielski, więc licz z zapasem.
Bez serwera: Crawl4AI ze skryptu Pythona
Jeśli potrzebujesz jednorazowo pobrać kilkadziesiąt stron na własnym komputerze, serwer nie jest konieczny. Biblioteka działa z Pythona 3.10+, a polecenie crawl4ai-setup instaluje przeglądarkę Chromium:
# pip install -U crawl4ai && crawl4ai-setup (Python 3.10+, instaluje Chromium)
import asyncio
from crawl4ai import (
AsyncWebCrawler, CacheMode, CrawlerRunConfig,
DefaultMarkdownGenerator, PruningContentFilterLXML,
)
URLS = [
"https://example.com/blog/artykul-1",
"https://example.com/blog/artykul-2",
]
config = CrawlerRunConfig(
cache_mode=CacheMode.BYPASS,
excluded_tags=["nav", "footer", "aside"],
markdown_generator=DefaultMarkdownGenerator(
content_filter=PruningContentFilterLXML(threshold=0.45, threshold_type="dynamic")
),
)
async def main():
async with AsyncWebCrawler() as crawler:
results = await crawler.arun_many(URLS, config=config)
for r in results:
if not r.success:
print("BŁĄD", r.url, r.error_message)
continue
md = r.markdown.fit_markdown or r.markdown.raw_markdown
name = r.url.rstrip("/").split("/")[-1] or "index"
with open(f"{name}.md", "w", encoding="utf-8") as f:
f.write(md)
print("OK", r.url, len(md), "znaków")
asyncio.run(main())fit_markdown to tekst po filtrze PruningContentFilter, a raw_markdown cała strona. threshold steruje agresywnością filtra: niższa wartość zostawia więcej treści, wyższa tnie więcej. Jeśli w wyniku brakuje akapitów, zejdź do 0.3–0.4. PruningContentFilterLXML to szybsza wersja filtra (ten sam wynik), której domyślnie używa serwer Dockera.
Co wolno scrapować: robots.txt, prawo autorskie i RODO
To, że strona jest publiczna, nie znaczy, że wolno z nią zrobić wszystko. Przed uruchomieniem potoku sprawdź trzy rzeczy:
- robots.txt i regulamin serwisu. Jeśli serwis zakazuje automatycznego pobierania albo wyklucza boty AI, uszanuj to. Część wydawców zastrzega to wprost w regulaminie.
- Prawo autorskie. Polska ustawa o prawie autorskim (art. 26³, wdrożenie dyrektywy DSM) dopuszcza eksplorację tekstów i danych, ale właściciel może się temu sprzeciwić w formie czytelnej maszynowo, np. w robots.txt lub metadanych strony. Streszczenie artykułu na własny użytek to co innego niż ponowna publikacja cudzej treści na swojej stronie. Tego drugiego nie rób bez zgody.
- Dane osobowe. Jeśli scrapujesz strony z imionami, e-mailami czy telefonami (katalogi firm, fora, profile), podlegasz RODO. Nie zbieraj danych osobowych „na zapas” i nie łącz ich w profile osób.
Do tego dochodzi zwykła przyzwoitość techniczna: limit żądań, przerwy w pętli i identyfikowalny ruch. Mały serwis nie powinien odczuć Twojego potoku.
Typowe problemy i rozwiązania
| Objaw | Przyczyna | Rozwiązanie |
|---|---|---|
| Pusty lub bardzo krótki Markdown | treść doładowuje JavaScript | Firecrawl: waitFor: 2000–5000; Crawl4AI: tryb raw i porównanie wyniku |
| W tekście menu i stopka | filtr nie rozpoznał układu strony | Firecrawl: excludeTags z selektorami; Crawl4AI SDK: wyższy threshold |
| Brakuje akapitów | filtr fit wyciął za dużo | Crawl4AI: f: "raw" albo niższy threshold w SDK |
connection reset z Crawl4AI | brak CRAWL4AI_API_TOKEN, serwer słucha tylko lokalnie | uruchom kontener z tokenem |
| HTTP 401 z Crawl4AI | brak lub zły nagłówek Bearer | sprawdź poświadczenie Header Auth w n8n |
| HTTP 400 z Crawl4AI | pole niedozwolone w API od 0.9.0 (np. js_code, proxy, deep_crawl_strategy) | usuń pole albo użyj SDK w Pythonie |
| HTTP 402 z Firecrawl | brak kredytów na cały limit crawla | zmniejsz limit albo dokup kredyty |
statusCode 403 w metadanych | blokada anty-bot lub Cloudflare | Firecrawl: proxy: "enhanced"; przy self-hostingu często nie do obejścia |
| Kontener Crawl4AI pada przy wielu stronach | za mało /dev/shm lub RAM | --shm-size=1g, limit 4 GB, mniejsze partie w n8n |
| Timeout w n8n | domyślny limit węzła za krótki | Timeout 90 000 ms w Options węzła HTTP Request |
Ile to kosztuje w praktyce
Przykład: monitorujesz 30 serwisów branżowych i codziennie pobierasz po 5 nowych artykułów, czyli ok. 4500 stron miesięcznie.
| Wariant | Miesięczny koszt | Uwagi |
|---|---|---|
| Firecrawl Free | 0 zł | starczy na ok. 1000 stron, czyli pierwszy tydzień |
| Firecrawl Hobby | 19 USD | 5000 kredytów, mieści się z niewielkim zapasem |
| Crawl4AI na VPS z n8n | 0 zł ponad koszt serwera | potrzebujesz VPS z 8 GB RAM zamiast 4 GB |
| Firecrawl self-host | 0 zł ponad koszt serwera | więcej usług do utrzymania (PostgreSQL, kolejka) |
Powyżej ok. 10 000 stron miesięcznie własny serwer zwykle wygrywa kosztowo. Poniżej tej granicy chmura Firecrawl jest tańsza, jeśli policzysz własny czas na utrzymanie. Do tego dochodzi koszt modelu, który przetwarza Markdown dalej: przy streszczeniach przez API płacisz za tokeny wejściowe, więc dobre czyszczenie tekstu przekłada się wprost na rachunek.
Serwery pod n8n i scrapery porównujemy w rankingu VPS pod n8n.