diff --git a/apps/web/content/docs/dev/content-engine/content-delivery-and-seo.mdx b/apps/web/content/docs/dev/content-engine/content-delivery-and-seo.mdx
index c412c407d2..5a52d7d288 100644
--- a/apps/web/content/docs/dev/content-engine/content-delivery-and-seo.mdx
+++ b/apps/web/content/docs/dev/content-engine/content-delivery-and-seo.mdx
@@ -283,4 +283,4 @@ Pages hold 1,000 entries by default (`?limit=` up to 50,000), and `nextCursor` f
 
 Every URL delivery builds follows the app's [localized URL rules](/docs/dev/i18n/localized-urls): language prefixes, per-language domains and translated route segments. With [localization](/docs/dev/content-engine/localization) and a localized slug, and an app that translates `/recipes` in its `routePaths`, the Polish recipe can live at `/pl/przepisy/szakszuka-dla-dwojga` while the English one stays at `/recipes/shakshuka-for-two`. Only published translations become alternate links.
 
-Every `delivery` option, with its default and requirements, is in the [content type reference](/docs/dev/content-engine/reference#delivery).
+To list every recipe on one page with search and filters, continue with [Show a list of records](/docs/dev/content-engine/list-pages). Every `delivery` option, with its default and requirements, is in the [content type reference](/docs/dev/content-engine/reference#delivery).
diff --git a/apps/web/content/docs/dev/content-engine/index.mdx b/apps/web/content/docs/dev/content-engine/index.mdx
index 9336cd1df1..dc8a958ac7 100644
--- a/apps/web/content/docs/dev/content-engine/index.mdx
+++ b/apps/web/content/docs/dev/content-engine/index.mdx
@@ -40,7 +40,7 @@ export const recipeContentType = defineContentType({
 | Every content type   | Staff routes and `can_view`, `can_create`, `can_edit` and `can_delete` permissions                    |
 | `publication`        | Draft and published states, `can_publish`, and Publish buttons                                        |
 | `publicApi`          | Read-only public routes that return only the fields you list                                          |
-| `delivery`           | Page URL resolution, SEO metadata, slug redirects and sitemap entries                                 |
+| `delivery`           | Page URL resolution, SEO metadata, slug redirects, sitemap entries and an optional list page          |
 | `editorial`          | Revision history with restore, signed preview links and scheduled publishing                          |
 | `localization`       | A translations table, per-language fields and per-language publishing                                 |
 | `search`             | Records in the site [search](/docs/dev/search) index                                                  |
@@ -54,6 +54,7 @@ Content types live in code and in your migrations, not in the database. There is
 | Build a content type from scratch, with AdminCP screens         | [Create your first content type](/docs/dev/content-engine/defining-a-content-type)             |
 | Add drafts and a public, read-only API                          | [Publish content with a public API](/docs/dev/content-engine/public-api-and-caching)           |
 | Give each record its own page with SEO metadata                 | [Show content on a public page](/docs/dev/content-engine/content-delivery-and-seo)             |
+| List published records with pagination, search and filters      | [Show a list of records](/docs/dev/content-engine/list-pages)                                  |
 | Link records together, group fields or repeat rows              | [Relations and advanced fields](/docs/dev/content-engine/relations-and-advanced-modeling)      |
 | Translate content into several languages                        | [Translate content](/docs/dev/content-engine/localization)                                     |
 | Keep revisions, share draft previews or schedule publishing     | [Revisions, previews and scheduling](/docs/dev/content-engine/publication-and-editorial)       |
diff --git a/apps/web/content/docs/dev/content-engine/list-pages-reference.mdx b/apps/web/content/docs/dev/content-engine/list-pages-reference.mdx
new file mode 100644
index 0000000000..9b82bf3101
--- /dev/null
+++ b/apps/web/content/docs/dev/content-engine/list-pages-reference.mdx
@@ -0,0 +1,81 @@
+---
+title: List page reference
+description: Every helper and component VitNode provides for Content Engine list pages, from @vitnode/core/tanstack/content, with parameters, defaults and return values.
+icon: BookOpen
+---
+
+Everything a [list page](/docs/dev/content-engine/list-pages) uses comes from `@vitnode/core/tanstack/content`. The helpers read a content type's resolved `delivery.list`, so any definition returned by `defineContentType` can be passed where a `definition` is expected.
+
+```ts
+import {
+  contentListPage,
+  contentListPageHead,
+  contentListQuery,
+  contentListSearch,
+} from "@vitnode/core/tanstack/content";
+```
+
+## `ContentListSearch`
+
+The page's URL after `contentListSearch` has read it.
+
+| Key                | Type                             | Description                                                 |
+| ------------------ | -------------------------------- | ----------------------------------------------------------- |
+| `page`             | `number`                         | Set from 2 upwards. Page 1 has no `?page=`, so it has one URL |
+| `q`                | `string`                         | The trimmed search term, at most 256 characters             |
+| any declared filter | `boolean` \| `number` \| `string` | One key per field in `delivery.list.filters`               |
+
+## Helpers
+
+| Helper | Returns | Behavior |
+| ------ | ------- | -------- |
+| `contentListSearch(definition)` | `(input) => ContentListSearch` | The route's `search` validator. Drops a value it cannot read instead of failing |
+| `contentListQuery(definition, search)` | `ContentListQuery` | The `args.query` of the public list route: `first`, plus `page`, `search` and each filter as strings |
+| `contentListPage({ list, search })` | the `list` it was given | Throws `notFound()` when `search.page` is past the last page |
+| `contentListPageHead(definition, options)` | `PluginRouteHead` | The route's `head`. See below |
+| `nextContentListSearch(search, changes)` | `ContentListSearch` | The search of a link that changes the list. `undefined` removes a key, and any change except `page` goes back to page 1 |
+| `isContentListIndexable(search)` | `boolean` | `true` only for the plain first page |
+
+### How filters are read
+
+`contentListSearch` reads each filter by the kind of its field:
+
+| Field kind                     | URL value             | Search value |
+| ------------------------------ | --------------------- | ------------ |
+| `field.boolean()`              | `true` or `false`     | `boolean`    |
+| `field.enum()`                 | one of its `values`   | `string`     |
+| `field.number()`               | a finite number       | `number`     |
+| `field.relation()`, `field.user()` | a positive whole number | `number` |
+| `field.text()`, `field.slug()` | up to 255 characters  | `string`     |
+
+### `contentListPageHead` options
+
+| Name          | Type                              | Required | Default          | Description                       |
+| ------------- | --------------------------------- | -------- | ---------------- | --------------------------------- |
+| `search`      | `ContentListSearch \| undefined`  | Yes      |                  | The `search` that `head` receives |
+| `title`       | `string`                          | No       |                  | The page title, already translated |
+| `description` | `string`                          | No       |                  | The meta description              |
+| `locales`     | `readonly string[]`               | No       | every app locale | Languages that get an `hreflang` link |
+
+The plain first page gets a canonical link and one alternate per language, all pointing at `delivery.list.path`. Any other page returns `robots: "noindex, follow"` and no alternates.
+
+## Components
+
+All components render semantic HTML, take a `className`, and translate their own labels through the `core.global` namespace.
+
+| Component | Renders | Props |
+| --------- | ------- | ----- |
+| `ContentList` | A `<ul>` grid: one column on phones, two from `sm`, three from `lg` | Any `<ul>` prop |
+| `ContentListItem` | An `<li>` for one card | Any `<li>` prop |
+| `ContentCard` | An `<article>` with an optional image, a meta line, the title as a link and a description | `href`, `title`, `description?`, `image?` (`{ src, alt, width?, height? }`), `meta?`, `headingLevel?` (`2` or `3`, default `2`) |
+| `ContentListEmpty` | A `role="status"` message for an empty list | `title?`, `description?`. Defaults to "No results found" |
+| `ContentListPagination` | A `<nav>` with previous, numbered and next links | `page`, `totalPages`, `search`. Renders nothing for one page |
+| `ContentListSearchForm` | A `role="search"` `GET` form with a search field and a **Search** button | `search`, `label?`, `placeholder?` |
+| `ContentListFilter` | A `<nav>` with a visible label and a row of links, **All** first | `name`, `label`, `options` (`{ label, value }[]`), `search`, `allLabel?` |
+
+### Links and accessibility
+
+- Pagination and filter links are plain `<a href>` elements built with the router's `Link`, so they work without JavaScript and crawlers can follow them. The current page and the active filter carry `aria-current="page"`.
+- `ContentCard` makes only the title a link for assistive technology. The image links to the same page with `tabIndex={-1}` and `aria-hidden`, so a keyboard user reaches each record once.
+- `ContentListSearchForm` submits as a normal `GET` form without JavaScript. With it, the router navigates without a reload. Active filters travel along as hidden fields.
+- `ContentListPagination` shows the first page, the last page and the neighbours of the current one, with an ellipsis for the gaps.
diff --git a/apps/web/content/docs/dev/content-engine/list-pages.mdx b/apps/web/content/docs/dev/content-engine/list-pages.mdx
new file mode 100644
index 0000000000..065bf18a4c
--- /dev/null
+++ b/apps/web/content/docs/dev/content-engine/list-pages.mdx
@@ -0,0 +1,323 @@
+---
+title: Show a list of records
+description: Give a Content Engine content type a public list page, such as /recipes, with pagination, a search box, filters and SEO that keeps search and filter results out of the index.
+icon: LayoutGrid
+---
+
+import { ImgDocs } from '@/components/fumadocs/img'
+import recipesList from './recipes-list-page.png'
+import recipesFiltered from './recipes-list-filtered.png'
+
+A list page shows every published record of a content type at one URL, such as `/recipes`. Turn on `delivery.list` and the Content Engine reads the page number, the search term and your filters from the URL, asks the public API for exactly that page, and builds the page's SEO tags. Your plugin renders the page from ready-made components, so a list with pagination, search and filters is one route and one file.
+
+## Before you begin
+
+The content type needs [delivery](/docs/dev/content-engine/content-delivery-and-seo), which already gives each recipe its own page at `/recipes/:slug`. This guide continues the recipes example.
+
+<Steps>
+
+<Step>
+
+### Turn on the list page
+
+Add `list` to the `delivery` block. Every filter must already be in `publicApi.filterableFields`, because the page passes it to the public list route:
+
+```ts title="plugins/example/src/content/recipe.ts"
+publicApi: {
+  enabled: true,
+  path: "recipes",
+  fields: ["title", "slug", "summary", "cookingTime", "difficulty", "vegetarian", "publishedAt"],
+  searchableFields: ["title", "summary"],
+  filterableFields: ["difficulty", "vegetarian"],
+  orderableFields: ["cookingTime"],
+},
+delivery: {
+  enabled: true,
+  seo: { titleField: "title", descriptionField: "summary" },
+  sitemap: { enabled: true, changeFrequency: "weekly" },
+  list: { // [!code ++:5]
+    enabled: true,
+    pageSize: 6,
+    filters: ["difficulty", "vegetarian"],
+  },
+},
+```
+
+- The page lives at `/{publicApi.path}`, here `/recipes`. Set `list.path` for another URL, such as `/cookbook`. It cannot have parameters.
+- `pageSize` is how many records one page shows, from 1 to 50. The default is 12.
+- The search box works because `publicApi.searchableFields` is set. Without it, the page ignores `?q=`.
+
+</Step>
+
+<Step>
+
+### Claim the URL
+
+Add a page for the list path in your plugin's routes. `contentListSearch` reads the page's URL using the definition, so `?vegetarian=true` becomes a boolean and a misspelled `?difficulty=` is dropped instead of breaking the page:
+
+```ts title="plugins/example/src/routes.ts"
+import { contentListSearch } from "@vitnode/core/tanstack/content"; // [!code ++]
+
+import { recipeContentType } from "./content/recipe"; // [!code ++]
+
+export const routes = definePluginRoutes([
+  page("/recipes", { // [!code ++:5]
+    component: lazy(() => import("./pages/recipes-page")),
+    messages: ["@vitnode/example.recipes"],
+    search: contentListSearch(recipeContentType),
+  }),
+  page("/recipes/:slug", {
+    component: lazy(() => import("./pages/recipe-page")),
+    messages: ["@vitnode/example.recipes"],
+  }),
+]);
+```
+
+Like the record URL, the list URL is checked when you build. If no page serves `/recipes`, `dev` and `build` stop with `content-url-without-page` and point at `delivery.list.path`.
+
+</Step>
+
+<Step>
+
+### Write the page
+
+The loader turns the URL into an API query with `contentListQuery` and checks the answer with `contentListPage`. The component puts the search box, two filters, the cards and the page links together:
+
+```tsx title="plugins/example/src/pages/recipes-page.tsx"
+import type { PluginRoutePageProps } from "@vitnode/core/routing";
+import type { ContentListSearch } from "@vitnode/core/tanstack/content";
+
+import { contentDeliveryInternalPath } from "@vitnode/core/content";
+import { definePluginRoute } from "@vitnode/core/routing";
+import {
+  ContentCard,
+  ContentList,
+  ContentListEmpty,
+  ContentListFilter,
+  ContentListItem,
+  contentListPage,
+  contentListPageHead,
+  ContentListPagination,
+  contentListQuery,
+  ContentListSearchForm,
+} from "@vitnode/core/tanstack/content";
+import { fetcher } from "@vitnode/core/tanstack/fetcher";
+import { useTranslations } from "use-intl";
+import { z } from "zod";
+
+import { recipeContentType } from "@/content/recipe";
+
+const DIFFICULTIES = ["easy", "medium", "hard"] as const;
+
+const zodRecipeCard = z.object({
+  cookingTime: z.number(),
+  difficulty: z.enum(DIFFICULTIES),
+  slug: z.string(),
+  summary: z.string().nullable(),
+  title: z.string(),
+});
+
+const loadRecipes = async (search: ContentListSearch) => {
+  const response = await fetcher({
+    plugin: "@vitnode/example",
+    method: "get",
+    module: "content/recipes",
+    path: "/",
+    args: { query: contentListQuery(recipeContentType, search) },
+  });
+  if (response.status !== 200) {
+    throw new Error(`Listing recipes answered ${response.status}.`);
+  }
+
+  const { edges, pageInfo } = await response.json();
+
+  return contentListPage({
+    list: { edges: z.array(zodRecipeCard).parse(edges), pageInfo },
+    search,
+  });
+};
+
+type RecipesPageData = Awaited<ReturnType<typeof loadRecipes>>;
+
+export const route = definePluginRoute<RecipesPageData, ContentListSearch>({
+  load: async ({ search }) => await loadRecipes(search),
+  head: ({ search, t }) =>
+    contentListPageHead(recipeContentType, {
+      description: t("@vitnode/example.recipes.list.desc"),
+      search,
+      title: t("@vitnode/example.recipes.list.title"),
+    }),
+});
+
+const RecipesPage = ({
+  loaderData: { edges, pageInfo },
+  search,
+}: PluginRoutePageProps<RecipesPageData, ContentListSearch>) => {
+  const t = useTranslations("@vitnode/example.recipes");
+
+  return (
+    <div className="container mx-auto flex max-w-5xl flex-col gap-6 px-4 py-8 md:py-12">
+      <header className="flex flex-col gap-2">
+        <h1 className="text-foreground text-3xl font-semibold text-balance md:text-4xl">
+          {t("list.title")}
+        </h1>
+        <p className="text-muted-foreground text-lg leading-relaxed text-pretty">
+          {t("list.desc")}
+        </p>
+      </header>
+
+      <ContentListSearchForm
+        className="max-w-xl"
+        label={t("list.search")}
+        placeholder={t("list.search")}
+        search={search}
+      />
+
+      <div className="flex flex-col gap-4 md:flex-row md:gap-8">
+        <ContentListFilter
+          label={t("difficulty")}
+          name="difficulty"
+          options={DIFFICULTIES.map(value => ({
+            label: t(`level.${value}`),
+            value,
+          }))}
+          search={search}
+        />
+        <ContentListFilter
+          label={t("vegetarian")}
+          name="vegetarian"
+          options={[
+            { label: t("yes"), value: true },
+            { label: t("no"), value: false },
+          ]}
+          search={search}
+        />
+      </div>
+
+      {edges.length === 0 ? (
+        <ContentListEmpty
+          description={t("list.empty.desc")}
+          title={t("list.empty.title")}
+        />
+      ) : (
+        <ContentList>
+          {edges.map(recipe => (
+            <ContentListItem key={recipe.slug}>
+              <ContentCard
+                description={recipe.summary}
+                href={
+                  contentDeliveryInternalPath({
+                    definition: recipeContentType,
+                    slug: recipe.slug,
+                  }) ?? "/recipes"
+                }
+                meta={`${t("minutes", { count: recipe.cookingTime })} · ${t(`level.${recipe.difficulty}`)}`}
+                title={recipe.title}
+              />
+            </ContentListItem>
+          ))}
+        </ContentList>
+      )}
+
+      <ContentListPagination
+        page={pageInfo.currentPage ?? 1}
+        search={search}
+        totalPages={pageInfo.totalPages}
+      />
+    </div>
+  );
+};
+
+export default RecipesPage;
+```
+
+- The `response.status` check narrows the response to the `200` answer. Before it, `response.json()` is `unknown`, because the route can also answer `400`.
+- The public API returns rows typed loosely, so the Zod schema picks and checks the fields the cards use.
+- `contentDeliveryInternalPath` builds `/recipes/{slug}` from `delivery.path`, so the cards follow if you move the record pages.
+- `contentListPage` answers `404` for a page past the end, such as `?page=9` when there are two pages.
+
+</Step>
+
+<Step>
+
+### Add the page strings
+
+The page reuses the recipe strings from [Show content on a public page](/docs/dev/content-engine/content-delivery-and-seo#add-the-page-strings) and adds a `list` group to the same namespace:
+
+```json title="plugins/example/src/locales/en.json"
+{
+  "@vitnode/example": {
+    "recipes": {
+      "list": {
+        "title": "Recipes",
+        "desc": "Dishes our community cooks again and again.",
+        "search": "Search recipes",
+        "empty": {
+          "title": "No recipes found",
+          "desc": "Try another word, or clear the filters to see every recipe."
+        }
+      }
+    }
+  }
+}
+```
+
+The **Search** button, **All**, **Previous** and **Next** come from VitNode's own translations, so you do not add them.
+
+</Step>
+
+</Steps>
+
+## Check the result
+
+Run `pnpm build:plugins`, restart `pnpm dev` and open `http://localhost:3000/recipes`. Delivery adds no database columns, so there is nothing to migrate. The newest recipes come first, six to a page, with page links underneath:
+
+<ImgDocs
+  withoutBackground
+  className="*:max-w-full"
+  src={recipesList}
+  alt="Recipes list page with a search box, Difficulty and Vegetarian filters set to All, six recipe cards and page links 1, 2 and Next"
+/>
+
+Click **Easy** under **Difficulty** and **Yes** under **Vegetarian**. The URL becomes `/recipes?difficulty=easy&vegetarian=true`, only the matching recipes stay, and the page links disappear because everything fits on one page:
+
+<ImgDocs
+  withoutBackground
+  className="*:max-w-full"
+  src={recipesFiltered}
+  alt="Recipes list filtered to Easy and Vegetarian Yes, showing two cards: Shakshuka for two and Chickpea curry"
+/>
+
+Changing a filter or the search term always goes back to page 1, because page 2 of all recipes is not page 2 of the vegetarian ones. The draft recipe never appears, the same as in the public API.
+
+### What search engines see
+
+Only the plain first page is meant for search results. View the source of `/recipes` and `/recipes?vegetarian=true` to compare:
+
+| URL                        | `<head>`                                                       |
+| -------------------------- | -------------------------------------------------------------- |
+| `/recipes`                 | Canonical link to `/recipes`, plus one `hreflang` per language |
+| `/recipes?page=2`          | `<meta name="robots" content="noindex, follow">`               |
+| `/recipes?vegetarian=true` | `<meta name="robots" content="noindex, follow">`               |
+| `/recipes?q=risotto`       | `<meta name="robots" content="noindex, follow">`               |
+| `/recipes?page=9`          | The app's not-found page with a `404`                          |
+
+`noindex, follow` keeps the many filter combinations out of the index while crawlers still follow the cards to every recipe page. The links are plain `<a href>` elements, so they also work before JavaScript loads.
+
+## How the URL becomes an API request
+
+`contentListQuery` maps the page's URL onto the [public list route](/docs/dev/content-engine/public-api-and-caching#public-api-routes):
+
+| Page URL                   | Public API query            |
+| -------------------------- | --------------------------- |
+| `/recipes`                 | `?first=6`                  |
+| `/recipes?page=2`          | `?first=6&page=2`           |
+| `/recipes?q=risotto`       | `?first=6&search=risotto`   |
+| `/recipes?vegetarian=true` | `?first=6&vegetarian=true`  |
+
+Parameters the content type did not declare, such as `?utm_source=newsletter`, are dropped before the request.
+
+## Related
+
+- [List page reference](/docs/dev/content-engine/list-pages-reference): every helper and component with its props.
+- [Content type reference](/docs/dev/content-engine/reference#delivery): every `delivery.list` option.
diff --git a/apps/web/content/docs/dev/content-engine/meta.json b/apps/web/content/docs/dev/content-engine/meta.json
index 478d4978a6..6209bd227c 100644
--- a/apps/web/content/docs/dev/content-engine/meta.json
+++ b/apps/web/content/docs/dev/content-engine/meta.json
@@ -8,6 +8,7 @@
     "defining-a-content-type",
     "public-api-and-caching",
     "content-delivery-and-seo",
+    "list-pages",
     "---Model your content---",
     "relations-and-advanced-modeling",
     "localization",
@@ -18,6 +19,7 @@
     "production-and-security",
     "---Reference---",
     "reference",
+    "list-pages-reference",
     "fields",
     "database-and-migrations",
     "plugin-registration"
diff --git a/apps/web/content/docs/dev/content-engine/recipes-list-filtered.png b/apps/web/content/docs/dev/content-engine/recipes-list-filtered.png
new file mode 100644
index 0000000000..c55cf00c6a
Binary files /dev/null and b/apps/web/content/docs/dev/content-engine/recipes-list-filtered.png differ
diff --git a/apps/web/content/docs/dev/content-engine/recipes-list-page.png b/apps/web/content/docs/dev/content-engine/recipes-list-page.png
new file mode 100644
index 0000000000..722369e395
Binary files /dev/null and b/apps/web/content/docs/dev/content-engine/recipes-list-page.png differ
diff --git a/apps/web/content/docs/dev/content-engine/reference.mdx b/apps/web/content/docs/dev/content-engine/reference.mdx
index 70a7d16bbf..ec98112e03 100644
--- a/apps/web/content/docs/dev/content-engine/reference.mdx
+++ b/apps/web/content/docs/dev/content-engine/reference.mdx
@@ -51,6 +51,7 @@ To turn a feature off, leave its block out. The `enabled` keys accept only `true
 | `delivery`                   | `publicApi`                                                  |
 | `delivery.redirects`         | `editorial`, and a localized slug on a localized type        |
 | `delivery.sitemap`           | `publication`                                                |
+| `delivery.list.filters`      | each field in `publicApi.filterableFields`                   |
 | `delivery.hreflang`          | `localization`                                               |
 | `editorial.preview`          | `publicApi`                                                  |
 | `editorial.scheduling`       | `publication`                                                |
@@ -108,6 +109,10 @@ How these options look on screen is covered in [Customize the AdminCP](/docs/dev
 | `sitemap.changeFrequency`      | `"always"` … `"never"`  |                             |                                                                             |
 | `sitemap.priority`             | `number` from 0 to 1    |                             |                                                                             |
 | `hreflang.xDefault`            | `"defaultLocale"`       |                             | Reports an `x-default` alternate in the API metadata                        |
+| `list.enabled`                 | `boolean`               | `false`                     | Adds a public [list page](/docs/dev/content-engine/list-pages)              |
+| `list.path`                    | `string`                | `/{publicApi.path}`         | The list page's English route. No parameters, not under `/admin` or `/api`  |
+| `list.pageSize`                | `number` from 1 to 50   | `12`                        | Records per page                                                            |
+| `list.filters`                 | field names             | `[]`                        | Filters the page reads from its URL. Each must be in `publicApi.filterableFields` |
 
 Every SEO field must be in `publicApi.fields`. A localized type also needs `"id"` there.
 
diff --git a/apps/web/src/locales/@vitnode/blog/pl.json b/apps/web/src/locales/@vitnode/blog/pl.json
index 7aeba7cf82..fe3ff329f4 100644
--- a/apps/web/src/locales/@vitnode/blog/pl.json
+++ b/apps/web/src/locales/@vitnode/blog/pl.json
@@ -129,6 +129,19 @@
     "title": "Blog",
     "post": {
       "published": "Opublikowano"
+    },
+    "list": {
+      "title": "Blog",
+      "desc": "Nowości, poradniki i historie od naszego zespołu.",
+      "search": "Szukaj artykułów",
+      "empty": {
+        "title": "Nie ma jeszcze artykułów",
+        "desc": "Zajrzyj wkrótce - pierwszy jest już w drodze."
+      },
+      "no_results": {
+        "title": "Żaden artykuł nie pasuje do wyszukiwania",
+        "desc": "Spróbuj innego słowa albo wyczyść wyszukiwanie, aby zobaczyć wszystkie artykuły."
+      }
     }
   },
   "@vitnode/blog:categories": "Kategorie",
diff --git a/apps/web/src/locales/@vitnode/core/pl.json b/apps/web/src/locales/@vitnode/core/pl.json
index 5c2329ada1..8aa2a903bf 100644
--- a/apps/web/src/locales/@vitnode/core/pl.json
+++ b/apps/web/src/locales/@vitnode/core/pl.json
@@ -2626,7 +2626,9 @@
           }
         }
       },
-      "unsaved_changes": "Niezapisane zmiany"
+      "unsaved_changes": "Niezapisane zmiany",
+      "search": "Szukaj",
+      "all": "Wszystkie"
     },
     "navigation": {
       "discover": {
diff --git a/packages/vitnode/src/content/define.ts b/packages/vitnode/src/content/define.ts
index 41366dffe0..fd82c483c5 100644
--- a/packages/vitnode/src/content/define.ts
+++ b/packages/vitnode/src/content/define.ts
@@ -189,7 +189,8 @@ export const defineContentType = <
         ContentEditorialEnabled<TEditorial>,
         ContentDeliveryTitleField<TFields, TPublicField>,
         ContentDeliveryDescriptionField<TFields, TPublicField>,
-        ContentDeliveryNoIndexField<TFields, TPublicField>
+        ContentDeliveryNoIndexField<TFields, TPublicField>,
+        TPublicField
       >
     | { enabled: false } = { enabled: false },
   TPublicPath extends string = string,
diff --git a/packages/vitnode/src/content/delivery.test-d.ts b/packages/vitnode/src/content/delivery.test-d.ts
index a94259d684..f9e3b56990 100644
--- a/packages/vitnode/src/content/delivery.test-d.ts
+++ b/packages/vitnode/src/content/delivery.test-d.ts
@@ -68,6 +68,19 @@ const plainType = defineContentType({
 });
 
 describe("delivery configuration", () => {
+  it("lets a list page filter only by a public field", () => {
+    defineContentType({
+      ...shared,
+      id: "typed.private-filter",
+      delivery: {
+        enabled: true,
+        // @ts-expect-error - `internalCode` is not in publicApi.fields.
+        list: { enabled: true, filters: ["internalCode"] },
+      },
+      tableName: "typed_private_filter",
+    });
+  });
+
   it("keeps the `enabled` literal, so every conditional resolves", () => {
     expectTypeOf(deliveredType.delivery.enabled).toEqualTypeOf<true>();
     expectTypeOf(plainType.delivery.enabled).toEqualTypeOf<false>();
diff --git a/packages/vitnode/src/content/delivery.test.ts b/packages/vitnode/src/content/delivery.test.ts
index 9120074df7..27dcecad46 100644
--- a/packages/vitnode/src/content/delivery.test.ts
+++ b/packages/vitnode/src/content/delivery.test.ts
@@ -2,6 +2,8 @@ import { describe, expect, it } from "vitest";
 
 import { testContentLocaleRouting } from "@/tests/content-fixtures";
 
+import type { ContentDeliveryListConfig } from "./types";
+
 import { defineContentType } from "./define";
 import {
   contentDeliveryHreflang,
@@ -68,6 +70,13 @@ describe("delivery definition validation", () => {
     expect(plainType.delivery).toStrictEqual({
       enabled: false,
       hreflang: { xDefault: null },
+      list: {
+        enabled: false,
+        filters: [],
+        pageSize: 12,
+        path: "",
+        searchable: false,
+      },
       path: "",
       redirects: { enabled: false },
       seo: {
@@ -618,6 +627,127 @@ describe("delivery.path", () => {
   });
 });
 
+describe("delivery.list", () => {
+  const listFields = {
+    ...fields,
+    level: field.enum({ defaultValue: "easy", values: ["easy", "hard"] }),
+  };
+  const listPublicApi = {
+    ...publicApi,
+    fields: [...publicApi.fields, "hidden", "views", "level"],
+    filterableFields: ["hidden", "views", "level"],
+    searchableFields: ["title"],
+  } as const;
+  // Typed as `never` filters so a runtime-only refusal can still be asserted;
+  // the field names themselves are checked by the types elsewhere.
+  const withList = (list: ContentDeliveryListConfig) =>
+    defineContentType({
+      ...base,
+      id: "delivery.listed",
+      delivery: {
+        enabled: true,
+        list: list as ContentDeliveryListConfig<never>,
+      },
+      fields: listFields,
+      publicApi: listPublicApi,
+      tableName: "delivery_listed",
+    });
+
+  it("defaults the page to the public API segment with 12 records", () => {
+    const type = withList({ enabled: true });
+
+    expect(type.delivery.list).toStrictEqual({
+      enabled: true,
+      filters: [],
+      pageSize: 12,
+      path: "/articles",
+      searchable: true,
+    });
+  });
+
+  it("is off when the content type declares no list", () => {
+    expect(articleType.delivery.list.enabled).toBe(false);
+  });
+
+  it("records how each filter is read from the URL", () => {
+    const type = withList({
+      enabled: true,
+      filters: ["hidden", "views", "level"],
+      pageSize: 24,
+      path: "/library",
+    });
+
+    expect(type.delivery.list.path).toBe("/library");
+    expect(type.delivery.list.pageSize).toBe(24);
+    expect(type.delivery.list.filters).toStrictEqual([
+      { kind: "boolean", name: "hidden", values: null },
+      { kind: "number", name: "views", values: null },
+      { kind: "enum", name: "level", values: ["easy", "hard"] },
+    ]);
+  });
+
+  it("is not searchable without publicApi.searchableFields", () => {
+    expect(
+      defineContentType({
+        ...base,
+        id: "delivery.unsearchable",
+        delivery: { enabled: true, list: { enabled: true } },
+        fields,
+        publicApi,
+        tableName: "delivery_unsearchable",
+      }).delivery.list.searchable,
+    ).toBe(false);
+  });
+
+  it("refuses a filter the public list route does not accept", () => {
+    expect(() => withList({ enabled: true, filters: ["title"] })).toThrow(
+      /"title", which is not in publicApi.filterableFields/,
+    );
+  });
+
+  it("refuses a filter listed twice", () => {
+    expect(() =>
+      withList({ enabled: true, filters: ["hidden", "hidden"] }),
+    ).toThrow(/lists "hidden" twice/);
+  });
+
+  it("refuses a page size the public API cannot return", () => {
+    expect(() => withList({ enabled: true, pageSize: 0 })).toThrow(
+      /pageSize is 0/,
+    );
+    expect(() => withList({ enabled: true, pageSize: 51 })).toThrow(
+      /pageSize is 51/,
+    );
+    expect(() => withList({ enabled: true, pageSize: 2.5 })).toThrow(
+      /pageSize is 2.5/,
+    );
+  });
+
+  it("refuses a path with a parameter", () => {
+    expect(() =>
+      withList({ enabled: true, path: "/articles/:category" }),
+    ).toThrow(/declares ":category"/);
+    expect(() => withList({ enabled: true, path: "/articles/*" })).toThrow(
+      /declares "\*"/,
+    );
+  });
+
+  it("refuses the AdminCP and API prefixes", () => {
+    expect(() => withList({ enabled: true, path: "/admin/list" })).toThrow(
+      /reserved for the AdminCP/,
+    );
+    expect(() => withList({ enabled: true, path: "/api" })).toThrow(
+      /reserved for the API/,
+    );
+  });
+
+  it("refuses a route the router could not parse", () => {
+    expect(() => withList({ enabled: true, path: "articles" })).toThrow(
+      /delivery.list.path is not a valid route path/,
+    );
+  });
+});
+
 describe("contentDeliveryPath", () => {
   it("writes the default locale without a prefix under as-needed", () => {
     expect(
diff --git a/packages/vitnode/src/content/delivery.ts b/packages/vitnode/src/content/delivery.ts
index 2de21e3745..8cd9e72ee4 100644
--- a/packages/vitnode/src/content/delivery.ts
+++ b/packages/vitnode/src/content/delivery.ts
@@ -7,6 +7,8 @@ import type {
   ContentSitemapChangeFrequency,
   DeliverableContentTypeDefinition,
   ResolvedContentDeliveryConfig,
+  ResolvedContentDeliveryListConfig,
+  ResolvedContentDeliveryListFilter,
   ResolvedContentPublicApiConfig,
 } from "./types";
 
@@ -16,6 +18,7 @@ import {
   CONTENT_DELIVERY_NO_INDEX_KINDS,
   CONTENT_DELIVERY_PATH_MAX_LENGTH,
   CONTENT_DELIVERY_TITLE_KINDS,
+  CONTENT_PUBLIC_MAX_PAGE_SIZE,
   isContentSitemapChangeFrequency,
 } from "./const";
 import { ContentEngineError } from "./errors";
@@ -32,10 +35,23 @@ const noIndexKinds: ReadonlySet<string> = new Set(
   CONTENT_DELIVERY_NO_INDEX_KINDS,
 );
 
+/** Records a list page shows when `delivery.list.pageSize` is not set. */
+export const CONTENT_DELIVERY_LIST_DEFAULT_PAGE_SIZE = 12;
+
+/** The disabled default every content type without `delivery.list` carries. */
+export const contentDeliveryListDisabled: ResolvedContentDeliveryListConfig = {
+  enabled: false,
+  filters: [],
+  pageSize: CONTENT_DELIVERY_LIST_DEFAULT_PAGE_SIZE,
+  path: "",
+  searchable: false,
+};
+
 /** The disabled default every content type without `delivery` carries. */
 export const contentDeliveryDisabled: ResolvedContentDeliveryConfig<false> = {
   enabled: false,
   hreflang: { xDefault: null },
+  list: contentDeliveryListDisabled,
   path: "",
   redirects: { enabled: false },
   seo: {
@@ -208,6 +224,138 @@ const resolveContentDeliveryPath = ({
   return parsed.path;
 };
 
+const resolveContentDeliveryListPath = ({
+  id,
+  path,
+  publicPath,
+}: {
+  id: string;
+  path: string | undefined;
+  publicPath: string;
+}): string => {
+  if (path === undefined) return `/${publicPath}`;
+
+  if (
+    typeof path !== "string" ||
+    path.length > CONTENT_DELIVERY_PATH_MAX_LENGTH
+  ) {
+    throw new ContentEngineError(
+      `delivery.list.path must be a string of at most ${CONTENT_DELIVERY_PATH_MAX_LENGTH} characters.`,
+      { contentTypeId: id },
+    );
+  }
+
+  const parsed = parseRoutePath(path);
+  if (!parsed.ok) {
+    throw new ContentEngineError(
+      `delivery.list.path is not a valid route path: ${parsed.reason}.`,
+      { contentTypeId: id },
+    );
+  }
+
+  const dynamic = parsed.segments.find(segment => segment.kind !== "static");
+  if (dynamic) {
+    throw new ContentEngineError(
+      `delivery.list.path "${path}" declares ${dynamic.kind === "param" ? `":${dynamic.name}"` : '"*"'}. A list page lists every published record, so its URL has no parameters - narrow it with \`filters\` and a query string instead.`,
+      { contentTypeId: id },
+    );
+  }
+
+  const [first] = parsed.segments;
+  if (first?.kind === "static" && RESERVED_DELIVERY_PREFIXES.has(first.value)) {
+    throw new ContentEngineError(
+      `delivery.list.path "${path}" starts with "/${first.value}", which is reserved for the ${first.value === "api" ? "API" : "AdminCP"} and never served as a public page.`,
+      { contentTypeId: id },
+    );
+  }
+
+  return parsed.path;
+};
+
+const listFilterOf = (
+  descriptor: ContentFieldDescriptor,
+  name: string,
+): ResolvedContentDeliveryListFilter => {
+  switch (descriptor.kind) {
+    case "boolean":
+      return { kind: "boolean", name, values: null };
+    case "enum":
+      return {
+        kind: "enum",
+        name,
+        values: [...(descriptor as { values: readonly string[] }).values],
+      };
+    case "number":
+      return { kind: "number", name, values: null };
+    case "relation":
+    case "user":
+      return { kind: "reference", name, values: null };
+    default:
+      return { kind: "text", name, values: null };
+  }
+};
+
+const resolveContentDeliveryList = ({
+  fields,
+  id,
+  list,
+  publicApi,
+}: {
+  fields: ContentFieldMap;
+  id: string;
+  list: ContentDeliveryConfig["list"];
+  publicApi: ResolvedContentPublicApiConfig;
+}): ResolvedContentDeliveryListConfig => {
+  if (!list?.enabled) return contentDeliveryListDisabled;
+
+  const pageSize = list.pageSize ?? CONTENT_DELIVERY_LIST_DEFAULT_PAGE_SIZE;
+  if (
+    !Number.isInteger(pageSize) ||
+    pageSize < 1 ||
+    pageSize > CONTENT_PUBLIC_MAX_PAGE_SIZE
+  ) {
+    throw new ContentEngineError(
+      `delivery.list.pageSize is ${pageSize}; it must be a whole number from 1 to ${CONTENT_PUBLIC_MAX_PAGE_SIZE}, the most the public list route returns in one page.`,
+      { contentTypeId: id },
+    );
+  }
+
+  const names = (list.filters ?? []).map(String);
+  const duplicate = names.find(
+    (name, position) => names.indexOf(name) !== position,
+  );
+  if (duplicate !== undefined) {
+    throw new ContentEngineError(
+      `delivery.list.filters lists "${duplicate}" twice.`,
+      { contentTypeId: id },
+    );
+  }
+
+  const filters = names.map(name => {
+    const target = resolveSeoTarget(fields, name);
+    if (!publicApi.filterableFields.includes(name) || target === null) {
+      throw new ContentEngineError(
+        `delivery.list.filters includes "${name}", which is not in publicApi.filterableFields. The page passes each filter to the public list route, which only accepts the fields that allowlist names.`,
+        { contentTypeId: id },
+      );
+    }
+
+    return listFilterOf(target.descriptor, name);
+  });
+
+  return {
+    enabled: true,
+    filters,
+    pageSize,
+    path: resolveContentDeliveryListPath({
+      id,
+      path: list.path,
+      publicPath: publicApi.path,
+    }),
+    searchable: publicApi.searchableFields.length > 0,
+  };
+};
+
 export const resolveContentDelivery = ({
   delivery,
   editorial,
@@ -428,6 +576,12 @@ export const resolveContentDelivery = ({
   return {
     enabled: true,
     hreflang: { xDefault: delivery.hreflang?.xDefault ?? null },
+    list: resolveContentDeliveryList({
+      fields,
+      id,
+      list: delivery.list,
+      publicApi,
+    }),
     path,
     redirects: { enabled: redirects },
     seo: {
diff --git a/packages/vitnode/src/content/index.ts b/packages/vitnode/src/content/index.ts
index a4a3cb8e2e..a8608d76d8 100644
--- a/packages/vitnode/src/content/index.ts
+++ b/packages/vitnode/src/content/index.ts
@@ -171,10 +171,12 @@ export {
 } from "./const";
 export { defineContentType } from "./define";
 export {
+  CONTENT_DELIVERY_LIST_DEFAULT_PAGE_SIZE,
   contentDeliveryAlternateHref,
   contentDeliveryDisabled,
   contentDeliveryHreflang,
   contentDeliveryInternalPath,
+  contentDeliveryListDisabled,
   contentDeliveryOpenGraph,
   contentDeliveryPath,
   contentDeliveryPublicUrl,
@@ -364,6 +366,8 @@ export type {
   ContentDeliveryDescriptionField,
   ContentDeliveryEnabled,
   ContentDeliveryHreflangConfig,
+  ContentDeliveryListConfig,
+  ContentDeliveryListFilterKind,
   ContentDeliveryNoIndexField,
   ContentDeliveryOpenGraphConfig,
   ContentDeliveryRedirectsConfig,
@@ -443,6 +447,8 @@ export type {
   PublicFilterableContentFieldName,
   ResolvedContentAdminConfig,
   ResolvedContentDeliveryConfig,
+  ResolvedContentDeliveryListConfig,
+  ResolvedContentDeliveryListFilter,
   ResolvedContentDeliverySeoConfig,
   ResolvedContentEditorialConfig,
   ResolvedContentIndex,
diff --git a/packages/vitnode/src/content/public-urls.ts b/packages/vitnode/src/content/public-urls.ts
index 77fbef28d7..07712218c8 100644
--- a/packages/vitnode/src/content/public-urls.ts
+++ b/packages/vitnode/src/content/public-urls.ts
@@ -10,7 +10,10 @@ export type ContentUrlErrorCode =
   | "incomplete-content-types"
   | "invalid-content-types-module";
 
-export type ContentUrlSetting = "delivery.path" | "search.pathTemplate";
+export type ContentUrlSetting =
+  | "delivery.list.path"
+  | "delivery.path"
+  | "search.pathTemplate";
 
 export interface ContentUrlErrorDetails {
   code: ContentUrlErrorCode;
@@ -39,7 +42,12 @@ export class ContentUrlError extends Error {
 }
 
 export interface ContentUrlDefinition {
-  delivery: { enabled: boolean; path: string };
+  delivery: {
+    enabled: boolean;
+    /** Optional so a definition built before list pages existed still reads. */
+    list?: { enabled: boolean; path: string };
+    path: string;
+  };
   id: string;
   search: { enabled: boolean; pathTemplate: string };
 }
@@ -63,6 +71,15 @@ export const contentPublicUrls = (
     });
   }
 
+  const list = definition.delivery.list;
+  if (definition.delivery.enabled && list?.enabled && list.path !== "") {
+    urls.push({
+      declared: list.path,
+      routePath: list.path,
+      setting: "delivery.list.path",
+    });
+  }
+
   if (definition.search.enabled && definition.search.pathTemplate !== "") {
     urls.push({
       declared: definition.search.pathTemplate,
diff --git a/packages/vitnode/src/content/types.ts b/packages/vitnode/src/content/types.ts
index a9cfb7b5a1..bd0eaf2bdd 100644
--- a/packages/vitnode/src/content/types.ts
+++ b/packages/vitnode/src/content/types.ts
@@ -1341,6 +1341,48 @@ export interface ContentDeliveryRedirectsConfig {
   enabled: true;
 }
 
+/**
+ * A public page listing the published records, such as `/blog`.
+ *
+ * The page reads `?page=`, `?q=` (when `publicApi.searchableFields` is set) and
+ * one parameter per field in `filters` from its URL, and asks the public list
+ * route for exactly that. Anything else in the URL is ignored.
+ */
+export interface ContentDeliveryListConfig<TFilter extends string = string> {
+  enabled: true;
+  /** Fields from `publicApi.filterableFields` the page reads from its URL. */
+  filters?: readonly TFilter[];
+  /** Records per page, 1-50. Defaults to 12. */
+  pageSize?: number;
+  /** The page's English route, with no parameters. Defaults to `/{publicApi.path}`. */
+  path?: string;
+}
+
+/** How a list page reads one filter from its URL. */
+export type ContentDeliveryListFilterKind =
+  | "boolean"
+  | "enum"
+  | "number"
+  | "reference"
+  | "text";
+
+export interface ResolvedContentDeliveryListFilter {
+  kind: ContentDeliveryListFilterKind;
+  name: string;
+  /** The allowed values of an `enum` filter, `null` for every other kind. */
+  values: null | readonly string[];
+}
+
+/** `delivery.list` after `defineContentType` has filled in every default. */
+export interface ResolvedContentDeliveryListConfig {
+  enabled: boolean;
+  filters: readonly ResolvedContentDeliveryListFilter[];
+  pageSize: number;
+  path: string;
+  /** Whether the page passes `?q=` to the API, from `publicApi.searchableFields`. */
+  searchable: boolean;
+}
+
 export interface ContentDeliverySitemapConfig {
   /** One of the seven `changefreq` values the protocol defines. */
   changeFrequency?: ContentSitemapChangeFrequency;
@@ -1385,9 +1427,11 @@ export interface ContentDeliveryConfig<
   TTitle extends string = string,
   TDescription extends string = string,
   TNoIndex extends string = string,
+  TFilter extends string = string,
 > {
   enabled: TPublicEnabled extends true ? true : never;
   hreflang?: ContentDeliveryHreflangConfig;
+  list?: ContentDeliveryListConfig<TFilter> | { enabled: false };
   path?: string;
 
   redirects?: TPublicEnabled extends true
@@ -1424,6 +1468,7 @@ export interface ResolvedContentDeliveryConfig<
 > {
   enabled: TEnabled;
   hreflang: { xDefault: "defaultLocale" | null };
+  list: ResolvedContentDeliveryListConfig;
   path: string;
   redirects: { enabled: boolean };
   seo: ResolvedContentDeliverySeoConfig;
diff --git a/packages/vitnode/src/framework/plugin-routes/content-urls.test.ts b/packages/vitnode/src/framework/plugin-routes/content-urls.test.ts
index 1802bd9d13..469bc02747 100644
--- a/packages/vitnode/src/framework/plugin-routes/content-urls.test.ts
+++ b/packages/vitnode/src/framework/plugin-routes/content-urls.test.ts
@@ -157,6 +157,52 @@ describe("content URLs served by page routes", () => {
     expect(error.message).toContain('Declared in "@vitnode/blog/content".');
   });
 
+  it("fails on a delivery.list.path no page serves", () => {
+    const error = failureOf(() =>
+      compilePluginRoutes({
+        contentUrls: [
+          blogContent({
+            ...BLOG_POST,
+            delivery: {
+              ...BLOG_POST.delivery,
+              list: { enabled: true, path: "/blog" },
+            },
+          }),
+        ],
+        sources: [blogPage()],
+      }),
+    );
+
+    expect(error.code).toBe("content-url-without-page");
+    expect(error.setting).toBe("delivery.list.path");
+    expect(error.pattern).toBe("/blog");
+    expect(error.message).toContain('Add a page route at "/blog"');
+    expect(error.message).toContain("`list: { enabled: false }`");
+  });
+
+  it("accepts a delivery.list.path a plugin page serves", () => {
+    expect(() =>
+      compilePluginRoutes({
+        contentUrls: [
+          blogContent({
+            ...BLOG_POST,
+            delivery: {
+              ...BLOG_POST.delivery,
+              list: { enabled: true, path: "/blog" },
+            },
+          }),
+        ],
+        sources: [
+          routesOf(
+            "@vitnode/blog",
+            page("/blog", { component: lazyPage() }),
+            page("/blog/:slug", { component: lazyPage() }),
+          ),
+        ],
+      }),
+    ).not.toThrow();
+  });
+
   it("fails on a search.pathTemplate no page serves", () => {
     const error = failureOf(() =>
       compilePluginRoutes({
diff --git a/packages/vitnode/src/framework/plugin-routes/content-urls.ts b/packages/vitnode/src/framework/plugin-routes/content-urls.ts
index e57af8a79b..4161a6513a 100644
--- a/packages/vitnode/src/framework/plugin-routes/content-urls.ts
+++ b/packages/vitnode/src/framework/plugin-routes/content-urls.ts
@@ -40,6 +40,7 @@ export interface AssertContentUrlsHavePagesOptions {
 }
 
 const disableHint: Record<ContentUrlSetting, string> = {
+  "delivery.list.path": "turn the list page off (`list: { enabled: false }`)",
   "delivery.path": "turn delivery off (`delivery: { enabled: false }`)",
   "search.pathTemplate": "turn search off for this content type",
 };
diff --git a/packages/vitnode/src/locales/en.json b/packages/vitnode/src/locales/en.json
index 82473aa549..7d60e16f29 100644
--- a/packages/vitnode/src/locales/en.json
+++ b/packages/vitnode/src/locales/en.json
@@ -643,7 +643,9 @@
           }
         }
       },
-      "unsaved_changes": "Unsaved changes"
+      "unsaved_changes": "Unsaved changes",
+      "search": "Search",
+      "all": "All"
     },
     "navigation": {
       "discover": {
diff --git a/packages/vitnode/src/routing/module.ts b/packages/vitnode/src/routing/module.ts
index 2169799f70..4d88d52280 100644
--- a/packages/vitnode/src/routing/module.ts
+++ b/packages/vitnode/src/routing/module.ts
@@ -1,5 +1,8 @@
 /** What a crawler may do with a plugin page. */
-export type PluginRouteRobots = "index, follow" | "noindex, nofollow";
+export type PluginRouteRobots =
+  | "index, follow"
+  | "noindex, follow"
+  | "noindex, nofollow";
 
 export interface PluginRouteHead {
   alternates?: Readonly<Record<string, string>>;
diff --git a/packages/vitnode/src/tanstack/content/index.ts b/packages/vitnode/src/tanstack/content/index.ts
index 5b17ca0a4c..a4ef7c855b 100644
--- a/packages/vitnode/src/tanstack/content/index.ts
+++ b/packages/vitnode/src/tanstack/content/index.ts
@@ -8,3 +8,30 @@ export {
   contentDeliveryPageHead,
   contentPageItem,
 } from "./delivery-page";
+export type { ContentCardImage, ContentListFilterOption } from "./list";
+export {
+  ContentCard,
+  ContentList,
+  ContentListEmpty,
+  ContentListFilter,
+  ContentListItem,
+  contentListPageNumbers,
+  ContentListPagination,
+  ContentListSearchForm,
+} from "./list";
+export type {
+  ContentListDefinition,
+  ContentListFilterValue,
+  ContentListQuery,
+  ContentListResponse,
+  ContentListSearch,
+} from "./list-page";
+export {
+  CONTENT_LIST_SEARCH_MAX_LENGTH,
+  contentListPage,
+  contentListPageHead,
+  contentListQuery,
+  contentListSearch,
+  isContentListIndexable,
+  nextContentListSearch,
+} from "./list-page";
diff --git a/packages/vitnode/src/tanstack/content/list-page.test.ts b/packages/vitnode/src/tanstack/content/list-page.test.ts
new file mode 100644
index 0000000000..2ec5791299
--- /dev/null
+++ b/packages/vitnode/src/tanstack/content/list-page.test.ts
@@ -0,0 +1,222 @@
+// @vitest-environment node
+import { isNotFound } from "@tanstack/react-router";
+import { describe, expect, it } from "vitest";
+
+import type { ContentListDefinition } from "./list-page";
+
+import {
+  contentListPage,
+  contentListPageHead,
+  contentListQuery,
+  contentListSearch,
+  nextContentListSearch,
+} from "./list-page";
+
+const recipes: ContentListDefinition = {
+  delivery: {
+    list: {
+      enabled: true,
+      filters: [
+        { kind: "boolean", name: "vegetarian", values: null },
+        { kind: "enum", name: "difficulty", values: ["easy", "hard"] },
+        { kind: "number", name: "cookingTime", values: null },
+        { kind: "reference", name: "category", values: null },
+        { kind: "text", name: "cuisine", values: null },
+      ],
+      pageSize: 12,
+      path: "/recipes",
+      searchable: true,
+    },
+  },
+};
+
+const unsearchable: ContentListDefinition = {
+  delivery: { list: { ...recipes.delivery.list, searchable: false } },
+};
+
+const thrownBy = (run: () => unknown): unknown => {
+  try {
+    run();
+  } catch (error) {
+    return error;
+  }
+
+  throw new Error("Expected the list check to throw.");
+};
+
+describe("contentListSearch", () => {
+  const read = contentListSearch(recipes);
+
+  it("reads nothing from a plain URL, so the first page has one address", () => {
+    expect(read({})).toStrictEqual({});
+    expect(read({ page: 1 })).toStrictEqual({});
+  });
+
+  it("reads the page, the term and every declared filter", () => {
+    expect(
+      read({
+        category: "7",
+        cookingTime: "30",
+        cuisine: " Italian ",
+        difficulty: "easy",
+        page: "3",
+        q: "  risotto ",
+        vegetarian: "true",
+      }),
+    ).toStrictEqual({
+      category: 7,
+      cookingTime: 30,
+      cuisine: "Italian",
+      difficulty: "easy",
+      page: 3,
+      q: "risotto",
+      vegetarian: true,
+    });
+  });
+
+  it("accepts the values the router already parsed from JSON", () => {
+    expect(read({ page: 2, q: 404, vegetarian: false })).toStrictEqual({
+      page: 2,
+      q: "404",
+      vegetarian: false,
+    });
+  });
+
+  it("drops values it cannot use instead of failing", () => {
+    expect(
+      read({
+        category: "-1",
+        cookingTime: "soon",
+        difficulty: "impossible",
+        page: "two",
+        q: "   ",
+        utm_source: "newsletter",
+        vegetarian: "yes",
+      }),
+    ).toStrictEqual({});
+  });
+
+  it("ignores a term when the content type has nothing to search", () => {
+    expect(contentListSearch(unsearchable)({ q: "risotto" })).toStrictEqual({});
+  });
+
+  it("cuts a long term to the length the page passes on", () => {
+    expect(read({ q: "a".repeat(400) }).q).toHaveLength(256);
+  });
+});
+
+describe("contentListQuery", () => {
+  it("asks for one page of the declared size", () => {
+    expect(contentListQuery(recipes, {})).toStrictEqual({ first: "12" });
+  });
+
+  it("passes the page, the term and the filters as strings", () => {
+    expect(
+      contentListQuery(recipes, {
+        category: 7,
+        page: 2,
+        q: "risotto",
+        vegetarian: true,
+      }),
+    ).toStrictEqual({
+      category: "7",
+      first: "12",
+      page: "2",
+      search: "risotto",
+      vegetarian: "true",
+    });
+  });
+
+  it("passes only declared filters and no term when search is off", () => {
+    expect(
+      contentListQuery(unsearchable, { author: 3, q: "risotto" }),
+    ).toStrictEqual({ first: "12" });
+  });
+});
+
+describe("contentListPage", () => {
+  const list = (currentPage: number, totalPages: number) => ({
+    edges: [],
+    pageInfo: { currentPage, totalPages },
+  });
+
+  it("hands back the list it was given", () => {
+    const loaded = list(2, 3);
+
+    expect(contentListPage({ list: loaded, search: { page: 2 } })).toBe(loaded);
+  });
+
+  it("answers 404 for a page past the end", () => {
+    // The API clamps `?page=9` onto the last page it has.
+    expect(
+      isNotFound(
+        thrownBy(() =>
+          contentListPage({ list: list(3, 3), search: { page: 9 } }),
+        ),
+      ),
+    ).toBe(true);
+  });
+
+  it("keeps an empty first page, which is a list with nothing in it yet", () => {
+    expect(() =>
+      contentListPage({ list: list(1, 0), search: {} }),
+    ).not.toThrow();
+  });
+});
+
+describe("contentListPageHead", () => {
+  const locales = ["en", "pl"];
+
+  it("indexes the plain first page with one alternate per language", () => {
+    expect(
+      contentListPageHead(recipes, {
+        description: "Every recipe we cooked.",
+        locales,
+        search: {},
+        title: "Recipes",
+      }),
+    ).toStrictEqual({
+      alternates: { en: "/recipes", pl: "/recipes" },
+      description: "Every recipe we cooked.",
+      title: "Recipes",
+    });
+  });
+
+  it.each([
+    ["a later page", { page: 2 }],
+    ["a search", { q: "risotto" }],
+    ["a filter", { vegetarian: true }],
+  ])("keeps %s out of the index but lets crawlers follow it", (_, search) => {
+    expect(
+      contentListPageHead(recipes, { locales, search, title: "Recipes" }),
+    ).toStrictEqual({ robots: "noindex, follow", title: "Recipes" });
+  });
+});
+
+describe("nextContentListSearch", () => {
+  it("goes back to the first page when a filter changes", () => {
+    expect(
+      nextContentListSearch({ page: 3, q: "soup" }, { vegetarian: true }),
+    ).toStrictEqual({ q: "soup", vegetarian: true });
+  });
+
+  it("keeps the term and filters when only the page changes", () => {
+    expect(
+      nextContentListSearch({ q: "soup", vegetarian: true }, { page: 2 }),
+    ).toStrictEqual({ page: 2, q: "soup", vegetarian: true });
+  });
+
+  it("removes a key set to undefined and never writes page 1", () => {
+    expect(
+      nextContentListSearch({ page: 2, vegetarian: true }, { page: 1 }),
+    ).toStrictEqual({ vegetarian: true });
+    expect(
+      nextContentListSearch(
+        { q: "soup", vegetarian: true },
+        {
+          vegetarian: undefined,
+        },
+      ),
+    ).toStrictEqual({ q: "soup" });
+  });
+});
diff --git a/packages/vitnode/src/tanstack/content/list-page.ts b/packages/vitnode/src/tanstack/content/list-page.ts
new file mode 100644
index 0000000000..c3132ec5e0
--- /dev/null
+++ b/packages/vitnode/src/tanstack/content/list-page.ts
@@ -0,0 +1,245 @@
+import { notFound } from "@tanstack/react-router";
+
+import type {
+  ResolvedContentDeliveryListConfig,
+  ResolvedContentDeliveryListFilter,
+} from "@/content/types";
+import type { PluginRouteHead } from "@/routing";
+
+import { getIntlRuntime } from "../i18n/runtime";
+
+/** The longest `?q=` a list page passes on to the API. */
+export const CONTENT_LIST_SEARCH_MAX_LENGTH = 256;
+
+const TEXT_FILTER_MAX_LENGTH = 255;
+
+/** The part of a content type a list page reads. A whole definition fits. */
+export interface ContentListDefinition {
+  delivery: { list: ResolvedContentDeliveryListConfig };
+}
+
+export type ContentListFilterValue = boolean | number | string;
+
+/**
+ * A list page's URL, after {@link contentListSearch} has read it.
+ *
+ * `page` is left out on the first page and `q` when nothing is searched, so the
+ * plain `/blog` is the one address of the first page. Every other key is a
+ * filter from `delivery.list.filters`.
+ */
+export interface ContentListSearch {
+  [filter: string]: ContentListFilterValue | undefined;
+  page?: number;
+  q?: string;
+}
+
+/** The query string a list page sends to the public list route. */
+export interface ContentListQuery {
+  [filter: string]: string | undefined;
+  first: string;
+  page?: string;
+  search?: string;
+}
+
+/** The part of the public list response a list page checks. */
+export interface ContentListResponse {
+  pageInfo: { currentPage: null | number; totalPages: number };
+}
+
+const asInteger = (value: unknown): number | undefined => {
+  const parsed =
+    typeof value === "number"
+      ? value
+      : typeof value === "string" && /^\d+$/.test(value)
+        ? Number(value)
+        : Number.NaN;
+
+  return Number.isSafeInteger(parsed) ? parsed : undefined;
+};
+
+const asText = (value: unknown, maxLength: number): string | undefined => {
+  if (typeof value !== "string" && typeof value !== "number") return undefined;
+
+  const text = String(value).trim().slice(0, maxLength).trim();
+
+  return text.length > 0 ? text : undefined;
+};
+
+const readFilter = (
+  filter: ResolvedContentDeliveryListFilter,
+  value: unknown,
+): ContentListFilterValue | undefined => {
+  switch (filter.kind) {
+    case "boolean":
+      if (value === true || value === "true") return true;
+      if (value === false || value === "false") return false;
+
+      return undefined;
+    case "enum":
+      return typeof value === "string" && filter.values?.includes(value)
+        ? value
+        : undefined;
+    case "number": {
+      const parsed = typeof value === "string" ? Number(value) : value;
+
+      return typeof parsed === "number" &&
+        Number.isFinite(parsed) &&
+        String(value).trim() !== ""
+        ? parsed
+        : undefined;
+    }
+    case "reference": {
+      const id = asInteger(value);
+
+      return id !== undefined && id > 0 ? id : undefined;
+    }
+    case "text":
+      return asText(value, TEXT_FILTER_MAX_LENGTH);
+  }
+};
+
+/**
+ * Builds a list page's `search` validator from its content type.
+ *
+ * Reads `page`, `q` and the declared filters, and drops anything it cannot use
+ * instead of failing: a stale bookmark or a tracking parameter still opens the
+ * page.
+ */
+export const contentListSearch =
+  ({ delivery: { list } }: ContentListDefinition) =>
+  (input: Record<string, unknown>): ContentListSearch => {
+    const search: ContentListSearch = {};
+
+    const page = asInteger(input.page);
+    if (page !== undefined && page > 1) search.page = page;
+
+    if (list.searchable) {
+      const q = asText(input.q, CONTENT_LIST_SEARCH_MAX_LENGTH);
+      if (q !== undefined) search.q = q;
+    }
+
+    for (const filter of list.filters) {
+      const value = readFilter(filter, input[filter.name]);
+      if (value !== undefined) search[filter.name] = value;
+    }
+
+    return search;
+  };
+
+/**
+ * Turns a list page's search into the query of the public list route.
+ *
+ * Spread it into `args.query` of the `fetcher` call that reads the list.
+ */
+export const contentListQuery = (
+  { delivery: { list } }: ContentListDefinition,
+  search: ContentListSearch,
+): ContentListQuery => {
+  const query: ContentListQuery = { first: String(list.pageSize) };
+
+  if (search.page !== undefined && search.page > 1) {
+    query.page = String(search.page);
+  }
+  if (list.searchable && search.q !== undefined) query.search = search.q;
+
+  for (const filter of list.filters) {
+    const value = search[filter.name];
+    if (value !== undefined) query[filter.name] = String(value);
+  }
+
+  return query;
+};
+
+/**
+ * Checks a list the page loaded against the page it asked for.
+ *
+ * The API answers a page past the end with the last page, which would put the
+ * same records under every higher `?page=`. This turns that into a `404`.
+ */
+export const contentListPage = <TList extends ContentListResponse>({
+  list,
+  search,
+}: {
+  list: TList;
+  search: ContentListSearch;
+}): TList => {
+  const requested = search.page ?? 1;
+
+  if (requested > 1 && list.pageInfo.currentPage !== requested) {
+    // oxlint-disable-next-line typescript/only-throw-error
+    throw notFound();
+  }
+
+  return list;
+};
+
+/** Whether the search is the plain first page, with no `q` and no filter. */
+export const isContentListIndexable = (search: ContentListSearch): boolean =>
+  Object.values(search).every(value => value === undefined);
+
+/**
+ * The `<head>` of a list page.
+ *
+ * Only the plain first page is indexed, with a canonical link and one alternate
+ * per language. Later pages and every search or filter result answer
+ * `noindex, follow`: a crawler skips the page but still follows its links to
+ * the records.
+ */
+export const contentListPageHead = (
+  { delivery: { list } }: ContentListDefinition,
+  {
+    description,
+    locales,
+    search,
+    title,
+  }: {
+    description?: string;
+    /** The languages the page is served in. Defaults to every app locale. */
+    locales?: readonly string[];
+    search: ContentListSearch | undefined;
+    title?: string;
+  },
+): PluginRouteHead => {
+  const head: PluginRouteHead = {};
+
+  if (title !== undefined) head.title = title;
+  if (description !== undefined) head.description = description;
+
+  if (search !== undefined && !isContentListIndexable(search)) {
+    head.robots = "noindex, follow";
+
+    return head;
+  }
+
+  if (list.path === "") return head;
+
+  head.alternates = Object.fromEntries(
+    (locales ?? getIntlRuntime().localeRouting.locales).map(locale => [
+      locale,
+      list.path,
+    ]),
+  );
+
+  return head;
+};
+
+/**
+ * The search of a link that changes the list: a filter, the term or the page.
+ *
+ * `undefined` removes a key. Any change other than `page` goes back to the
+ * first page, because page 3 of one result set is not page 3 of another.
+ */
+export const nextContentListSearch = (
+  search: ContentListSearch,
+  changes: ContentListSearch,
+): ContentListSearch => {
+  const next: ContentListSearch = { ...search, ...changes };
+  if (!("page" in changes)) delete next.page;
+  if (next.page !== undefined && next.page <= 1) delete next.page;
+
+  for (const [key, value] of Object.entries(next)) {
+    if (value === undefined) delete next[key];
+  }
+
+  return next;
+};
diff --git a/packages/vitnode/src/tanstack/content/list.test.tsx b/packages/vitnode/src/tanstack/content/list.test.tsx
new file mode 100644
index 0000000000..71c984f795
--- /dev/null
+++ b/packages/vitnode/src/tanstack/content/list.test.tsx
@@ -0,0 +1,276 @@
+// @vitest-environment jsdom
+import {
+  createMemoryHistory,
+  createRootRoute,
+  createRoute,
+  createRouter,
+  Outlet,
+  RouterProvider,
+  useSearch,
+} from "@tanstack/react-router";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { describe, expect, it } from "vitest";
+
+import type { ContentListSearch } from "./list-page";
+
+import {
+  ContentCard,
+  ContentListEmpty,
+  ContentListFilter,
+  contentListPageNumbers,
+  ContentListPagination,
+  ContentListSearchForm,
+} from "./list";
+import { contentListSearch } from "./list-page";
+
+const validate = contentListSearch({
+  delivery: {
+    list: {
+      enabled: true,
+      filters: [{ kind: "boolean", name: "vegetarian", values: null }],
+      pageSize: 12,
+      path: "/recipes",
+      searchable: true,
+    },
+  },
+});
+
+const mount = async (
+  url: string,
+  Screen: (props: { search: ContentListSearch }) => React.ReactNode,
+) => {
+  const ListScreen = () => {
+    const search = useSearch({ strict: false });
+
+    return <Screen search={validate(search)} />;
+  };
+
+  const rootRoute = createRootRoute({ component: Outlet });
+  const listRoute = createRoute({
+    component: ListScreen,
+    getParentRoute: () => rootRoute,
+    path: "/recipes",
+  });
+  const router = createRouter({
+    history: createMemoryHistory({ initialEntries: [url] }),
+    routeTree: rootRoute.addChildren([listRoute]),
+  });
+
+  await act(async () => {
+    await router.load();
+  });
+  render(<RouterProvider router={router} />);
+
+  return router;
+};
+
+const currentSearch = (router: Awaited<ReturnType<typeof mount>>) =>
+  validate(router.state.location.search);
+
+describe("ContentCard", () => {
+  it("links the title to the record and keeps the image out of the tab order", async () => {
+    await mount("/recipes", () => (
+      <ContentCard
+        description="Eggs poached in a spicy tomato sauce."
+        href="/recipes/shakshuka"
+        image={{ alt: "A pan of shakshuka", src: "/shakshuka.webp" }}
+        meta="30 minutes"
+        title="Shakshuka"
+      />
+    ));
+
+    const title = await screen.findByRole("link", { name: "Shakshuka" });
+    expect(title.getAttribute("href")).toBe("/recipes/shakshuka");
+    expect(screen.getByRole("heading", { level: 2 }).textContent).toBe(
+      "Shakshuka",
+    );
+    expect(screen.getByText("30 minutes")).toBeTruthy();
+    expect(
+      screen.getByText("Eggs poached in a spicy tomato sauce."),
+    ).toBeTruthy();
+
+    const image = screen.getByAltText("A pan of shakshuka");
+    const imageLink = image.closest("a");
+    expect(imageLink?.getAttribute("tabindex")).toBe("-1");
+    expect(imageLink?.getAttribute("aria-hidden")).toBe("true");
+    // The image link is hidden, so assistive technology meets one link.
+    expect(screen.getAllByRole("link")).toHaveLength(1);
+  });
+});
+
+describe("ContentListEmpty", () => {
+  it("announces an empty list with the default text", async () => {
+    await mount("/recipes", () => <ContentListEmpty />);
+
+    const status = await screen.findByRole("status");
+    expect(status.textContent).toContain("core.global.no_results.title");
+  });
+});
+
+describe("contentListPageNumbers", () => {
+  it("shows every page of a short list", () => {
+    expect(contentListPageNumbers(2, 3)).toStrictEqual([1, 2, 3]);
+  });
+
+  it("keeps the ends and the neighbours of the current page", () => {
+    expect(contentListPageNumbers(5, 10)).toStrictEqual([
+      1,
+      null,
+      4,
+      5,
+      6,
+      null,
+      10,
+    ]);
+  });
+});
+
+describe("ContentListPagination", () => {
+  it("renders nothing when one page holds everything", async () => {
+    await mount("/recipes", ({ search }) => (
+      <ContentListPagination page={1} search={search} totalPages={1} />
+    ));
+
+    expect(screen.queryByRole("navigation")).toBeNull();
+  });
+
+  it("links every page and keeps the term and the filters", async () => {
+    await mount("/recipes?page=2&q=soup&vegetarian=true", ({ search }) => (
+      <ContentListPagination
+        page={search.page ?? 1}
+        search={search}
+        totalPages={3}
+      />
+    ));
+
+    const current = await screen.findByRole("link", { current: "page" });
+    expect(current.textContent).toBe("2");
+
+    const first = screen.getByRole("link", { name: "1" });
+    expect(first.getAttribute("href")).toBe("/recipes?q=soup&vegetarian=true");
+
+    const next = screen.getByRole("link", { name: "core.global.next_page" });
+    expect(next.getAttribute("href")).toBe(
+      "/recipes?page=3&q=soup&vegetarian=true",
+    );
+    expect(next.getAttribute("rel")).toBe("next");
+    expect(
+      screen.getByRole("link", { name: "core.global.previous_page" }),
+    ).toBeTruthy();
+  });
+
+  it("has no previous link on the first page and no next link on the last", async () => {
+    await mount("/recipes", ({ search }) => (
+      <ContentListPagination page={1} search={search} totalPages={2} />
+    ));
+
+    await screen.findByRole("navigation");
+    expect(
+      screen.queryByRole("link", { name: "core.global.previous_page" }),
+    ).toBeNull();
+    expect(
+      screen.getByRole("link", { name: "core.global.next_page" }),
+    ).toBeTruthy();
+  });
+});
+
+describe("ContentListFilter", () => {
+  const options = [
+    { label: "Vegetarian", value: true },
+    { label: "With meat", value: false },
+  ];
+
+  it("marks All as current until a value is chosen", async () => {
+    const router = await mount("/recipes?page=2", ({ search }) => (
+      <ContentListFilter
+        label="Diet"
+        name="vegetarian"
+        options={options}
+        search={search}
+      />
+    ));
+
+    expect(
+      (await screen.findByRole("navigation", { name: "Diet" })).tagName,
+    ).toBe("NAV");
+    expect(screen.getByRole("link", { current: "page" }).textContent).toBe(
+      "core.global.all",
+    );
+
+    await act(async () => {
+      fireEvent.click(screen.getByRole("link", { name: "Vegetarian" }));
+    });
+
+    // Back to the first page: page 2 of all recipes is not page 2 of these.
+    expect(currentSearch(router)).toStrictEqual({ vegetarian: true });
+    expect(screen.getByRole("link", { current: "page" }).textContent).toBe(
+      "Vegetarian",
+    );
+  });
+
+  it("clears the filter from the All link", async () => {
+    const router = await mount(
+      "/recipes?vegetarian=false&q=soup",
+      ({ search }) => (
+        <ContentListFilter
+          label="Diet"
+          name="vegetarian"
+          options={options}
+          search={search}
+        />
+      ),
+    );
+
+    await act(async () => {
+      fireEvent.click(
+        await screen.findByRole("link", { name: "core.global.all" }),
+      );
+    });
+
+    expect(currentSearch(router)).toStrictEqual({ q: "soup" });
+  });
+});
+
+describe("ContentListSearchForm", () => {
+  it("searches from the first page and keeps the active filters", async () => {
+    const router = await mount(
+      "/recipes?page=3&vegetarian=true",
+      ({ search }) => <ContentListSearchForm search={search} />,
+    );
+
+    const field = await screen.findByRole("searchbox", {
+      name: "core.global.search",
+    });
+    expect(
+      document.querySelector('input[type="hidden"][name="vegetarian"]'),
+    ).toBeTruthy();
+
+    fireEvent.change(field, { target: { value: "  risotto " } });
+    await act(async () => {
+      fireEvent.click(
+        screen.getByRole("button", { name: "core.global.search" }),
+      );
+    });
+
+    expect(currentSearch(router)).toStrictEqual({
+      q: "risotto",
+      vegetarian: true,
+    });
+  });
+
+  it("removes the term when the field is cleared", async () => {
+    const router = await mount("/recipes?q=soup", ({ search }) => (
+      <ContentListSearchForm search={search} />
+    ));
+
+    const field = await screen.findByRole("searchbox");
+    expect((field as HTMLInputElement).value).toBe("soup");
+
+    fireEvent.change(field, { target: { value: "" } });
+    await act(async () => {
+      fireEvent.submit(screen.getByRole("search"));
+    });
+
+    expect(currentSearch(router)).toStrictEqual({});
+  });
+});
diff --git a/packages/vitnode/src/tanstack/content/list.tsx b/packages/vitnode/src/tanstack/content/list.tsx
new file mode 100644
index 0000000000..5aa0996e8b
--- /dev/null
+++ b/packages/vitnode/src/tanstack/content/list.tsx
@@ -0,0 +1,438 @@
+import { Link, useNavigate } from "@tanstack/react-router";
+import { cn } from "cn";
+import { ChevronLeftIcon, ChevronRightIcon, SearchIcon } from "lucide-react";
+import React from "react";
+import { useTranslations } from "use-intl";
+
+import { Button, buttonVariants } from "@/components/ui/button";
+import {
+  InputGroup,
+  InputGroupAddon,
+  InputGroupInput,
+} from "@/components/ui/input-group";
+import {
+  Pagination,
+  PaginationContent,
+  PaginationEllipsis,
+  PaginationItem,
+} from "@/components/ui/pagination";
+
+import type { ContentListFilterValue, ContentListSearch } from "./list-page";
+
+import { nextContentListSearch } from "./list-page";
+
+/** A responsive grid of records: one column on phones, up to three on desktop. */
+export const ContentList = ({
+  className,
+  ...props
+}: React.ComponentProps<"ul">) => (
+  <ul
+    className={cn(
+      "grid grid-cols-1 gap-4 sm:grid-cols-2 lg:grid-cols-3",
+      className,
+    )}
+    data-slot="content-list"
+    {...props}
+  />
+);
+
+export const ContentListItem = ({
+  className,
+  ...props
+}: React.ComponentProps<"li">) => (
+  <li
+    className={cn("flex", className)}
+    data-slot="content-list-item"
+    {...props}
+  />
+);
+
+export interface ContentCardImage {
+  alt: string;
+  height?: null | number;
+  src: string;
+  width?: null | number;
+}
+
+/**
+ * One record in a list: an optional image, a line of meta such as the date,
+ * the title linking to the record's page and a short description.
+ *
+ * Only the title is a link for assistive technology. The image links to the
+ * same page for pointer users but is hidden from the tab order, so a keyboard
+ * user does not reach every record twice.
+ */
+export const ContentCard = ({
+  className,
+  description,
+  headingLevel = 2,
+  href,
+  image,
+  meta,
+  title,
+}: {
+  className?: string;
+  description?: null | string;
+  headingLevel?: 2 | 3;
+  /** The record's internal path, such as `/blog/hello-world`. */
+  href: string;
+  image?: ContentCardImage | null;
+  meta?: React.ReactNode;
+  title: string;
+}) => {
+  const Heading = headingLevel === 2 ? "h2" : "h3";
+
+  return (
+    <article
+      className={cn(
+        "bg-card text-card-foreground flex w-full flex-col overflow-hidden rounded-lg border",
+        className,
+      )}
+      data-slot="content-card"
+    >
+      {image ? (
+        <Link aria-hidden="true" tabIndex={-1} to={href}>
+          <img
+            alt={image.alt}
+            className="bg-muted aspect-video w-full object-cover"
+            height={image.height ?? undefined}
+            loading="lazy"
+            src={image.src}
+            width={image.width ?? undefined}
+          />
+        </Link>
+      ) : null}
+
+      <div className="flex flex-1 flex-col gap-2 p-4">
+        {meta ? (
+          <div className="text-muted-foreground text-sm leading-relaxed">
+            {meta}
+          </div>
+        ) : null}
+
+        <Heading className="text-lg leading-snug font-semibold text-balance">
+          <Link
+            className="focus-visible:ring-ring/50 rounded-sm outline-none hover:underline focus-visible:ring-3"
+            to={href}
+          >
+            {title}
+          </Link>
+        </Heading>
+
+        {description ? (
+          <p className="text-muted-foreground line-clamp-3 leading-relaxed text-pretty">
+            {description}
+          </p>
+        ) : null}
+      </div>
+    </article>
+  );
+};
+
+/** What a list shows when it has no records, or no records match. */
+export const ContentListEmpty = ({
+  className,
+  description,
+  title,
+}: {
+  className?: string;
+  description?: string;
+  title?: string;
+}) => {
+  const t = useTranslations("core.global");
+
+  return (
+    <div
+      className={cn(
+        "flex flex-col items-center gap-2 rounded-lg border border-dashed p-8 text-center",
+        className,
+      )}
+      data-slot="content-list-empty"
+      role="status"
+    >
+      <p className="text-foreground font-medium text-balance">
+        {title ?? t("no_results.title")}
+      </p>
+      <p className="text-muted-foreground leading-relaxed text-pretty">
+        {description ?? t("no_results.desc")}
+      </p>
+    </div>
+  );
+};
+
+const PAGE_WINDOW = 1;
+
+/**
+ * The router marks a link active - and sets its `aria-current` - when its
+ * search is a subset of the current one, so "All" would be current under every
+ * filter. Exact matching makes the router agree with the list's own state.
+ */
+const EXACT_MATCH = { exact: true } as const;
+
+/**
+ * The page numbers to show, with `null` where an ellipsis goes.
+ *
+ * Always the first and the last page, plus the neighbours of the current one,
+ * so a list of 40 pages still fits on a phone.
+ */
+export const contentListPageNumbers = (
+  page: number,
+  totalPages: number,
+): (null | number)[] => {
+  const numbers: (null | number)[] = [];
+
+  for (let current = 1; current <= totalPages; current++) {
+    const nearCurrent = Math.abs(current - page) <= PAGE_WINDOW;
+    if (current === 1 || current === totalPages || nearCurrent) {
+      numbers.push(current);
+    } else if (numbers.at(-1) !== null) {
+      numbers.push(null);
+    }
+  }
+
+  return numbers;
+};
+
+/** A stable key per entry: a page number, or the gap after one. */
+const pageNumberKey = (numbers: (null | number)[], position: number) =>
+  numbers[position] === null
+    ? `gap-after-${numbers[position - 1]}`
+    : `page-${numbers[position]}`;
+
+/**
+ * Page links for a list page.
+ *
+ * Plain links rather than buttons, so crawlers and readers without JavaScript
+ * reach every page. Renders nothing when everything fits on one page.
+ */
+export const ContentListPagination = ({
+  className,
+  page,
+  search,
+  totalPages,
+}: {
+  className?: string;
+  page: number;
+  search: ContentListSearch;
+  totalPages: number;
+}) => {
+  const t = useTranslations("core.global");
+
+  if (totalPages <= 1) return null;
+
+  const numbers = contentListPageNumbers(page, totalPages);
+  const pageLink = (target: number) =>
+    nextContentListSearch(search, { page: target });
+
+  return (
+    <Pagination className={className}>
+      <PaginationContent className="flex-wrap justify-center">
+        {page > 1 ? (
+          <PaginationItem>
+            <Link
+              activeOptions={EXACT_MATCH}
+              aria-label={t("previous_page")}
+              className={buttonVariants({ variant: "ghost" })}
+              rel="prev"
+              search={pageLink(page - 1)}
+              to="."
+            >
+              <ChevronLeftIcon aria-hidden="true" className="rtl:rotate-180" />
+              <span className="hidden sm:block">{t("previous")}</span>
+            </Link>
+          </PaginationItem>
+        ) : null}
+
+        {numbers.map((number, position) =>
+          number === null ? (
+            <PaginationItem key={pageNumberKey(numbers, position)}>
+              <PaginationEllipsis />
+            </PaginationItem>
+          ) : (
+            <PaginationItem key={pageNumberKey(numbers, position)}>
+              <Link
+                activeOptions={EXACT_MATCH}
+                aria-current={number === page ? "page" : undefined}
+                className={cn(
+                  buttonVariants({
+                    size: "icon",
+                    variant: number === page ? "outline" : "ghost",
+                  }),
+                  "w-auto min-w-9 px-2 tabular-nums",
+                )}
+                search={pageLink(number)}
+                to="."
+              >
+                {number}
+              </Link>
+            </PaginationItem>
+          ),
+        )}
+
+        {page < totalPages ? (
+          <PaginationItem>
+            <Link
+              activeOptions={EXACT_MATCH}
+              aria-label={t("next_page")}
+              className={buttonVariants({ variant: "ghost" })}
+              rel="next"
+              search={pageLink(page + 1)}
+              to="."
+            >
+              <span className="hidden sm:block">{t("next")}</span>
+              <ChevronRightIcon aria-hidden="true" className="rtl:rotate-180" />
+            </Link>
+          </PaginationItem>
+        ) : null}
+      </PaginationContent>
+    </Pagination>
+  );
+};
+
+/**
+ * The search box of a list page.
+ *
+ * A real `GET` form: without JavaScript it reloads the page with `?q=`, and
+ * with it the router navigates without a reload. Active filters travel along
+ * as hidden fields, and a new term goes back to the first page.
+ */
+export const ContentListSearchForm = ({
+  className,
+  label,
+  placeholder,
+  search,
+}: {
+  className?: string;
+  /** The accessible name of the field. Defaults to "Search". */
+  label?: string;
+  placeholder?: string;
+  search: ContentListSearch;
+}) => {
+  const t = useTranslations("core.global");
+  const navigate = useNavigate();
+  const id = React.useId();
+  const kept = Object.entries(search).filter(
+    ([key, value]) => key !== "page" && key !== "q" && value !== undefined,
+  );
+
+  return (
+    <form
+      className={cn("flex items-center gap-2", className)}
+      data-slot="content-list-search"
+      method="get"
+      onSubmit={event => {
+        event.preventDefault();
+        const q = new FormData(event.currentTarget).get("q");
+
+        void navigate({
+          search: nextContentListSearch(search, {
+            q: typeof q === "string" && q.trim() !== "" ? q.trim() : undefined,
+          }),
+          to: ".",
+        });
+      }}
+      role="search"
+    >
+      <label className="sr-only" htmlFor={id}>
+        {label ?? t("search")}
+      </label>
+      <InputGroup className="flex-1">
+        <InputGroupInput
+          defaultValue={search.q ?? ""}
+          id={id}
+          key={search.q ?? ""}
+          name="q"
+          placeholder={placeholder ?? t("search_placeholder")}
+          type="search"
+        />
+        <InputGroupAddon>
+          <SearchIcon aria-hidden="true" />
+        </InputGroupAddon>
+      </InputGroup>
+
+      {kept.map(([key, value]) => (
+        <input key={key} name={key} type="hidden" value={String(value)} />
+      ))}
+
+      <Button type="submit" variant="outline">
+        {t("search")}
+      </Button>
+    </form>
+  );
+};
+
+export interface ContentListFilterOption {
+  label: string;
+  value: ContentListFilterValue;
+}
+
+/**
+ * One filter of a list page: its name above a row of links.
+ *
+ * The first link clears the filter. The active option carries
+ * `aria-current="page"`, and choosing another goes back to the first page.
+ */
+export const ContentListFilter = ({
+  allLabel,
+  className,
+  label,
+  name,
+  options,
+  search,
+}: {
+  /** The text of the link that clears the filter. Defaults to "All". */
+  allLabel?: string;
+  className?: string;
+  /** The visible name of the filter, such as "Difficulty". */
+  label: string;
+  /** The filter's field name, as listed in `delivery.list.filters`. */
+  name: string;
+  options: readonly ContentListFilterOption[];
+  search: ContentListSearch;
+}) => {
+  const t = useTranslations("core.global");
+  const labelId = React.useId();
+  const active = search[name];
+  const chip = (isActive: boolean) =>
+    buttonVariants({ size: "sm", variant: isActive ? "default" : "outline" });
+
+  return (
+    <nav
+      aria-labelledby={labelId}
+      className={cn("flex flex-col gap-2", className)}
+      data-slot="content-filter"
+    >
+      <span className="text-muted-foreground text-sm font-medium" id={labelId}>
+        {label}
+      </span>
+      <ul className="flex flex-wrap items-center gap-2">
+        <li>
+          <Link
+            activeOptions={EXACT_MATCH}
+            aria-current={active === undefined ? "page" : undefined}
+            className={chip(active === undefined)}
+            search={nextContentListSearch(search, { [name]: undefined })}
+            to="."
+          >
+            {allLabel ?? t("all")}
+          </Link>
+        </li>
+        {options.map(option => (
+          <li key={String(option.value)}>
+            <Link
+              activeOptions={EXACT_MATCH}
+              aria-current={active === option.value ? "page" : undefined}
+              className={chip(active === option.value)}
+              search={nextContentListSearch(search, {
+                [name]: option.value,
+              })}
+              to="."
+            >
+              {option.label}
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </nav>
+  );
+};
diff --git a/packages/vitnode/src/tanstack/metadata/index.ts b/packages/vitnode/src/tanstack/metadata/index.ts
index b3871aae09..1f1fd14231 100644
--- a/packages/vitnode/src/tanstack/metadata/index.ts
+++ b/packages/vitnode/src/tanstack/metadata/index.ts
@@ -19,7 +19,10 @@ export {
 } from "./alternates";
 
 /** What a crawler may do with a page. */
-export type RouteRobots = "index, follow" | "noindex, nofollow";
+export type RouteRobots =
+  | "index, follow"
+  | "noindex, follow"
+  | "noindex, nofollow";
 
 /** What kind of thing a page is, to a social card. */
 export type RouteOpenGraphType = "article" | "website";
diff --git a/packages/vitnode/src/tanstack/plugin-routes/head.ts b/packages/vitnode/src/tanstack/plugin-routes/head.ts
index 7833b17e48..77fa73bd68 100644
--- a/packages/vitnode/src/tanstack/plugin-routes/head.ts
+++ b/packages/vitnode/src/tanstack/plugin-routes/head.ts
@@ -10,6 +10,7 @@ import { isInternalPathname } from "../metadata/alternates";
 
 const ROBOTS: readonly PluginRouteRobots[] = [
   "index, follow",
+  "noindex, follow",
   "noindex, nofollow",
 ];
 
diff --git a/plugins/blog/src/content/post.ts b/plugins/blog/src/content/post.ts
index 4b3d90a6cc..eed8fa8333 100644
--- a/plugins/blog/src/content/post.ts
+++ b/plugins/blog/src/content/post.ts
@@ -116,6 +116,9 @@ export const blogPostContentType = defineContentType({
 
   delivery: {
     enabled: true,
+    // `/blog`: the newest articles first, nine to a page so the grid fills its
+    // three columns, with a search box over the title and the content.
+    list: { enabled: true, pageSize: 9 },
     redirects: { enabled: true },
     seo: {
       titleField: "title",
diff --git a/plugins/blog/src/locales/en.json b/plugins/blog/src/locales/en.json
index a6366a20f8..ecc184f543 100644
--- a/plugins/blog/src/locales/en.json
+++ b/plugins/blog/src/locales/en.json
@@ -154,6 +154,19 @@
     },
     "post": {
       "published": "Published"
+    },
+    "list": {
+      "title": "Blog",
+      "desc": "News, guides and stories from our team.",
+      "search": "Search articles",
+      "empty": {
+        "title": "No articles yet",
+        "desc": "Check back soon - the first one is on its way."
+      },
+      "no_results": {
+        "title": "No articles match your search",
+        "desc": "Try a different word, or clear the search to see every article."
+      }
     }
   },
   "@vitnode/blog:posts": "Articles",
diff --git a/plugins/blog/src/pages/posts-page.tsx b/plugins/blog/src/pages/posts-page.tsx
new file mode 100644
index 0000000000..343ff2cf2e
--- /dev/null
+++ b/plugins/blog/src/pages/posts-page.tsx
@@ -0,0 +1,165 @@
+import type { PluginRoutePageProps } from "@vitnode/core/routing";
+import type { ContentListSearch } from "@vitnode/core/tanstack/content";
+
+import { DateFormat } from "@vitnode/core/components/date-format";
+import {
+  contentDeliveryInternalPath,
+  zodContentFileDescriptor,
+} from "@vitnode/core/content";
+import { resolveImageAlt } from "@vitnode/core/lib/files/resolve-alt";
+import { definePluginRoute } from "@vitnode/core/routing";
+import {
+  ContentCard,
+  ContentList,
+  ContentListEmpty,
+  ContentListItem,
+  contentListPage,
+  contentListPageHead,
+  ContentListPagination,
+  contentListQuery,
+  ContentListSearchForm,
+} from "@vitnode/core/tanstack/content";
+import { fetcher } from "@vitnode/core/tanstack/fetcher";
+import { getIntlRuntime } from "@vitnode/core/tanstack/i18n";
+import { useTranslations } from "use-intl";
+import { z } from "zod";
+
+import { CONFIG_PLUGIN } from "@/const";
+import { blogPostContentType } from "@/content/post";
+
+const zodBlogPostCard = z.object({
+  coverImage: zodContentFileDescriptor.nullable(),
+  coverImageAlt: z.string().nullable(),
+  excerpt: z.string().nullable(),
+  friendlyUrl: z.string(),
+  id: z.number(),
+  locale: z.string().nullable().optional(),
+  publishedAt: z.string().nullable(),
+  title: z.string(),
+});
+
+const loadPosts = async ({
+  locale,
+  search,
+}: {
+  locale: string;
+  search: ContentListSearch;
+}) => {
+  const response = await fetcher({
+    plugin: CONFIG_PLUGIN.pluginId,
+    method: "get",
+    module: "content/blog",
+    path: "/",
+    args: {
+      query: { ...contentListQuery(blogPostContentType, search), locale },
+    },
+  });
+
+  if (response.status !== 200) {
+    throw new Error(`Listing blog articles answered ${response.status}.`);
+  }
+
+  const { edges, pageInfo } = await response.json();
+
+  return contentListPage({
+    list: { edges: z.array(zodBlogPostCard).parse(edges), pageInfo },
+    search,
+  });
+};
+
+type BlogPostsPageData = Awaited<ReturnType<typeof loadPosts>>;
+
+export const route = definePluginRoute<BlogPostsPageData, ContentListSearch>({
+  load: async ({ context, search }) =>
+    await loadPosts({ locale: context.locale, search }),
+
+  head: ({ search, t }) =>
+    contentListPageHead(blogPostContentType, {
+      description: t("@vitnode/blog.list.desc"),
+      search,
+      title: t("@vitnode/blog.list.title"),
+    }),
+});
+
+const BlogPostsPage = ({
+  loaderData: { edges, pageInfo },
+  search,
+}: PluginRoutePageProps<BlogPostsPageData, ContentListSearch>) => {
+  const t = useTranslations("@vitnode/blog.list");
+  const { defaultLocale } = getIntlRuntime();
+  const empty = search.q === undefined ? "empty" : "no_results";
+
+  return (
+    <div className="container mx-auto flex max-w-6xl flex-col gap-6 px-4 py-8 md:gap-8 md:py-12">
+      <header className="flex flex-col gap-2">
+        <h1 className="text-foreground text-3xl font-semibold tracking-tight text-balance md:text-4xl">
+          {t("title")}
+        </h1>
+        <p className="text-muted-foreground text-lg leading-relaxed text-pretty">
+          {t("desc")}
+        </p>
+      </header>
+
+      <ContentListSearchForm
+        className="max-w-xl"
+        label={t("search")}
+        placeholder={t("search")}
+        search={search}
+      />
+
+      {edges.length === 0 ? (
+        <ContentListEmpty
+          description={t(`${empty}.desc`)}
+          title={t(`${empty}.title`)}
+        />
+      ) : (
+        <ContentList>
+          {edges.map(post => (
+            <ContentListItem key={post.id}>
+              <ContentCard
+                description={post.excerpt}
+                href={
+                  contentDeliveryInternalPath({
+                    definition: blogPostContentType,
+                    slug: post.friendlyUrl,
+                  }) ?? "/blog"
+                }
+                image={
+                  post.coverImage
+                    ? {
+                        alt: resolveImageAlt({
+                          alts: post.coverImage.alts,
+                          fallbackLocales: [defaultLocale],
+                          locale: post.locale ?? defaultLocale,
+                          occurrence: { alt: post.coverImageAlt },
+                        }).alt,
+                        height: post.coverImage.height,
+                        src: post.coverImage.url,
+                        width: post.coverImage.width,
+                      }
+                    : null
+                }
+                meta={
+                  post.publishedAt ? (
+                    <time dateTime={new Date(post.publishedAt).toISOString()}>
+                      <DateFormat date={post.publishedAt} showFullDate />
+                    </time>
+                  ) : null
+                }
+                title={post.title}
+              />
+            </ContentListItem>
+          ))}
+        </ContentList>
+      )}
+
+      <ContentListPagination
+        page={pageInfo.currentPage ?? 1}
+        search={search}
+        totalPages={pageInfo.totalPages}
+      />
+    </div>
+  );
+};
+
+export default BlogPostsPage;
diff --git a/plugins/blog/src/routes.ts b/plugins/blog/src/routes.ts
index f00e98a500..fb412872f1 100644
--- a/plugins/blog/src/routes.ts
+++ b/plugins/blog/src/routes.ts
@@ -1,6 +1,14 @@
 import { definePluginRoutes, lazy, page } from "@vitnode/core/routing";
+import { contentListSearch } from "@vitnode/core/tanstack/content";
+
+import { blogPostContentType } from "./content/post";
 
 export const routes = definePluginRoutes([
+  page("/blog", {
+    component: lazy(() => import("./pages/posts-page")),
+    messages: ["@vitnode/blog.list"],
+    search: contentListSearch(blogPostContentType),
+  }),
   page("/blog/:slug", {
     component: lazy(() => import("./pages/post-page")),
     messages: ["@vitnode/blog.post"],
diff --git a/plugins/example/src/content/article.ts b/plugins/example/src/content/article.ts
index 939877c914..06794ad871 100644
--- a/plugins/example/src/content/article.ts
+++ b/plugins/example/src/content/article.ts
@@ -92,6 +92,8 @@ export const articleContentType = defineContentType({
 
   delivery: {
     enabled: true,
+    // `/articles`, with a "Featured" filter read from `?featured=true`.
+    list: { enabled: true, filters: ["featured"] },
     redirects: { enabled: true },
     seo: {
       titleField: "title",
diff --git a/plugins/example/src/locales/en.json b/plugins/example/src/locales/en.json
index 9b7a215ce1..f04e52a643 100644
--- a/plugins/example/src/locales/en.json
+++ b/plugins/example/src/locales/en.json
@@ -98,7 +98,19 @@
     },
     "articles": {
       "published": "Published",
-      "faq": "Frequently asked questions"
+      "faq": "Frequently asked questions",
+      "list": {
+        "title": "Articles",
+        "desc": "Every published example article, newest first.",
+        "search": "Search articles",
+        "featured": "Featured",
+        "featured_only": "Featured only",
+        "not_featured": "Not featured",
+        "empty": {
+          "title": "No articles found",
+          "desc": "Publish an article in the AdminCP, or clear the search and filters."
+        }
+      }
     }
   },
   "@vitnode/example:article": "Articles",
diff --git a/plugins/example/src/pages/articles-page.tsx b/plugins/example/src/pages/articles-page.tsx
new file mode 100644
index 0000000000..6e248fafc0
--- /dev/null
+++ b/plugins/example/src/pages/articles-page.tsx
@@ -0,0 +1,144 @@
+import type { PluginRoutePageProps } from "@vitnode/core/routing";
+import type { ContentListSearch } from "@vitnode/core/tanstack/content";
+
+import { DateFormat } from "@vitnode/core/components/date-format";
+import { contentDeliveryInternalPath } from "@vitnode/core/content";
+import { definePluginRoute } from "@vitnode/core/routing";
+import {
+  ContentCard,
+  ContentList,
+  ContentListEmpty,
+  ContentListFilter,
+  ContentListItem,
+  contentListPage,
+  contentListPageHead,
+  ContentListPagination,
+  contentListQuery,
+  ContentListSearchForm,
+} from "@vitnode/core/tanstack/content";
+import { fetcher } from "@vitnode/core/tanstack/fetcher";
+import { useTranslations } from "use-intl";
+import { z } from "zod";
+
+import { CONFIG_PLUGIN } from "@/const";
+import { articleContentType } from "@/content/article";
+
+const zodArticleCard = z.object({
+  excerpt: z.string().nullable(),
+  publishedAt: z.string().nullable(),
+  slug: z.string(),
+  title: z.string(),
+});
+
+const loadArticles = async (search: ContentListSearch) => {
+  const response = await fetcher({
+    plugin: CONFIG_PLUGIN.pluginId,
+    method: "get",
+    module: "content/articles",
+    path: "/",
+    args: { query: contentListQuery(articleContentType, search) },
+  });
+
+  if (response.status !== 200) {
+    throw new Error(`Listing articles answered ${response.status}.`);
+  }
+
+  const { edges, pageInfo } = await response.json();
+
+  return contentListPage({
+    list: { edges: z.array(zodArticleCard).parse(edges), pageInfo },
+    search,
+  });
+};
+
+type ArticlesPageData = Awaited<ReturnType<typeof loadArticles>>;
+
+export const route = definePluginRoute<ArticlesPageData, ContentListSearch>({
+  load: async ({ search }) => await loadArticles(search),
+
+  head: ({ search, t }) =>
+    contentListPageHead(articleContentType, {
+      description: t("@vitnode/example.articles.list.desc"),
+      search,
+      title: t("@vitnode/example.articles.list.title"),
+    }),
+});
+
+const ArticlesPage = ({
+  loaderData: { edges, pageInfo },
+  search,
+}: PluginRoutePageProps<ArticlesPageData, ContentListSearch>) => {
+  const t = useTranslations("@vitnode/example.articles");
+
+  return (
+    <div className="container mx-auto flex max-w-6xl flex-col gap-6 px-4 py-8 md:gap-8 md:py-12">
+      <header className="flex flex-col gap-2">
+        <h1 className="text-foreground text-3xl font-semibold tracking-tight text-balance md:text-4xl">
+          {t("list.title")}
+        </h1>
+        <p className="text-muted-foreground text-lg leading-relaxed text-pretty">
+          {t("list.desc")}
+        </p>
+      </header>
+
+      <div className="flex flex-col gap-4 md:flex-row md:items-end md:justify-between">
+        <ContentListSearchForm
+          className="w-full md:max-w-md"
+          label={t("list.search")}
+          placeholder={t("list.search")}
+          search={search}
+        />
+        <ContentListFilter
+          label={t("list.featured")}
+          name="featured"
+          options={[
+            { label: t("list.featured_only"), value: true },
+            { label: t("list.not_featured"), value: false },
+          ]}
+          search={search}
+        />
+      </div>
+
+      {edges.length === 0 ? (
+        <ContentListEmpty
+          description={t("list.empty.desc")}
+          title={t("list.empty.title")}
+        />
+      ) : (
+        <ContentList>
+          {edges.map(article => (
+            <ContentListItem key={article.slug}>
+              <ContentCard
+                description={article.excerpt}
+                href={
+                  contentDeliveryInternalPath({
+                    definition: articleContentType,
+                    slug: article.slug,
+                  }) ?? "/articles"
+                }
+                meta={
+                  article.publishedAt ? (
+                    <time
+                      dateTime={new Date(article.publishedAt).toISOString()}
+                    >
+                      <DateFormat date={article.publishedAt} showFullDate />
+                    </time>
+                  ) : null
+                }
+                title={article.title}
+              />
+            </ContentListItem>
+          ))}
+        </ContentList>
+      )}
+
+      <ContentListPagination
+        page={pageInfo.currentPage ?? 1}
+        search={search}
+        totalPages={pageInfo.totalPages}
+      />
+    </div>
+  );
+};
+
+export default ArticlesPage;
diff --git a/plugins/example/src/routes.ts b/plugins/example/src/routes.ts
index 26cba4a8af..9dec8ee747 100644
--- a/plugins/example/src/routes.ts
+++ b/plugins/example/src/routes.ts
@@ -5,9 +5,11 @@ import {
   lazy,
   page,
 } from "@vitnode/core/routing";
+import { contentListSearch } from "@vitnode/core/tanstack/content";
 
 import type { ExampleSearch } from "./pages/example-page";
 
+import { articleContentType } from "./content/article";
 import { browseSearch } from "./pages/browse-search";
 import { zonesSearch } from "./pages/zones-search";
 
@@ -50,6 +52,12 @@ export const routes = definePluginRoutes([
     ],
   }),
 
+  page("/articles", {
+    component: lazy(() => import("./pages/articles-page")),
+    messages: ["@vitnode/example.articles"],
+    search: contentListSearch(articleContentType),
+  }),
+
   page("/articles/:slug", {
     component: lazy(() => import("./pages/article-page")),
     messages: ["@vitnode/example.articles"],