SCRAPING•13 min czytania•Aktualizacja: 2026-11-16

Scraping stron do AI: Firecrawl albo Crawl4AI + n8n, od URL-a do czystego Markdownu

Jak zamienić dowolną stronę na czysty Markdown dla AI: Firecrawl API lub własny Crawl4AI w Dockerze, workflow w n8n, czyszczenie tekstu i koszty.

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:

  1. URL (lista w arkuszu, RSS albo sitemapa),
  2. scraper, który renderuje stronę w przeglądarce i oddaje Markdown (Firecrawl albo Crawl4AI),
  3. n8n, który czyści tekst, przycina go do limitu i zapisuje,
  4. 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.

Wskazówka: Oba narzędzia renderują JavaScript w prawdziwej przeglądarce (Chromium), więc radzą sobie ze stronami w React, Vue czy Next.js, na których zwykłe pobranie HTML-a zwraca pustą skorupę.

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)
Licencjausługa płatnaAGPL-3.0Apache 2.0
Koszt1 kredyt za stronęTwój serwerTwój serwer
Darmowy start1000 kredytów / mies.taktak
UtrzymanieżadneDocker + PostgreSQLjeden kontener
Blokady anty-botproxy i fire-engine w ceniebrak fire-engineto, co zdziała przeglądarka
Crawl całej domenytak, jednym wywołaniemtakwyłączony domyślnie w API
Najlepszy doszybkiego startu, trudnych stronfirmowej sieci, prywatnościstał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.

Wskazówka: Nie musisz wybierać na zawsze. Oba narzędzia przyjmują adres w JSON i oddają Markdown, więc w n8n różnią się tylko adresem endpointu, polem w body i miejscem treści w odpowiedzi.

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:

OpcjaDomyślnieCo robi
formats["markdown"]co zwrócić: markdown, html, links, json i inne
onlyMainContenttruewycina nagłówek, menu i stopkę (filtr na poziomie HTML, bez LLM)
excludeTagsbrakdodatkowe tagi lub selektory do usunięcia
waitFor0ile ms czekać na doładowanie JS (max 60 000)
timeout60000limit czasu całego żądania w ms
maxAge2 dnizwraca 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.

Wskazówka: Kopia z cache (maxAge) przyspiesza odpowiedź, ale nadal kosztuje 1 kredyt. Cache nie oszczędza pieniędzy, tylko czas.

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/health

Od 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:

fCo dostajesz
fit (domyślnie)treść główna po odcięciu menu i boksów (PruningContentFilter)
rawcała strona zamieniona na Markdown, bez filtrowania
bm25tylko fragmenty pasujące do zapytania z pola q
llmtreść 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.

Wskazówka: Nie publikuj portu 11235 na 0.0.0.0 bez reverse proxy z TLS. Token idzie w nagłówku, więc przez zwykłe HTTP ktoś w sieci może go podejrzeć. Najbezpieczniej trzymać Crawl4AI w tej samej sieci Dockera co n8n, bez wystawiania portu.

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.

Wskazówka: Po zmianie pliku .env uruchom docker compose up -d ponownie. Sam restart kontenera nie wczytuje nowych zmiennych środowiskowych.

Workflow w n8n: od listy adresów do plików .md

Workflow ma pięć węzłów:

  1. Trigger: Schedule Trigger (np. codziennie o 6:00) albo Manual Trigger do testów.
  2. Źródło adresów: Google Sheets, RSS Read albo węzeł Code z listą URL-i. Każdy element musi mieć pole url.
  3. 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.
  4. HTTP Request do scrapera (konfiguracja niżej).
  5. 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ą Authorization i 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 }}.
UstawienieFirecrawlCrawl4AI
MethodPOSTPOST
URLhttps://api.firecrawl.dev/v2/scrapehttp://crawl4ai:11235/md
Body{"url": "{{ $json.url }}", "formats": ["markdown"], "onlyMainContent": true}{"url": "{{ $json.url }}", "f": "fit"}
Gdzie jest treśćdata.markdownmarkdown
Timeout (Options)90 000 ms90 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.

Wskazówka: Poświadczenie Header Auth działa dla obu usług tak samo, bo Firecrawl i Crawl4AI oczekują nagłówka Authorization: Bearer.

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.

Wskazówka: Do bazy wektorowej nie wrzucaj całego dokumentu jako jednego wektora. Dziel Markdown po nagłówkach ## na fragmenty po 500–1000 tokenów, a tytuł i adres źródła dopisuj do metadanych każdego fragmentu.

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.

Wskazówka: arun_many sam pilnuje równoległości i pamięci, więc nie musisz ręcznie dzielić listy adresów na partie.

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:

  1. 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.
  2. 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.
  3. 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.

Wskazówka: To nie jest porada prawna. Przy komercyjnym wykorzystaniu cudzych treści (np. budowie produktu na danych z cudzego serwisu) skonsultuj się z prawnikiem.

Typowe problemy i rozwiązania

ObjawPrzyczynaRozwiązanie
Pusty lub bardzo krótki Markdowntreść doładowuje JavaScriptFirecrawl: waitFor: 2000–5000; Crawl4AI: tryb raw i porównanie wyniku
W tekście menu i stopkafiltr nie rozpoznał układu stronyFirecrawl: excludeTags z selektorami; Crawl4AI SDK: wyższy threshold
Brakuje akapitówfiltr fit wyciął za dużoCrawl4AI: f: "raw" albo niższy threshold w SDK
connection reset z Crawl4AIbrak CRAWL4AI_API_TOKEN, serwer słucha tylko lokalnieuruchom kontener z tokenem
HTTP 401 z Crawl4AIbrak lub zły nagłówek Bearersprawdź poświadczenie Header Auth w n8n
HTTP 400 z Crawl4AIpole 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 Firecrawlbrak kredytów na cały limit crawlazmniejsz limit albo dokup kredyty
statusCode 403 w metadanychblokada anty-bot lub CloudflareFirecrawl: proxy: "enhanced"; przy self-hostingu często nie do obejścia
Kontener Crawl4AI pada przy wielu stronachza mało /dev/shm lub RAM--shm-size=1g, limit 4 GB, mniejsze partie w n8n
Timeout w n8ndomyślny limit węzła za krótkiTimeout 90 000 ms w Options węzła HTTP Request
Wskazówka: Przy problemach z jedną stroną najpierw wywołaj scraper curl-em spoza n8n. Od razu zobaczysz, czy problem leży w stronie, w scraperze czy w konfiguracji węzła.

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.

WariantMiesięczny kosztUwagi
Firecrawl Free0 złstarczy na ok. 1000 stron, czyli pierwszy tydzień
Firecrawl Hobby19 USD5000 kredytów, mieści się z niewielkim zapasem
Crawl4AI na VPS z n8n0 zł ponad koszt serwerapotrzebujesz VPS z 8 GB RAM zamiast 4 GB
Firecrawl self-host0 zł ponad koszt serwerawię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.

Wskazówka: Ceny Firecrawl podajemy według cennika z listopada 2026. Przed wyborem planu sprawdź aktualne stawki, bo dostawca regularnie zmienia limity kredytów.

Źródła

Często zadawane pytania (FAQ)

Czy Firecrawl albo Crawl4AI obchodzą Cloudflare i CAPTCHA?

Firecrawl w chmurze ma rotację proxy i własny silnik przeglądarki, więc radzi sobie z częścią zabezpieczeń anty-bot. Self-hostowany Firecrawl i Crawl4AI używają zwykłego Chromium i na mocno chronionych stronach często dostaną 403. Jeśli serwis aktywnie blokuje boty, potraktuj to jako sygnał, że właściciel nie życzy sobie scrapowania.

Czy mogę użyć Crawl4AI na n8n Cloud?

Tak, jeśli serwer Crawl4AI jest dostępny z internetu przez HTTPS (reverse proxy z TLS, np. Caddy) i ma ustawiony token. n8n Cloud nie widzi Twojej sieci lokalnej, więc adres w stylu http://crawl4ai:11235 zadziała tylko przy self-hostowanym n8n w tej samej sieci Dockera.

Czym różni się fit_markdown od raw_markdown?

raw_markdown to cała strona zamieniona na Markdown, razem z menu i stopką. fit_markdown to wynik po filtrze treści (PruningContentFilter), który ocenia bloki strony po gęstości tekstu i linków i odcina te, które wyglądają na nawigację lub boksy. Do LLM i RAG zwykle lepszy jest fit, ale na nietypowych układach warto porównać oba.

Czy cache Firecrawl obniża koszty?

Nie. Kopia z cache (domyślnie do 2 dni, parametr maxAge) przyspiesza odpowiedź, ale nadal kosztuje 1 kredyt za stronę. Żeby nie płacić dwa razy za ten sam adres, zapisuj w n8n listę już pobranych URL-i i pomijaj je przed wywołaniem scrapera.

Ile stron dziennie mogę bezpiecznie pobierać z jednego serwisu?

Nie ma jednej granicy, ale dobra praktyka to jedno żądanie na 1–2 sekundy do tej samej domeny i pobieranie tylko nowych adresów (z RSS lub sitemapy), a nie całego serwisu codziennie. Sprawdź też robots.txt: dyrektywa Crawl-delay, jeśli jest, podaje oczekiwany odstęp.