Szybka odpowiedź: jaką paginację wybrać w Next.js pod SEO i wydajność?
Dla treści indeksowalnej domyślna jest paginacja w URL, np. ?page=3 albo /blog/page/3.
Parametr page waliduj jak dane od użytkownika.
Offset pasuje do blogów i katalogów z numerami stron, ale zwalnia przy bardzo dużych zbiorach.
Cursor jest szybki w feedach, ale nie pozwala skoczyć do konkretnej strony.
Infinite scroll dla treści indeksowalnej wymaga dostępnych URL-i kolejnych porcji i linków HTML; sam przycisk „Załaduj więcej” nie wystarczy.
Trzy rodzaje paginacji w Next.js
1. Paginacja numeryczna w URL: /blog?page=3
Klasyczna paginacja z numerami stron, w której użytkownik widzi, ile jest stron, i przeskakuje między nimi dowolnie. To wariant, który SEO lubi najbardziej, bo każda strona ma własny i stabilny URL. Jest on wygodny do udostępniania, indeksacji i taki, do którego wrócisz zakładką. Domyślny wybór dla blogów, katalogów i portfolio; właśnie z takiego rozwiązania korzystam na strivelab.pl.
2. Infinite scroll: ładowanie przy przewijaniu
Lista rośnie automatycznie, gdy użytkownik scrolluje. Takie rozwiązanie jest bardzo popularne w serwisach social media i feedach, może jest wygodne, ale znacznie gorsze dla SEO (jedna strona, dynamiczne ładowanie) i nawigacji (trudno wrócić do konkretnego elementu).
3. Przycisk „load more" jako kompromis
Przycisk „Załaduj więcej" na dole listy, czyli użytkownik kontroluje ładowanie. Daje kontrolę nad UX, ale sam nie poprawia dostępności treści dla robotów. Dla SEO potrzebuje również linków do osobnych URL-i kolejnych porcji.
Paginacja URL-based rekomendowana dla SEO
Server Component z searchParams
Code
// app/blog/page.tsximport Link from 'next/link'import { notFound, permanentRedirect } from 'next/navigation'import { Pagination } from '@/components/pagination'import { getPaginatedPosts } from '@/lib/posts-offset'const POSTS_PER_PAGE = 10type SearchParamValue = string | string[] | undefinedfunction parsePage(rawPage: SearchParamValue) { if (rawPage === undefined) return 1 if (Array.isArray(rawPage)) return null if (!/^[1-9]\d*$/.test(rawPage)) return null const page = Number(rawPage) // Limit offsetu dopasuj do bazy i przyjętego limitu głębokości listy. const offset = (page - 1) * POSTS_PER_PAGE return Number.isSafeInteger(page) && Number.isSafeInteger(offset) && offset <= 2_147_483_647 ? page : null}export default async function BlogPage({ searchParams,}: { searchParams: Promise<{ page?: SearchParamValue }>}) { const params = await searchParams const currentPage = parsePage(params.page) if (currentPage === null) { notFound() } if (currentPage === 1 && params.page) { permanentRedirect('/blog') // 308 — trwały duplikat, nie tymczasowy stan } const { posts, totalPosts } = await getPaginatedPosts({ page: currentPage, perPage: POSTS_PER_PAGE, }) const totalPages = Math.ceil(totalPosts / POSTS_PER_PAGE) // Math.max: przy pustej liście (totalPages = 0) strona 1 może być pustym // stanem, ale ?page=2 wciąż powinno zwrócić 404, nie 200. if (currentPage > Math.max(totalPages, 1)) { notFound() } return ( <main> <h1>Blog</h1> <div className="space-y-6"> {posts.map((post) => ( <article key={post.id}> <h2><Link href={`/blog/${post.slug}`}>{post.title}</Link></h2> <p>{post.excerpt}</p> </article> ))} </div> <Pagination currentPage={currentPage} totalPages={totalPages} basePath="/blog" /> </main> )}
searchParams jest częścią URL-a, więc traktuj go jak input od użytkownika. Number(params.page) || 1 wygląda wygodnie, ale przepuszcza zbyt dużo niejednoznacznych przypadków: ?page=abc zmienia się w stronę pierwszą, ?page=1.5 zostaje liczbą, ?page=01 tworzy duplikat tej samej strony, a powtórzony parametr może przyjść jako tablica. Dla SEO i cache lepiej mieć jeden kanoniczny adres na jeden stan listy.
Od Next.js 15 searchParams jest Promise, a jego wartości nie są znane w czasie budowania strony. Jest to z pewnością wygodne przy listach zależnych od parametrów zapytania, ale oznacza też, że taka strona działa w modelu zależnym od żądania. Jeśli archiwum ma być w pełni statyczne, rozważ segment ścieżki, np. /blog/page/2, zamiast parametru ?page=2.
Google nie używa już rel="prev" / rel="next" jako sygnału indeksowania serii, więc dla samego Google nie są potrzebne. Najważniejsze są tutaj stabilne URL-e, poprawny adres kanoniczny, linkowanie wewnętrzne i brak duplikatów. Mogą je wykorzystywać inne narzędzia, zależnie od implementacji, więc jeśli chcesz dalej je emitować, Next.js ma do tego dedykowane pole pagination w Metadata API, które generuje prawdziwe elementy <link rel="prev"> i <link rel="next">. Jeśli je masz, to nie usuwaj, ale rozważyłbym, czy mają sens w nowym projekcie:
Code
// Fragment generateMetadata: page jest już zwalidowane, a totalPages// pochodzi z count() z tymi samymi filtrami co lista.return { title: page === 1 ? 'Blog | StriveLab' : `Blog, strona ${page} | StriveLab`, alternates: { canonical: page === 1 ? baseUrl : `${baseUrl}?page=${page}` }, pagination: { previous: page > 1 ? (page === 2 ? baseUrl : `${baseUrl}?page=${page - 1}`) : undefined, next: page < totalPages ? `${baseUrl}?page=${page + 1}` : undefined, },}
Nie generuj ich natomiast przez metadata.other, ponieważ to pole tworzy meta tagi (<meta name="prev">), a nie linki relacyjne. W związku z tym, nie spełnia pierwotnej funkcji.
Edge case'y SEO dla parametru page
Największe błędy w paginacji nie wynikają z samego ?page=2, tylko z dziesiątek wariantów tego samego stanu i każdy z nich może zjeść crawl budget, wpłynąć negatywnie na sygnały kanoniczne albo pokazać robotowi pustą stronę.
URL
Rekomendacja
Dlaczego
/blog
poprawny adres strony pierwszej
najczystszy adres kanoniczny dla początku listy
/blog?page=1
permanentRedirect('/blog')
duplikat strony pierwszej
/blog?page=2
200 + link kanoniczny na /blog?page=2
unikalna druga porcja treści
/blog?page=0
notFound() albo redirect do /blog
parametr spoza zakresu
/blog?page=abc
notFound()
niepoprawny input, nie stan listy
/blog?page=01
redirect do /blog albo notFound()
techniczny duplikat strony pierwszej
/blog?page=2&page=3
notFound()
niejednoznaczny stan URL-a
/blog?page=9999
notFound()
pusta strona poza zakresem serii
Jeśli paginujesz publiczne archiwum bloga, dodaj strony paginacji do sitemap tylko wtedy, gdy naprawdę chcesz je indeksować. Przy dużych katalogach produktowych zwykle lepiej generować sitemapę dla kategorii i najważniejszych filtrów, a bardzo głębokie strony paginacji zostawić do odkrywania przez linkowanie wewnętrzne.
?page=2 czy /page/2 dla paginacji?
Parametry zapytania nie jest błędem SEO sam w sobie, ponieważ ?page=2 może być poprawnym, indeksowalnym adresem. Pod warunkiem że ma własny adres kanoniczny, stabilną treść i linki HTML prowadzące do kolejnych stron. Kiedy jest źle? Gdy ta sama porcja treści istnieje pod kilkoma wariantami URL (duplikacja treści) albo gdy kolejne porcje są dostępne wyłącznie przez JavaScript (zbyt późne wczytywanie treści i problemy z widocznością w Google). Jak porządkować takie warianty w całym serwisie, nie tylko w paginacji, opisuję w artykule o obsłudze parametrów w URL bez duplikacji treści.
Wybór zależy od architektury:
Wzorzec
Kiedy używać
Uwaga
/blog?page=2
sortowanie, filtrowanie, listy zależne od parametrów zapytania
w App Router searchParams jest API zależnym od żądania
/blog/page/2
statyczne archiwa, blogi, kategorie, strony tagów
łatwiejsze do generowania, monitorowania i dodania do sitemap
Dla bloga, który ma statyczne archiwum i przewidywalną liczbę stron, /blog/page/2 bywa czystsze operacyjnie. Dla wyszukiwarki nie jest jednak ważny sam zapis adresu, tylko to, czy każda strona serii jest osiągalna przez zwykły link, odpowiada statusem 200, ma unikalną porcję treści i nie kanonizuje wszystkiego do strony pierwszej.
Offset vs cursor pagination: zapytania do bazy
Offset pagination w bazie danych
Code
// lib/posts-offset.ts — db to skonfigurowany klient Prisma projektu.import { db } from '@/lib/db'export async function getPaginatedPosts({ page, perPage,}: { page: number perPage: number}) { const offset = (page - 1) * perPage if (!Number.isSafeInteger(page) || page < 1 || !Number.isSafeInteger(perPage) || perPage < 1 || perPage > 100 || !Number.isSafeInteger(offset) || offset > 2_147_483_647) { throw new RangeError('Nieprawidłowy zakres paginacji') } const totalPosts = await db.post.count({ where: { published: true } }) // Nie wykonuj zapytania z ogromnym skip dla strony poza zakresem. if (page > Math.max(1, Math.ceil(totalPosts / perPage))) { return { posts: [], totalPosts } } const posts = await db.post.findMany({ where: { published: true }, orderBy: [{ createdAt: 'desc' }, { id: 'desc' }], skip: offset, take: perPage, }) return { posts, totalPosts }}
Problem wymaga od bazy danych przeskoczenia 10 000 rekordów, co przy milionach wierszy robi się wolno, nawet jeśli finalnie zwracasz tylko 10 pozycji. Dodatkowy koszt to dokładne COUNT(*); liczbę stron można też wyliczać z utrzymywanego licznika, cache lub oszacowania, zależnie od wymaganej dokładności.
Offset nadal ma sens przy blogu, katalogu usług albo panelu administracyjnym, gdzie użytkownik naprawdę potrzebuje numerów stron. Zadbaj tylko o indeks pasujący do zapytania, np. published + createdAt + id.
Druga sprawa to kwestia stabilnego sortowania, bo jeśli dwie pozycje mają ten sam createdAt, baza może zwrócić je w różnej kolejności między żądaniami. W paginacji kończy się to duplikatem na stronie 2 albo brakującym elementem. Dlatego nawet przy offset pagination warto dodać tie-breaker, najczęściej będzie to id.
Przy bardzo ruchliwych listach pamiętaj też, że count() i findMany() mogą widzieć trochę inny stan danych, jeśli między zapytaniami pojawi się nowy rekord. W blogu to zwykle akceptowalne. W systemach transakcyjnych albo raportowych potrzebny może być spójny snapshot, np. transakcja z odpowiednim poziomem izolacji. Sam cursor nie zapewnia spójności między count() a pobieraniem listy ani snapshotu między żądaniami.
Cursor pagination w bazie danych
Code
// lib/posts-cursor.ts — wariant alternatywny wobec posts-offset.ts.import { db } from '@/lib/db'type Cursor = { createdAt: string id: string}function encodeCursor(cursor: Cursor) { return Buffer.from(JSON.stringify(cursor)).toString('base64url')}export function decodeCursor(cursor: string): Cursor { if (cursor.length > 1024 || !/^[A-Za-z0-9_-]+$/.test(cursor)) { throw new Error('Nieprawidłowy cursor') } const value: unknown = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8')) if (!value || typeof value !== 'object' || Array.isArray(value)) { throw new Error('Nieprawidłowy cursor') } const { createdAt, id } = value as Record<string, unknown> // Przykład zakłada tekstowe ID: litery, cyfry, _ i -, maksymalnie 128 znaków. if (typeof createdAt !== 'string' || typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(id)) { throw new Error('Nieprawidłowy cursor') } const date = new Date(createdAt) if (!Number.isFinite(date.getTime()) || date.toISOString() !== createdAt) { throw new Error('Nieprawidłowa data kursora') } return { createdAt, id }}export async function getPaginatedPosts({ cursor, perPage,}: { cursor?: string perPage: number}) { if (!Number.isInteger(perPage) || perPage < 1 || perPage > 100) { throw new RangeError('Nieprawidłowy rozmiar strony') } const decodedCursor = cursor === undefined ? null : decodeCursor(cursor) const posts = await db.post.findMany({ where: { published: true, ...(decodedCursor && { OR: [ { createdAt: { lt: new Date(decodedCursor.createdAt) } }, { createdAt: new Date(decodedCursor.createdAt), id: { lt: decodedCursor.id }, }, ], }), }, orderBy: [{ createdAt: 'desc' }, { id: 'desc' }], take: perPage + 1, }) const hasMore = posts.length > perPage const items = hasMore ? posts.slice(0, -1) : posts const lastItem = items.at(-1) const nextCursor = hasMore && lastItem ? encodeCursor({ createdAt: lastItem.createdAt.toISOString(), id: lastItem.id, }) : null return { posts: items, nextCursor, hasMore }}
nie pozwala przeskakiwać
do strony 50, bo wymaga sekwencyjnego przechodzenia. Takie rozwiązanie jest
idealne dla infinite scrolla, ale gorsze dla numerycznej paginacji.
Wersja z samym cursor: { id } jest kusząca, ale łatwo ją źle połączyć z sortowaniem po createdAt. Cursor musi odpowiadać kolejności sortowania. Jeśli sortujesz po dacie, dodaj stabilny tie-breaker, najczęściej id, bo dwa rekordy mogą mieć ten sam timestamp.
Wydajność zależy od indeksu pasującego do filtrów i sortowania (tutaj np. published + createdAt + id) oraz planu zapytania. Przykład zakłada model z unikalnym tekstowym id, datą createdAt o precyzji zachowanej przez JavaScript i polami published, slug, title, excerpt. Walidację ID dopasuj do schematu. Najlepiej paginować po niezmiennych polach: zmiana daty sortowania lub widoczności rekordu może nadal powodować pominięcia albo powtórzenia. Cursor nie zamraża zbioru danych.
Kiedy wybrać offset, a kiedy cursor?
Kryterium
Offset
Cursor
Przeskakiwanie do strony N
Tak
Nie
Wydajność przy dużych zbiorach
Koszt rośnie z offsetem
Unika dużego offsetu; wymaga dobrego indeksu
„Ile jest stron?"
Osobny COUNT lub licznik
Osobny COUNT lub licznik
Infinite scroll
Możliwe
Idealne
SEO
Zależy od URL-i i linków HTML
Zależy od URL-i i linków HTML
Rekomendowałbym offset dla blogów i katalogów, gdzie potrzebujesz numerów stron i skakania do konkretnej strony. Cursor dla feedów, logów i dużych zbiorów z infinite scroll, gdzie nie jest ważny numer strony, ale stabilność i wydajność.
Endpoint do cursor pagination i doładowywania danych
Komponent klientowy nie powinien znać ORM-a. Wystaw cienki Route Handler, który waliduje cursor, pobiera następną porcję i zwraca tylko dane potrzebne do renderu.
Code
// app/api/posts/route.tsimport { NextRequest, NextResponse } from 'next/server'import { decodeCursor, getPaginatedPosts } from '@/lib/posts-cursor'const PAGE_SIZE = 20export async function GET(request: NextRequest) { const cursors = request.nextUrl.searchParams.getAll('cursor') const cursor = cursors[0] // Zły input to 400, awaria po naszej stronie to 500 — nie sklejaj ich // w jeden status, bo klient nie odróżni "popraw żądanie" od "spróbuj później". try { if (cursors.length > 1) throw new Error('Powtórzony cursor') if (cursor !== undefined) decodeCursor(cursor) } catch { return NextResponse.json( { error: 'Nieprawidłowy cursor' }, { status: 400 }, ) } try { const { posts, nextCursor, hasMore } = await getPaginatedPosts({ cursor, perPage: PAGE_SIZE, }) return NextResponse.json({ items: posts.map((post) => ({ id: post.id, title: post.title, excerpt: post.excerpt, })), nextCursor, hasMore, }) } catch { return NextResponse.json( { error: 'Nie udało się pobrać kolejnej strony' }, { status: 500 }, ) }}
Base64url to kodowanie, nie szyfrowanie. Podpis pozwala wykryć modyfikację kursora, ale nie ukrywa jego zawartości; poufność wymaga np. szyfrowania uwierzytelnionego albo nieprzezroczystego tokenu przechowywanego po stronie serwera. Publiczny feed może używać jawnego kursora z walidacją struktury. Żaden z tych mechanizmów nie zastępuje autoryzacji i filtrowania danych dostępnych użytkownikowi.
Infinite scroll z Intersection Observer w Next.js
Infinite scroll najczęściej zbudujesz na . Na końcu listy ustawiasz element wartownik, a jego pojawienie się w widoku uruchamia doładowanie kolejnej porcji.
Funkcje fetchMore i renderItem definiuj po stronie klienta. Nie przekazuj zwykłych callbacków z Server Component przez granicę 'use client'. Mały wrapper może przyjąć z serwera tylko dane:
Code
// components/posts-feed.tsx'use client'import { InfiniteList } from './infinite-list'type Post = { id: string; title: string; excerpt: string | null }type Page = { items: Post[]; nextCursor: string | null; hasMore: boolean }async function fetchMore(cursor: string, signal: AbortSignal): Promise<Page> { const response = await fetch(`/api/posts?${new URLSearchParams({ cursor })}`, { signal }) if (!response.ok) throw new Error('Nie udało się pobrać danych') return response.json() // Kontrakt własnego endpointu pokazanego wyżej.}export function PostsFeed({ initialItems, initialCursor, listKey }: { initialItems: Post[] initialCursor: string | null listKey: string}) { return <InfiniteList key={listKey} initialItems={initialItems} initialCursor={initialCursor} fetchMore={fetchMore} renderItem={(post) => <article><h2>{post.title}</h2><p>{post.excerpt}</p></article>} />}
initialItems i initialCursor inicjalizują stan tylko przy montowaniu. Przy dodaniu filtrów lub sortowania zmieniaj listKey (np. na ich stabilną reprezentację) i pobieraj nową pierwszą porcję; te same filtry musi otrzymywać endpoint kolejnych porcji. Zmiana klucza resetuje listę, cleanup przerywa stare żądanie, a kontrola sygnału odrzuca spóźnioną odpowiedź. Tę samą zasadę stosuj do LoadMoreList poniżej.
Automatyczny scroll jest wygodny, ale trudniej wrócić do konkretnej pozycji, trudniej pokazać użytkownikowi, gdzie jest w serii, i łatwiej odpalić kilka requestów naraz. Dlatego w panelach i feedach dodaj deduplikację po id, obsługę błędów oraz aria-live, a w publicznych listach treści rozważ dedykowany przycisk.
Load more jako kompromis dla UX — SEO wymaga URL-i
Przycisk „Załaduj więcej" jest mniej efektowny niż automatyczny infinite scroll, ale daje użytkownikowi kontrolę i prostszą dostępność. Ten sam Route Handler z kursorem działa bez zmian:
Jeśli treść ma być indeksowana, przycisk nie zastępuje prawdziwych URL-i. Najlepszą hybrydą są klasyczne linki /blog?page=2, /blog?page=3 albo /blog/page/2 dla robotów i użytkowników bez JavaScriptu, a ulepszenie klientowe dopiero na wierzchu. Wtedy SEO widzi serię stron, a użytkownik może dostać płynniejsze doładowywanie.
Jeśli infinite scroll udostępnia adresy kolejnych porcji, może aktualizować adres przez History API, gdy użytkownik przechodzi do kolejnej porcji. Nie chodzi o sztuczne upychanie wszystkiego pod jednym URL-em, tylko o to, żeby po odświeżeniu, udostępnieniu albo wejściu z wyszukiwarki użytkownik dostał tę samą porcję listy. Samo pushState nie wystarczy: serwer musi obsługiwać te URL-e, a aplikacja odtwarzać stan listy przy nawigacji wstecz i dalej.
Elastyczne i wydajne narzędzia dla biznesu, które dotrzymają kroku Twojemu rozwojowi.
Mogą być indeksowane. Powinny mieć kanoniczny adres wskazujący na siebie i być dostępne przez linkowanie wewnętrzne; sitemap może pomóc w odkrywaniu, ale nie gwarantuje indeksacji. Google traktuje ?page=2 jak osobną stronę z unikalną treścią. Kanoniczny URL drugiej strony powinien wskazywać na ?page=2, a nie na pierwszą stronę, ponieważ w przeciwnym razie głębsze strony mogą wypaść z indeksu.
Ile elementów powinno być na stronę?
Dla blogów i artykułów rozsądne jest 10–20 pozycji. Dla siatek produktów sprawdza się 20–48, najlepiej w wielokrotności liczby kolumn (2, 3, 4), żeby ostatni rząd był pełny. Sprawdź to na prawdziwych danych: zbyt wiele elementów spowalnia ładowanie strony, zbyt mało zmusza użytkownika do nadmiaru kliknięć.
Czym różni się offset od cursor pagination?
Offset (skip/OFFSET) mówi bazie, ile rekordów pominąć. Jest prosty i pozwala skoczyć do dowolnej strony, ale przy dużych przesunięciach baza musi przetworzyć pomijane wyniki; koszt zależy od indeksów i planu zapytania. Cursor zamiast tego pamięta pozycję ostatniego elementu, zwykle ID albo parę createdAt + id, i pobiera rekordy po nim. Przy odpowiednim indeksie dobrze skaluje się do dużych zbiorów, ale działa sekwencyjnie, więc nie przeskoczysz nim od razu do strony pięćdziesiątej.
Czy infinite scroll szkodzi SEO?
Może. Przy infinite scroll Google zwykle widzi tylko pierwszą porcję treści, ponieważ kolejne ładują się dopiero w reakcji na scroll, którego robot nie wykonuje tak jak użytkownik. Jeśli treść ma być indeksowana, użyj numerycznej paginacji z prawdziwymi adresami URL. Infinite scroll zostaw dla paneli użytkownika, feedów i widoków, które nie muszą trafiać do wyszukiwarki. Taki podział jest bezpieczny i przewidywalny.
Czy nadal trzeba dodawać rel=prev i rel=next?
Nie trzeba — Google oficjalnie przestał używać rel="prev" i rel="next" jako sygnału do rozumienia serii paginowanych stron. Mogą je wykorzystywać inne narzędzia, zależnie od implementacji. Jeśli chcesz je mieć, użyj pola pagination w Metadata API Next.js, które generuje prawdziwe elementy link. Nie generuj ich przez metadata.other, bo to pole tworzy meta tagi, a nie linki relacyjne. Dla Google liczą się przede wszystkim stabilne URL-e, poprawny link kanoniczny na każdej stronie, brak duplikatów i czytelne linkowanie między stronami.
Co zrobić z błędnymi parametrami page?
Znormalizuj pierwszą stronę do czystego URL-a, np. /blog zamiast /blog?page=1, a strony poza zakresem zwracaj przez notFound(). Parametry typu ?page=abc, ?page=-1, ?page=0, ?page=1.5 albo ?page=01 nie powinny tworzyć indeksowalnych wariantów tej samej listy. Najbezpieczniej przyjąć tylko dodatnie liczby całkowite bez zer wiodących, a resztę przekierować albo odrzucić.
Czy lepsze jest `/blog?page=2` czy `/blog/page/2`?
Oba wzorce mogą być poprawne, jeśli mają stabilną treść, własny link kanoniczny i linki HTML do kolejnych stron. W Next.js App Router searchParams jest wygodne dla sortowania, filtrów i szybkich list, ale jest API zależnym od żądania. Dla statycznych blogów i archiwów często praktyczniejszy jest segment ścieżki typu /blog/page/2, bo łatwiej go wygenerować, dodać do sitemap i monitorować jako osobną stronę.
O autorze
Maciej Sala
Maciej Sala — konsultant technologiczny produktów cyfrowych i web developer z bogatym doświadczeniem w marketingu internetowym oraz SEO. Na co dzień pracuje z Reactem, Next.js i TypeScriptem, a ostatnio także z Astro i narzędziami do automatyzacji procesów AI. Sprawnie łączy perspektywę produktową z praktycznym podejściem do kodu. Przez kilka lat był związany z branżą gier wideo jako project manager i game designer. Absolwent historii na Uniwersytecie Jagiellońskim oraz studiów podyplomowych z marketingu internetowego na AGH w Krakowie. Po godzinach trenuje na siłowni, maluje figurki i rozwija własne projekty.
Parametry w URL mają, jak przysłowiowa moneta ma dwie strony. Z jednej, napędzają filtry, sortowanie, paginację i śledzenie kampanii, a z drugiej, jednocześnie potrafią cicho popsuć widoczność serwisu przez duplikacje treści, marnowany budżet indeksowania i rozwodnione link equity. W aplikacjach React, Next.js i Astro to problem architektoniczny i właśnie dlatego samo użycie rel="canonical" go nie rozwiązuje. W tym przewodniku przechodzę od klasyfikacji parametrów do decyzji o indeksacji, normalizacji URL-i, renderowania, paginacji oraz kontroli nawigacji fasetowej.
Maciej Sala
Founder StriveLab
Trudno wyobrazić sobie współczesną analitykę bez Google Search Console GSC , czyli podstawowego narzędzia pokazującego dane bezpośrednio z Google Search. PageSpeed Insights mierzy wydajność, Ahrefs śledzi backlinki, ale GSC pokazuje dane o widoczności i problemach dotyczących strony internetowej. Dowiesz się z niego, które strony Google zna i indeksuje, jakie błędy crawlowania występują, na jakie frazy rankujesz oraz jakie wyniki Core Web Vitals osiąga strona podczas rzeczywistych wizyt użytkowników.
Maciej Sala
Founder StriveLab
Użytkownik ustawia trzy filtry, znajduje idealny wynik i wysyła link koledze, jednak ten widzi pustą wyszukiwarkę. Dzieje się tak, ponieważ stan filtrów przechowywany w useState nie opuszcza przeglądarki. Przeniesienie stanu do adresu URL rozwiązuje ten problem u źródła: zatwierdzone filtry stają się częścią linku, dzięki czemu przetrwają odświeżenie strony, udostępnienie oraz użycie przycisku „wstecz”, a przy tym są w pełni czytelne dla Server Components. Pokazuję, jak zbudować taką wyszukiwarkę — z debounce , skeletonami oraz walidacją parametrów i SEO.