{%- endif -%}
{%- endfor -%}
{%- endcapture -%}
{%- if items != blank -%}
{%- endif -%}
```
This block loops through `custom.sub_collections`, checks `c.products_count > 0` so a child collection whose last product sells out drops off the page immediately rather than at the next morning's Link run, falls back to the parent collection's list as "Related categories" when a leaf collection has no children, and outputs nothing when both are empty. We use Custom Liquid rather than connecting Horizon's built-in Collection list section to the metafield as a dynamic source because Horizon fills an empty collection list setting with placeholder cards, which would show dummy cards on every leaf collection.
### Step 6: Link products to their brand page, and add Shop by brand
First, make sure each vendor has a smart collection (**Products > Collections > Create collection > Smart**, rule **Vendor is equal to TP-LINK**) whose handle matches the vendor name run through `handleize` (`tp-link`). Then in the theme editor, switch to the Product template (**Products > Default product**), open the group under **Product information** that holds the product title, click **Add block > Custom Liquid**, drag it directly below the title, and paste this snippet:
```liquid
{%- comment -%}
"By TP-LINK", linking the product to its brand page in custom.brand. Prints nothing when the field is empty.
Paste into a Custom Liquid block under the product title.
{%- endcomment -%}
{%- assign brand = product.metafields.custom.brand.value -%}
{%- if brand -%}
{%- endif -%}
```
Although you can connect a built-in Collection card block to the `custom.brand` dynamic source without code, Horizon shows a placeholder card on any product whose brand field is empty, whereas this Custom Liquid snippet prints a clean text link and disappears when no brand is set.
Next, switch back to the Collection template, click **Add block > Custom Liquid** in the heading section right below the sub-collection block from Step 5, and paste the Shop by brand snippet:
```liquid
{%- comment -%}
"Shop by brand" links from a category page to the brand page of every vendor in it.
Looks each vendor's brand collection up by handle (TP-LINK -> /collections/tp-link), so brand
collections need the handleized vendor name as their handle. Vendors without one are skipped.
Paste into a Custom Liquid block under the sub-collection links.
{%- endcomment -%}
{%- capture items -%}
{%- for vendor in collection.all_vendors -%}
{%- assign brand_handle = vendor | handleize -%}
{%- assign brand = collections[brand_handle] -%}
{%- if brand.id != blank and brand.id != collection.id and brand.products_count > 0 -%}
{%- endif -%}
{%- endfor -%}
{%- endcapture -%}
{%- if items != blank -%}
{%- endif -%}
```
Because it looks up each vendor's brand page from `collection.all_vendors` by handle (`collections[brand_handle]`), this block needs no metafield of its own and skips any vendor without a live brand collection (Liquid won't accept a filter inside square brackets, so `brand_handle` is assigned first).
### Step 7: Add the product breadcrumb, linked specs and "Shop more like this"
In the theme editor on the Product template, select **Product information**, click **Add block > Custom Liquid**, drag it to the top of the section, and paste the product breadcrumb snippet:
```liquid
{%- comment -%}
Product breadcrumb with BreadcrumbList markup, through the product's custom.primary_collection
and that collection's parents: Home / Security Cameras / TP-LINK VIGI C540.
Paste into a Custom Liquid block at the top of the product information section.
{%- endcomment -%}
{%- liquid
assign p1 = product.metafields.custom.primary_collection.value
assign p2 = p1.metafields.custom.parent_collection.value
assign p3 = p2.metafields.custom.parent_collection.value
assign pos = 1
-%}
```
Next, add a second **Custom Liquid** block under the product description in **Product information** and paste the specs table snippet. Its first line lists the specs to show, in order, as `namespace.key|Label`, so change it to the metafields and standard product attributes your products use (`shopify.` keys print their labels, such as Bullet):
```liquid
{%- comment -%}
Specifications table with linked values. A value links to the collection in custom.spec_links
for that spec, so "Resolution: 4MP" goes to 4MP Security Cameras; a value with no collection
stays plain text. List the specs to show below as namespace.key|Label, in order. Standard
product attributes (shopify.*) show their labels. Nothing prints when the product has none.
Paste into a Custom Liquid block in product information, under the description.
{%- endcomment -%}
{%- assign specs = 'custom.resolution|Resolution,custom.night_vision|Night vision,custom.channels|Channels,custom.poe_ports|PoE ports,custom.cable_length|Length,custom.ip_rating|IP rating,shopify.surveillance-camera-design|Camera design,shopify.power-source|Power source' | split: ',' -%}
{%- assign links = product.metafields.custom.spec_links.value -%}
{%- capture rows -%}
{%- for spec in specs -%}
{%- assign parts = spec | split: '|' -%}
{%- assign ref = parts[0] | split: '.' -%}
{%- assign field = product.metafields[ref[0]][ref[1]] -%}
{%- if field != blank -%}
{%- if field.type contains 'metaobject_reference' and field.type contains 'list.' -%}
{%- assign shown = field.value | map: 'label' | join: ', ' -%}
{%- elsif field.type contains 'metaobject_reference' -%}
{%- assign shown = field.value.label -%}
{%- elsif field.type contains 'list.' -%}
{%- assign shown = field.value | join: ', ' -%}
{%- else -%}
{%- assign shown = field.value -%}
{%- endif -%}
{%- assign handle = nil -%}
{%- assign target = nil -%}
{%- if links -%}{%- assign handle = links[parts[0]] -%}{%- endif -%}
{%- if handle != blank -%}{%- assign target = collections[handle] -%}{%- endif -%}
{{ parts[1] }}
{%- if target != blank and target.products_count > 0 -%}{{ shown }}{%- else -%}{{ shown }}{%- endif -%}
{%- endif -%}
```
A value prints as a link only when `custom.spec_links` names a collection for that spec and the collection still has products, so a spec with no collection of its own stays plain text and a deleted collection never leaves a dead link. The links point at collection pages, never at filter URLs.
Then add a third **Custom Liquid** block under the specs table and paste the "Shop more like this" snippet:
```liquid
{%- comment -%}
"Shop more like this": links to the narrower collections in custom.related_collections
(spec and brand-by-type collections the product is in). Empty collections are skipped,
and nothing prints when there's nothing to link.
Paste into a Custom Liquid block under the product description.
{%- endcomment -%}
{%- capture items -%}
{%- for c in product.metafields.custom.related_collections.value -%}
{%- if c.products_count > 0 -%}
{%- endif -%}
{%- endfor -%}
{%- endcapture -%}
{%- if items != blank -%}
{%- endif -%}
```
### Step 8: Optional extras
To round out your store's crawl paths with Horizon's built-in sections, add two optional templates in the theme editor:
- For a **Categories** page that lists more than Horizon's 20-collection limit on `/collections`, create a page template with a **Collection list** section (populated with static collection picks, which the weekly audit can't read, so list their handles in `theme_linked`) or a **Menu** block, assign it to a `/pages/categories` page, and link it from your footer menu.
- For blog buying guides that pass authority to core categories, open the **Default blog post** template and add a **Collection list** section below the article body to attach static category picks to relevant articles.
Preview your theme copy (**Actions > Preview**) on a top-level collection, a child collection and a product page to confirm the breadcrumbs and link lists render cleanly, then publish the theme.
## How to automate internal linking with n8n
Setting up the theme blocks is a one-time job, whereas the six link fields depend on store data that changes every time you add a product, vendor or smart collection. Automating those fields with n8n is optional, and if you fill them by hand on a small catalogue, the workflow's weekly Audit lane is still worth running on its own to catch orphan pages, broken links and redirects in Slack.
### What you'll build
You'll build one n8n workflow with three lanes that keeps your collection hierarchy and product links filled in code and sends a weekly Slack audit of anything that needs human attention. Before the automation runs on our test store, the audit flags 14 orphan collections (including `tp-link-security-cameras` and `4mp-security-cameras`) because rule-based smart collections have no inbound links from menus or parent pages:
The Link lane reads your menu structure and collection rules, works out the full parent-child hierarchy in code, and writes the six metafields. Afterwards, the TP-LINK VIGI C540 page shows the breadcrumb trail `Home / Security Cameras / TP-LINK VIGI C540`, a "By TP-LINK" link, a specs table whose 4MP value links to `4mp-security-cameras`, and "Shop more like this" links to `4mp-security-cameras` and `tp-link-security-cameras`, while the orphan audit drops to zero. All three lanes sit on one canvas:
### What you need
- n8n (version 2.46 or later, self-hosted Community Edition or n8n Cloud) with [Data Tables](https://docs.n8n.io/build/work-with-data/data-tables/) enabled.
- A custom Shopify app with `read_products`, `write_products`, `read_online_store_navigation`, and `read_content` Admin API scopes (`read_themes` only if you turn on the optional theme setting check; the repo's `SETUP.md` covers client credentials setup).
- A Slack bot token with the `chat:write` scope.
- The setup section above done, or at least the Custom Liquid blocks added to your theme (the workflow's Setup lane can create the six metafield definitions).
Because every relationship is calculated in deterministic code, the workflow needs no AI model and has no per-run API costs.
### How it works
1. The Setup lane (Manual Trigger) creates the `link_findings` and `link_changes` n8n Data Tables and registers the six metafield definitions in Shopify via GraphQL. You run it once when installing the workflow.
2. The Link lane (Schedule Trigger, daily at 05:00, plus Manual Trigger) reads all published collections, menus, and products, builds the category tree from menu nesting, adopts smart collections outside the menu by their `TYPE` rules, matches vendors to brand pages, and picks each product's primary collection, spec links and related collections. It diffs against current store metafields, logs planned changes in `link_changes`, and posts a summary to Slack. It starts with `dry_run` set to `true`; when you change `dry_run` to `false`, it writes updates in batches of 25 using `metafieldsSet`.
3. The Audit lane (Schedule Trigger, weekly on Monday at 06:00, plus Manual Trigger) scans published collections, menus, active products, pages, blog articles, and redirects. It tallies inbound links from every surface, checks for broken links, flags products without categories and vendors without brand pages, logs issues to `link_findings`, and posts a summary to Slack.
Every lane uses a Set node for settings and fetches a fresh Admin API token with a `Get Shopify token for ` HTTP Request node, Retry On Fail enabled (3 attempts, 2 seconds apart). GraphQL queries run through HTTP Request nodes pointing to `https://{{ store_domain }}/admin/api/2026-10/graphql.json` with the `X-Shopify-Access-Token` header, and Slack messages use an HTTP Request node to `https://slack.com/api/chat.postMessage` with your Slack API credential and **Execute Once** turned on.
### Step 1: Create the tables and the six link fields
In the Setup lane, connect a Manual Trigger named **Run once to set up** to a Set node named **Setup settings** (Mode: JSON) so your store domain and metafield namespace live in one place:
```json
{
"store_domain": "your-store.myshopify.com",
"namespace": "custom"
}
```
Next, add two [Data table](https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.datatable/) nodes named **Create link_findings** and **Create link_changes** (Resource: **Table**, Operation: **Create**, with **Reuse Existing Tables** turned on so a second Setup run doesn't overwrite existing rows):
| Table | Columns |
|---|---|
| `link_findings` | `run_date` (date), `kind` (string: `collection`, `link`, `product`, `vendor` or `theme`), `handle` (string), `issue` (string), `detail` (string), `inbound` (number) |
| `link_changes` | `run_date` (date), `owner` (string: `collection` or `product`), `handle` (string), `field` (string), `old_value` (string), `new_value` (string), `status` (string: `planned` or `written`) |
Connect **Get Shopify token for Setup** (HTTP Request), then an HTTP Request node named **Create link fields** (Method: **POST**, URL: `https://{{ $('Setup settings').first().json.store_domain }}/admin/api/2026-10/graphql.json`, Send Body: **JSON**, Specify Body: **Using JSON**, Execute Once: **On**) to register all six metafield definitions in one GraphQL call:
```graphql
mutation Fields($ns: String!) {
parent: metafieldDefinitionCreate(definition: {
name: "Parent collection", namespace: $ns, key: "parent_collection", ownerType: COLLECTION,
type: "collection_reference", pin: true,
description: "The collection one level up. Shown as the breadcrumb."
}) { createdDefinition { id } userErrors { field message code } }
children: metafieldDefinitionCreate(definition: {
name: "Sub-collections", namespace: $ns, key: "sub_collections", ownerType: COLLECTION,
type: "list.collection_reference", pin: true,
description: "The collections one level down. Shown as links under the description."
}) { createdDefinition { id } userErrors { field message code } }
brand: metafieldDefinitionCreate(definition: {
name: "Brand", namespace: $ns, key: "brand", ownerType: PRODUCT,
type: "collection_reference", pin: true,
description: "The brand page for this product's vendor."
}) { createdDefinition { id } userErrors { field message code } }
primary: metafieldDefinitionCreate(definition: {
name: "Primary collection", namespace: $ns, key: "primary_collection", ownerType: PRODUCT,
type: "collection_reference", pin: true,
description: "The collection the product breadcrumb runs through."
}) { createdDefinition { id } userErrors { field message code } }
related: metafieldDefinitionCreate(definition: {
name: "Related collections", namespace: $ns, key: "related_collections", ownerType: PRODUCT,
type: "list.collection_reference", pin: true,
description: "Shop more like this: the narrower collections the product is in."
}) { createdDefinition { id } userErrors { field message code } }
specs: metafieldDefinitionCreate(definition: {
name: "Spec links", namespace: $ns, key: "spec_links", ownerType: PRODUCT,
type: "json", pin: true,
description: "Which collection each spec value links to in the specs table, by metafield."
}) { createdDefinition { id } userErrors { field message code } }
}
```
Set its JSON body expression to pass the mutation and namespace variable:
```text
={{ JSON.stringify({ query: ``, variables: { ns: $('Setup settings').first().json.namespace } }) }}
```
Finally, connect a Code node named **Check the fields** (Mode: **Run Once for All Items**). Shopify returns a `TAKEN` error code when a definition already exists (for example, if you created them by hand in the setup section), so this node treats `TAKEN` as harmless and only throws an error for any other refusal:
```javascript
// "TAKEN" means the field already exists, which is fine on a second run.
const d = $input.first().json.data || {};
const out = [], bad = [];
for (const [field, r] of Object.entries(d)) {
const errs = (r && r.userErrors) || [];
if (r && r.createdDefinition) out.push(field + ': created');
else if (errs.length && errs.every(e => e.code === 'TAKEN')) out.push(field + ': already there');
else bad.push(field + ': ' + JSON.stringify(errs));
}
if ($input.first().json.errors) bad.push(JSON.stringify($input.first().json.errors));
if (bad.length) throw new Error('Shopify refused some fields: ' + bad.join('; '));
return [{ json: { fields: out } }];
```
On a first run, the node outputs `parent: created`, `children: created`, `brand: created`, `primary: created`, `related: created`, and `specs: created`; on a second run, it reports each definition as `already there`.
### Step 2: Work out each collection's parent and children
In the Link lane, add a Schedule Trigger named **Every day** (set to 05:00) and a Manual Trigger named **Run Link now**, and connect both to a Set node named **Link settings** (Mode: JSON):
```json
{
"store_domain": "your-store.myshopify.com",
"namespace": "custom",
"tree_menu": "main-menu",
"skip_handles": [
"frontpage",
"all"
],
"min_products": 1,
"max_children": 24,
"max_related": 6,
"write_collection_links": true,
"write_brand": true,
"write_primary": true,
"write_spec_links": true,
"write_related": true,
"dry_run": true,
"slack_channel": "#log-seo"
}
```
| Setting | What it does |
|---|---|
| `namespace` | Where the six fields live (`custom`, matching Setup) |
| `tree_menu` | The menu handle whose nesting represents your category tree |
| `skip_handles` | Collections that should never be linked (`frontpage` is the Home page collection every Shopify store has; `all` is the built-in all-products page) |
| `min_products` | Minimum active products required for a child collection to be linked under its parent |
| `max_children` | Maximum sub-collection links to show on a parent page |
| `max_related` | Maximum "Shop more like this" links per product page |
| `write_collection_links`, `write_brand`, `write_primary`, `write_spec_links`, `write_related` | Toggles to enable or disable writes for specific link types |
| `dry_run` | When true, plans and logs changes without writing to Shopify |
| `slack_channel` | Slack channel for execution notifications |
Connect **Get Shopify token for Link**, then add an HTTP Request node named **Read collections** that paginates through all published collections and fetches your store menus:
| Setting | Value |
|---|---|
| Method | POST |
| URL | `https://{{ $('Link settings').first().json.store_domain }}/admin/api/2026-10/graphql.json` |
| Send Headers | `X-Shopify-Access-Token` = `{{ $('Get Shopify token for Link').first().json.access_token }}` |
| Send Body | JSON, Using JSON |
| Pagination mode | Update a Parameter in Each Request |
| Parameter | Type Body, Name `variables`, Value `{{ { after: $response.body.data.collections.pageInfo.endCursor, ns: $('Link settings').first().json.namespace } }}` |
| Pagination Complete When | Other |
| Complete Expression | `{{ !$response.body.data.collections.pageInfo.hasNextPage }}` |
| Interval Between Requests (ms) | 250 |
| Execute Once | On |
Use this GraphQL query inside **Read collections** (its JSON body expression passes `variables: { after: null, ns: $('Link settings').first().json.namespace }`):
```graphql
query Collections($after: String, $ns: String!) {
collections(first: 100, after: $after, query: "published_status:published") {
pageInfo { hasNextPage endCursor }
nodes {
id handle title descriptionHtml productsCount { count }
ruleSet { appliedDisjunctively rules { column relation condition
conditionObject { ... on CollectionRuleMetafieldCondition { metafieldDefinition { namespace key } } } } }
parent: metafield(namespace: $ns, key: "parent_collection") { value }
subs: metafield(namespace: $ns, key: "sub_collections") { value }
}
}
menus(first: 50) {
nodes { handle items { title resourceId url
items { title resourceId url items { title resourceId url } } } }
}
}
```
Next, add an HTTP Request node named **Read products** with the same pagination settings, updating the Parameter value to `{{ { after: $response.body.data.products.pageInfo.endCursor, ns: $('Link settings').first().json.namespace } }}` and Complete Expression to `{{ !$response.body.data.products.pageInfo.hasNextPage }}`. We filter by `published_status:published` rather than checking `onlineStoreUrl` because `onlineStoreUrl` returns null on a password-protected development store:
```graphql
query Products($after: String, $ns: String!) {
products(first: 100, after: $after, query: "status:active AND published_status:published") {
pageInfo { hasNextPage endCursor }
nodes {
id handle vendor
collections(first: 25) { nodes { id } }
brand: metafield(namespace: $ns, key: "brand") { value }
primary: metafield(namespace: $ns, key: "primary_collection") { value }
related: metafield(namespace: $ns, key: "related_collections") { value }
specs: metafield(namespace: $ns, key: "spec_links") { value }
}
}
}
```
Now connect a Code node named **Plan the links** (Mode: **Run Once for All Items**). This one node plans both collection and product links: part 1 builds the category tree from your menu and smart collection rules, and part 2 (explained in Step 3) resolves each product's brand, primary collection, spec links and related collections and returns only the fields that differ from what Shopify holds:
```javascript
const s = $('Link settings').first().json;
const pages = $('Read collections').all();
for (const p of [...pages, ...$('Read products').all()]) if (p.json.errors) throw new Error(JSON.stringify(p.json.errors).slice(0, 500));
const cols = pages.flatMap(i => i.json.data.collections.nodes).filter(c => !s.skip_handles.includes(c.handle));
const menus = pages[0].json.data.menus.nodes;
const products = $('Read products').all().flatMap(i => i.json.data.products.nodes);
const byHandle = Object.fromEntries(cols.map(c => [c.handle, c]));
const byId = Object.fromEntries(cols.map(c => [c.id, c]));
const rules = c => (c && c.ruleSet && c.ruleSet.rules) || [];
const size = h => (byHandle[h] && byHandle[h].productsCount.count) || 0;
// 1. The tree comes from how the tree menu is nested, in menu order...
const parent = {}, kids = {}, rank = {};
const seen = h => { if (!(h in rank)) rank[h] = Object.keys(rank).length; };
const isUnder = (up, h) => { for (let x = up, n = 0; x && n < 20; x = parent[x], n++) if (x === h) return true; return false; };
const adopt = (h, up) => {
if (!h || !up || h === up || !byHandle[h] || !byHandle[up] || parent[h] || isUnder(up, h)) return;
parent[h] = up;
(kids[up] = kids[up] || []).push(h);
seen(h);
};
const handleOf = it => (byId[it.resourceId] || {}).handle || ((it.url || '').match(/\/collections\/([^/?#]+)/) || [])[1];
const walk = (items, up) => {
for (const it of items || []) {
const h = byHandle[handleOf(it)] ? handleOf(it) : null;
if (h) seen(h);
adopt(h, up);
walk(it.items, h || up);
}
};
const tree = menus.find(m => m.handle === s.tree_menu);
if (!tree) throw new Error('No menu with the handle "' + s.tree_menu + '". Check tree_menu in Link settings.');
walk(tree.items, null);
if (!Object.keys(rank).length) throw new Error('The menu "' + s.tree_menu + '" links to no published collection, so nothing would have a parent.');
// ...then from rules, for collections outside the menu:
// "type is X and ..." sits under the collection whose only rule is "type is X".
const typePage = {};
for (const c of cols) {
const r = rules(c);
if (r.length === 1 && r[0].column === 'TYPE' && r[0].relation === 'EQUALS') typePage[r[0].condition.toLowerCase()] ??= c.handle;
}
for (const c of [...cols].sort((a, b) => a.title.localeCompare(b.title))) {
if (!c.ruleSet || c.ruleSet.appliedDisjunctively || rules(c).length < 2) continue;
const t = rules(c).find(r => r.column === 'TYPE' && r.relation === 'EQUALS');
if (t) adopt(c.handle, typePage[t.condition.toLowerCase()]);
}
// Spec pages: a collection whose rules are one product metafield (or standard product attribute)
// condition, plus at most "type is X", is the page for that spec value: "Resolution is 4MP" links to it.
const specKey = c => {
if (!c.ruleSet || c.ruleSet.appliedDisjunctively) return null;
const r = rules(c), m = r.filter(x => x.column === 'PRODUCT_METAFIELD_DEFINITION' && x.relation === 'EQUALS');
const def = m.length === 1 && m[0].conditionObject && m[0].conditionObject.metafieldDefinition;
if (!def || r.some(x => x !== m[0] && !(x.column === 'TYPE' && x.relation === 'EQUALS')) || r.length > 2) return null;
return def.namespace + '.' + def.key;
};
const specOf = Object.fromEntries(cols.map(c => [c.handle, specKey(c)]).filter(([, k]) => k));
// Brand pages: the collection whose only rule is "vendor is X" (Shopify matches vendors without case).
const brandOf = {};
for (const c of cols) {
const r = rules(c);
if (r.length === 1 && r[0].column === 'VENDOR' && r[0].relation === 'EQUALS') brandOf[r[0].condition.toLowerCase()] ??= c.handle;
}
const brandPages = new Set(Object.values(brandOf));
const inTree = h => h in rank;
const depth = h => { let d = 0; for (let x = h; parent[x] && d < 20; x = parent[x]) d++; return d; };
const path = h => { const out = []; for (let x = h; x && out.length < 20; x = parent[x]) out.push(x); return out; };
// 2. Compare with what the store has now and keep only the changes.
const today = new Date().toISOString().slice(0, 10);
const names = v => { if (!v) return ''; let ids = [v]; if (v.startsWith('[')) { try { ids = JSON.parse(v); } catch (e) {} } return ids.map(id => (byId[id] || {}).handle || id).join(', '); };
const changes = [];
const compare = (owner, ownerId, handle, field, type, have, want, show = names) => {
have = have || '';
if (want === have) return;
changes.push({ json: { run_date: today, owner, owner_id: ownerId, handle, field, type, value: want,
old_value: show(have), new_value: show(want) } });
};
// Spec links are JSON, so compare them with sorted keys and show them as "key: handle".
const sortedJson = o => JSON.stringify(Object.fromEntries(Object.entries(o).sort(([a], [b]) => a.localeCompare(b))));
const specJson = v => { if (!v) return ''; try { return sortedJson(JSON.parse(v)); } catch (e) { return v; } };
const specShow = v => { if (!v) return ''; try { return Object.entries(JSON.parse(v)).map(([k, h]) => k.split('.').pop() + ': ' + h).join(', '); } catch (e) { return v; } };
const one = h => (h ? byHandle[h].id : '');
const list = hs => (hs.length ? JSON.stringify(hs.map(h => byHandle[h].id)) : '');
if (s.write_collection_links) for (const c of cols) {
compare('collection', c.id, c.handle, 'parent_collection', 'collection_reference', c.parent && c.parent.value, one(parent[c.handle]));
const children = (kids[c.handle] || []).filter(h => size(h) >= s.min_products).slice(0, s.max_children);
compare('collection', c.id, c.handle, 'sub_collections', 'list.collection_reference', c.subs && c.subs.value, list(children));
}
for (const p of products) {
const mine = p.collections.nodes.map(n => (byId[n.id] || {}).handle).filter(Boolean);
// Primary: the deepest tree collection the product is in. Collections with a vendor rule are skipped:
// a breadcrumb says what the product is, the brand link says who makes it. Ties go to menu order.
const primary = mine.filter(h => inTree(h) && !rules(byHandle[h]).some(r => r.column === 'VENDOR'))
.sort((a, b) => depth(b) - depth(a) || rank[a] - rank[b])[0] || '';
const onPath = new Set(primary ? path(primary) : []);
// Spec links: for each spec, the spec page the product is in, even when the breadcrumb runs through it.
// One with a type rule beats one without, then the smallest. A page holding only this product adds nothing.
const specs = {};
for (const h of mine.filter(h => specOf[h] && size(h) >= Math.max(2, s.min_products))
.sort((a, b) => rules(byHandle[b]).length - rules(byHandle[a]).length || size(a) - size(b) || a.localeCompare(b))) specs[specOf[h]] ??= h;
// Related: every other collection it's in, smallest (most specific) first. A collection holding only
// this product adds nothing. Spec collections stay in, by name, alongside the spec value links.
const related = mine.filter(h => !onPath.has(h) && !brandPages.has(h) && size(h) >= Math.max(2, s.min_products))
.sort((a, b) => size(a) - size(b) || a.localeCompare(b)).slice(0, s.max_related);
const brand = brandOf[String(p.vendor || '').toLowerCase()] || '';
if (s.write_brand) compare('product', p.id, p.handle, 'brand', 'collection_reference', p.brand && p.brand.value, one(brand));
if (s.write_primary) compare('product', p.id, p.handle, 'primary_collection', 'collection_reference', p.primary && p.primary.value, one(primary));
if (s.write_spec_links) compare('product', p.id, p.handle, 'spec_links', 'json', specJson(p.specs && p.specs.value),
Object.keys(specs).length ? sortedJson(specs) : '', specShow);
if (s.write_related) compare('product', p.id, p.handle, 'related_collections', 'list.collection_reference', p.related && p.related.value, list(related));
}
return changes;
```
Part 1 of **Plan the links** walks `main-menu` in menu order and stops with an error if the menu is missing or links to no published collections, so a typo in `tree_menu` can't wipe out your store's breadcrumbs. It then checks multi-rule AND smart collections outside the menu and adopts any collection with a `TYPE EQUALS X` rule under the category whose sole rule is `TYPE EQUALS X`. On our security store, `security-cameras` adopts `4k-security-cameras`, `hikvision-security-cameras`, and `tp-link-security-cameras` by their type rules, while `poe-switches` gets `networking` as its parent from the menu and adopts `8-port-poe-switches` from its rules.
### Step 3: Work out each product's brand, primary collection, spec links and related collections
Part 2 of **Plan the links** calculates the four product metafields for every active product and compares them against Shopify's current values:
1. For `brand`, it matches `p.vendor` case-insensitively to the collection whose sole rule is `VENDOR EQUALS X`, assigning `tp-link` to the TP-LINK VIGI C540.
2. For `primary_collection`, it filters the product's collections to those inside the category tree, skips any collection with a vendor rule (because a breadcrumb says what the product is, whereas the brand link says who makes it), and picks the deepest, breaking ties by menu order. The VIGI C540 sits in `security-cameras`, `tp-link-security-cameras` (skipped for its vendor rule) and `4mp-security-cameras` (outside the tree because its only rule is Resolution is 4MP, with no type rule), so its primary collection resolves to `security-cameras`.
3. For `spec_links`, it first finds the spec collections: smart collections whose rules are one condition on a product metafield or standard product attribute, optionally with a product type rule, such as 4MP Security Cameras (Resolution is 4MP) or 8 Port PoE Switches (type is PoE Switches and PoE ports is 8). For each spec, it picks the spec collection the product is in, preferring one with a type rule and then the smallest, and writes the result as JSON keyed by the metafield, so the VIGI C540 gets `{"custom.resolution": "4mp-security-cameras"}`. A spec collection counts even when it is also the product's breadcrumb, so a 4K camera's Resolution row links to 4K Security Cameras too.
4. For `related_collections`, it takes every other collection the product belongs to outside its breadcrumb trail and brand page (requiring at least 2 products so a single-item collection adds nothing), sorted smallest-first so the most specific spec and brand-by-type collections come first up to `max_related`. For the VIGI C540, that gives `4mp-security-cameras` and `tp-link-security-cameras`. A spec collection stays in the list even though the specs table links it too, so it also appears by its full name.
Across the rest of the running example, the same rules assign brand `tp-link` and primary `8-port-poe-switches` to the TP-LINK TL-SG1008MP switch, brand `tp-link` and primary `nvr` to the TP-LINK VIGI NVR1004H-4P, and brand `ubiquiti` and primary `nvr` to the Ubiquiti UniFi UNVR. The switch's PoE ports value also links to `8-port-poe-switches`, while the NVR1004H-4P's 4 channels stay plain text because the store has no 4-channel collection.
### Step 4: Write only the links that changed
From **Plan the links**, create two branches so every run logs and announces its plan before touching Shopify. On the first branch, connect a Data table node named **Save the plan** (Resource: **Row**, Operation: **Insert**, Table: `link_changes`) and map its columns:
| Column | Value |
|---|---|
| `run_date` | `{{ $json.run_date }}` |
| `owner` | `{{ $json.owner }}` |
| `handle` | `{{ $json.handle }}` |
| `field` | `{{ $json.field }}` |
| `old_value` | `{{ $json.old_value }}` |
| `new_value` | `{{ $json.new_value }}` |
| `status` | `{{ $('Link settings').first().json.dry_run ? 'planned' : 'written' }}` |
After **Save the plan**, add an HTTP Request node named **Post link summary** (Method: **POST**, URL: `https://slack.com/api/chat.postMessage`, Slack API credential, Execute Once: **On**) with this JSON body expression:
```text
={{ JSON.stringify((() => {
const s = $('Link settings').first().json;
const ch = $('Plan the links').all().map(i => i.json);
const labels = { parent_collection: 'Breadcrumb parents', sub_collections: 'Sub-collection lists',
brand: 'Brand links', primary_collection: 'Product breadcrumbs', spec_links: 'Spec links', related_collections: 'Shop more like this' };
const lines = Object.entries(labels).map(([f, label]) => {
const xs = ch.filter(c => c.field === f);
if (!xs.length) return '';
const shown = xs.slice(0, 8).map(c => c.handle + (c.new_value ? ' > ' + c.new_value : ' > (cleared)')).join('\n ');
return '*' + label + '* (' + xs.length + ')\n ' + shown + (xs.length > 8 ? '\n ...' : '') + '\n';
}).join('');
return { channel: s.slack_channel, unfurl_links: false,
text: (s.dry_run ? ':memo: Link plan (dry run, nothing written): ' : ':link: Links updated: ') + ch.length + (ch.length === 1 ? ' change' : ' changes') + '\n' + lines };
})()) }}
```
Click **Run Link now** with `dry_run` set to `true` first, check the Slack summary and the `link_changes` table, then set `dry_run` to `false` and run it again to write the metafields. On our test store, the first dry run planned this:
```text
:memo: Link plan (dry run, nothing written): 83 changes
*Breadcrumb parents* (7)
poe-switches > networking
patch-leads > networking
8-port-poe-switches > poe-switches
4k-security-cameras > security-cameras
8-channel-nvrs > nvr
hikvision-security-cameras > security-cameras
tp-link-security-cameras > security-cameras
*Sub-collection lists* (4)
security-cameras > 4k-security-cameras, hikvision-security-cameras, tp-link-security-cameras
nvr > 8-channel-nvrs
poe-switches > 8-port-poe-switches
networking > poe-switches, patch-leads
*Brand links* (29)
reolink-rlc-810a-8mp-4k-poe-ip-bullet-camera > reolink
tp-link-tl-sg1210mp-10-port-gigabit-desktop-switch-with-8-port-poe > tp-link
tp-link-tl-sg1008mp-8-port-gigabit-desktop-rackmount-switch-with-8-port-poe > tp-link
tp-link-tl-sl1311p-8-port-10-100mbps-3-port-gigabit-desktop-switch-with-8-port-poe > tp-link
d-link-dgs-1008mp-8-port-gigabit-poe-unmanaged-switch > d-link
ubiquiti-unifi-switch-16-poe-usw-16-poe > ubiquiti
d-link-dgs-1008p-8-port-gigabit-poe-unmanaged-switch > d-link
ubiquiti-unifi-switch-lite-8-poe-usw-lite-8-poe > ubiquiti
...
*Product breadcrumbs* (29)
reolink-rlc-810a-8mp-4k-poe-ip-bullet-camera > 4k-security-cameras
tp-link-tl-sg1210mp-10-port-gigabit-desktop-switch-with-8-port-poe > 8-port-poe-switches
tp-link-tl-sg1008mp-8-port-gigabit-desktop-rackmount-switch-with-8-port-poe > 8-port-poe-switches
tp-link-tl-sl1311p-8-port-10-100mbps-3-port-gigabit-desktop-switch-with-8-port-poe > 8-port-poe-switches
d-link-dgs-1008mp-8-port-gigabit-poe-unmanaged-switch > 8-port-poe-switches
...
```
Spec links came to the template after that first run, so a later dry run on the same store planned just the 18 spec links:
```text
:memo: Link plan (dry run, nothing written): 18 changes
*Spec links* (18)
reolink-rlc-810a-8mp-4k-poe-ip-bullet-camera > resolution: 4k-security-cameras
tp-link-tl-sg1210mp-10-port-gigabit-desktop-switch-with-8-port-poe > poe_ports: 8-port-poe-switches
tp-link-tl-sg1008mp-8-port-gigabit-desktop-rackmount-switch-with-8-port-poe > poe_ports: 8-port-poe-switches
tp-link-tl-sl1311p-8-port-10-100mbps-3-port-gigabit-desktop-switch-with-8-port-poe > poe_ports: 8-port-poe-switches
d-link-dgs-1008mp-8-port-gigabit-poe-unmanaged-switch > poe_ports: 8-port-poe-switches
ubiquiti-unifi-switch-16-poe-usw-16-poe > poe_ports: 8-port-poe-switches
d-link-dgs-1008p-8-port-gigabit-poe-unmanaged-switch > poe_ports: 8-port-poe-switches
reolink-rlc-820a-4k-8mp-turret-poe-ip-camera > resolution: 4k-security-cameras
...
```
When nothing in your store has drifted, **Plan the links** outputs zero items and the lane stops without posting to Slack.
On the second branch from **Plan the links**, add a Code node named **Batch the writes** (Mode: **Run Once for All Items**). Shopify's [`metafieldsSet` mutation](https://shopify.dev/docs/api/admin-graphql/2026-10/mutations/metafieldsSet) sets at most 25 metafields at a time, so this node splits updates into chunks of 25 and uses `metafieldsDelete` for any field that should become empty:
```javascript
// metafieldsSet takes up to 25 fields a call; an empty field is deleted rather than set.
const s = $('Link settings').first().json;
const all = $input.all().map(i => i.json);
const chunk = (xs, n) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, i * n + n));
const sets = all.filter(c => c.value)
.map(c => ({ ownerId: c.owner_id, namespace: s.namespace, key: c.field, type: c.type, value: c.value }));
const dels = all.filter(c => !c.value).map(c => ({ ownerId: c.owner_id, namespace: s.namespace, key: c.field }));
const SET = `mutation Set($m: [MetafieldsSetInput!]!) {
metafieldsSet(metafields: $m) { metafields { id } userErrors { field message code } } }`;
const DEL = `mutation Del($m: [MetafieldIdentifierInput!]!) {
metafieldsDelete(metafields: $m) { deletedMetafields { key } userErrors { field message } } }`;
return [
...chunk(sets, 25).map(m => ({ json: { query: SET, variables: { m } } })),
...chunk(dels, 25).map(m => ({ json: { query: DEL, variables: { m } } })),
];
```
Connect a Filter node named **Live run?** that keeps items when `{{ !$('Link settings').first().json.dry_run }}` (Boolean) is true, followed by an HTTP Request node named **Write the links** (Method: **POST** to the Shopify GraphQL URL with the Link token header, JSON body `={{ JSON.stringify({ query: $json.query, variables: $json.variables }) }}`, and under Options > Batching set Items per Batch to `1` with Batch Interval `500` ms). Place a red sticky note over **Write the links** reading: `Writes to your store. Sets or clears the six link fields. Leave dry_run true until the Slack summary and link_changes look right.`
Finish the branch with a Code node named **Any errors?** (Mode: **Run Once for All Items**). Because Shopify returns refused writes inside `userErrors` with an HTTP 200 status, this node throws an error so failed writes show up in your n8n execution log:
```javascript
// Shopify answers refused writes with HTTP 200 and userErrors, so check them here.
const errs = $input.all().flatMap(i => [
...((i.json.data && i.json.data.metafieldsSet && i.json.data.metafieldsSet.userErrors) || []),
...((i.json.data && i.json.data.metafieldsDelete && i.json.data.metafieldsDelete.userErrors) || []),
...(i.json.errors || []),
]);
if (errs.length) throw new Error('Shopify refused some links: ' + JSON.stringify(errs).slice(0, 500));
return [{ json: { batches: $input.all().length } }];
```
On our test store (38 live products, 24 collections), a dry run took about 2 seconds, and the live run wrote 83 fields across 4 batches in about 4 seconds; a second Link run found nothing to change and stopped immediately.
### Step 5: Count every link into each collection
In the Audit lane, add a Schedule Trigger named **Every Monday** (weekly on Monday at 06:00) alongside a Manual Trigger named **Run Audit now**, connecting both to a Set node named **Audit settings** (Mode: JSON):
```json
{
"store_domain": "your-store.myshopify.com",
"namespace": "custom",
"tree_menu": "main-menu",
"skip_menus": [],
"ignore": [
"frontpage",
"all"
],
"theme_linked": [],
"max_pills": 24,
"weak_below": 2,
"check_product_fields": true,
"check_theme": false,
"slack_channel": "#log-seo"
}
```
| Setting | What it does |
|---|---|
| `skip_menus` | Menus that aren't shown anywhere (such as a backup copy), so their links don't count |
| `ignore` | Collections the audit never reports (`frontpage` and `all`) |
| `theme_linked` | Handles your theme links in code (a homepage row, the footer) that store data can't show |
| `max_pills` | Must match `max_children` in Link settings |
| `weak_below` | A collection outside the menu with fewer links than this is reported as weak (2 means one link in) |
| `check_product_fields` | Report active products that have no primary collection |
| `check_theme` | Read the live theme's collection and product templates (needs the `read_themes` scope) |
Connect **Get Shopify token for Audit**, then add **Audit read collections** using the same GraphQL query and pagination settings as **Read collections** in Step 2 (pointing its expressions at `Audit settings` and `Get Shopify token for Audit`). Then connect an HTTP Request node named **Read pages, posts and redirects** (Method: **POST**, Execute Once: **On**, no pagination) to pull the HTML bodies of your first 250 published [pages](https://shopify.dev/docs/api/admin-graphql/latest/objects/Page), [blog articles](https://shopify.dev/docs/api/admin-graphql/latest/objects/Article) and URL redirects:
```graphql
{
pages(first: 250, query: "published_status:published") { nodes { handle body } }
articles(first: 250, query: "published_status:published") { nodes { handle body blog { handle } } }
urlRedirects(first: 250) { nodes { path target } }
}
```
Add **Audit read products** (using the same query and pagination settings as **Read products** in Step 2), followed by an HTTP Request node named **Read the theme** whose JSON body expression requests the live theme's `templates/collection.json` and `templates/product.json` files only when `check_theme` is true, and falls back to `{ shop { name } }` otherwise:
```text
={{ JSON.stringify({ query: $('Audit settings').first().json.check_theme ? "{\n themes(first: 1, roles: [MAIN]) { nodes { name files(filenames: [\"templates/collection.json\", \"templates/product.json\"]) {\n nodes { filename body { ... on OnlineStoreThemeFileBodyText { content } } } } } }\n}" : '{ shop { name } }' }) }}
```
Connect a Code node named **Count inbound links** (Mode: **Run Once for All Items**, with **Always Output Data** turned on in the node settings so the Slack report still runs when zero issues are found):
```javascript
const s = $('Audit settings').first().json;
const pages = $('Audit read collections').all();
const content = $('Read pages, posts and redirects').first().json;
for (const p of [...pages, ...$('Audit read products').all(), $input.first()]) if (p.json.errors) throw new Error(JSON.stringify(p.json.errors).slice(0, 500));
if (content.errors) throw new Error(JSON.stringify(content.errors).slice(0, 500));
const cols = pages.flatMap(i => i.json.data.collections.nodes).filter(c => !s.ignore.includes(c.handle));
const menus = pages[0].json.data.menus.nodes.filter(m => !s.skip_menus.includes(m.handle));
const docs = [...content.data.pages.nodes.map(d => ({ handle: 'pages/' + d.handle, body: d.body })),
...content.data.articles.nodes.map(d => ({ handle: 'blogs/' + d.blog.handle + '/' + d.handle, body: d.body }))];
const redirects = Object.fromEntries(content.data.urlRedirects.nodes.map(r => [r.path.toLowerCase(), r.target]));
const products = $('Audit read products').all().flatMap(i => i.json.data.products.nodes);
const byHandle = Object.fromEntries(cols.map(c => [c.handle, c]));
const byId = Object.fromEntries(cols.map(c => [c.id, c]));
const h = id => (byId[id] || {}).handle;
const size = c => (c && c.productsCount.count) || 0;
const rules = c => (c && c.ruleSet && c.ruleSet.rules) || [];
const list = v => { try { return JSON.parse(v || '[]'); } catch (e) { return []; } };
const hrefs = (html, type) => [...String(html || '').matchAll(new RegExp('href="[^"]*/' + type + '/([a-z0-9-]+)', 'gi'))]
.map(m => m[1].toLowerCase());
const ancestors = start => { const out = []; for (let x = start; x && out.length < 20; x = h((byHandle[x].parent || {}).value)) out.push(x); return out; };
// Every link the audit can see, as target -> set of "surface:source".
const inbound = {};
const add = (target, surface, source) => {
if (target && byHandle[target] && target !== source) (inbound[target] = inbound[target] || new Set()).add(surface + ':' + source);
};
const inMenu = new Set();
const walk = items => { for (const it of items || []) {
const t = h(it.resourceId) || ((it.url || '').match(/\/collections\/([^/?#]+)/) || [])[1];
if (t) inMenu.add(t);
walk(it.items);
} };
menus.forEach(m => walk(m.items));
const shown = c => list(c && c.subs && c.subs.value).slice(0, s.max_pills).map(h).filter(x => x && size(byHandle[x]) > 0); // the theme hides empty ones
for (const c of cols) {
shown(c).forEach(x => add(x, 'sub-collection link', c.handle));
const up = h((c.parent || {}).value);
if (up) {
ancestors(up).forEach(x => add(x, 'breadcrumb', c.handle));
if (!shown(c).length) shown(byHandle[up]).forEach(x => add(x, 'sibling link', c.handle)); // no children: siblings instead
}
hrefs(c.descriptionHtml, 'collections').forEach(x => add(x, 'description', c.handle));
}
docs.forEach(d => hrefs(d.body, 'collections').forEach(x => add(x, 'page or post', d.handle)));
for (const p of products) {
add(h((p.brand || {}).value), 'brand link', p.handle);
const primary = h((p.primary || {}).value);
if (primary) ancestors(primary).forEach(x => add(x, 'product breadcrumb', p.handle));
list((p.related || {}).value).map(h).forEach(x => add(x, 'shop more like this', p.handle));
let specs = {}; try { specs = JSON.parse((p.specs || {}).value || '{}'); } catch (e) {}
Object.values(specs).forEach(x => add(x, 'spec link', p.handle));
}
const today = new Date().toISOString().slice(0, 10);
const out = [];
const find = (kind, handle, issue, detail = '', links = 0) =>
out.push({ json: { run_date: today, kind, handle, issue, detail, inbound: links } });
for (const c of cols) {
const links = inbound[c.handle] ? [...inbound[c.handle]] : [];
const reached = inMenu.has(c.handle) || s.theme_linked.includes(c.handle);
if (inMenu.has(c.handle) && size(c) === 0) find('collection', c.handle, 'menu links to an empty collection');
else if (!reached && size(c) > 0 && links.length === 0) find('collection', c.handle, 'orphan');
else if (!reached && size(c) > 0 && links.length < s.weak_below) find('collection', c.handle, 'weak', links.join(', '), links.length);
const up = byHandle[h((c.parent || {}).value)];
if (up && size(c) > 0 && !shown(up).includes(c.handle) && !hrefs(up.descriptionHtml, 'collections').includes(c.handle))
find('collection', c.handle, 'not linked from its parent', up.handle, links.length);
}
// Links that go through a redirect or lead nowhere.
const live = new Set(products.map(p => p.handle));
for (const [source, html] of [...cols.map(c => [c.handle, c.descriptionHtml]), ...docs.map(d => [d.handle, d.body])]) {
for (const type of ['collections', 'products']) for (const x of hrefs(html, type)) {
const to = redirects['/' + type + '/' + x];
if (to) find('link', source, 'link through a redirect', '/' + type + '/' + x + ' > ' + to);
else if (type === 'collections' ? !byHandle[x] && !s.ignore.includes(x) : !live.has(x)) find('link', source, 'broken link', '/' + type + '/' + x);
}
}
// Products and vendors.
const brandVendors = new Set(cols.filter(c => rules(c).length === 1 && rules(c)[0].column === 'VENDOR').map(c => rules(c)[0].condition.toLowerCase()));
const noBrand = {};
for (const p of products) {
const mine = p.collections.nodes.map(n => h(n.id)).filter(Boolean);
if (!mine.length) find('product', p.handle, 'in no published collection');
else if (s.check_product_fields && !(p.primary || {}).value) find('product', p.handle, 'no primary collection');
if (p.vendor && !brandVendors.has(p.vendor.toLowerCase())) noBrand[p.vendor] = (noBrand[p.vendor] || 0) + 1;
}
for (const [v, n] of Object.entries(noBrand)) find('vendor', v, 'no brand page', n + (n === 1 ? ' product' : ' products'));
// Optional: theme settings that hide links (check_theme, read_themes scope).
const theme = (($input.first().json.data || {}).themes || { nodes: [] }).nodes[0];
if (s.check_theme && theme) {
const file = n => { const f = theme.files.nodes.find(x => x.filename === n); return f && f.body ? f.body.content : ''; };
const col = file('templates/collection.json'), prod = file('templates/product.json');
// Horizon's "Auto load products on scroll" is on unless the template saves it as false.
if (!/"enable_infinite_scroll"\s*:\s*false/.test(col)) find('theme', 'templates/collection.json', 'products load on scroll, so page 2 has no link');
if (!/parent_collection/.test(col)) find('theme', 'templates/collection.json', 'no breadcrumb block');
if (!/sub_collections/.test(col)) find('theme', 'templates/collection.json', 'no sub-collection links block');
if (!/primary_collection/.test(prod)) find('theme', 'templates/product.json', 'no product breadcrumb block');
if (!/custom\.brand|\.brand\.value/.test(prod)) find('theme', 'templates/product.json', 'no brand link block');
if (products.some(p => (p.specs || {}).value) && !/spec_links/.test(prod)) find('theme', 'templates/product.json', 'no linked specs table');
}
return out;
```
This node counts inbound links across menus, sub-collection pills, breadcrumbs, sibling links, collection descriptions, pages, blog posts, product brand links, product breadcrumbs, spec links and "Shop more like this" lists. A store-data audit can't see links hard-coded inside theme files (which is what `theme_linked` accounts for), links injected by scripts after the page loads, or sections the template doesn't read. A rendered-page crawler such as Screaming Frog or Sitebulb checks those surfaces, while this weekly audit keeps your structural links verified between crawls.
### Step 6: Report orphan pages, weak pages, broken and redirected links
From **Count inbound links**, split into two branches. On the first branch, connect a Filter node named **Has a finding?** that keeps items when `{{ Boolean($json.issue) }}` is true, followed by a Data table node named **Save findings** (Resource: **Row**, Operation: **Insert**, Table: `link_findings`), mapping `run_date`, `kind`, `handle`, `issue`, `detail`, and `inbound` from the matching JSON fields.
On the second branch, connect an HTTP Request node named **Post audit report** (Method: **POST**, URL: `https://slack.com/api/chat.postMessage`, Slack API credential, Execute Once: **On**) with this JSON body expression:
```text
={{ JSON.stringify((() => {
const f = $('Count inbound links').all().map(i => i.json).filter(x => x.issue);
const by = k => f.filter(x => x.issue === k);
const line = (label, xs, fmt) => xs.length ? '*' + label + '* (' + xs.length + '): '
+ xs.slice(0, 15).map(fmt).join(', ') + (xs.length > 15 ? ', ...' : '') + '\n' : '';
return { channel: $('Audit settings').first().json.slack_channel, unfurl_links: false,
text: ':mag: Weekly internal link audit\n' +
(f.length ? '' : 'No orphans, weak pages or broken links this week.\n') +
line('Orphans, nothing links to them', by('orphan'), x => x.handle) +
line('Weak, only one link in', by('weak'), x => x.handle + ' (' + x.detail + ')') +
line('Not linked from their parent', by('not linked from its parent'), x => x.handle + ' (parent ' + x.detail + ')') +
line('Menu links to empty collections', by('menu links to an empty collection'), x => x.handle) +
line('Broken links', by('broken link'), x => x.handle + ' > ' + x.detail) +
line('Links through a redirect', by('link through a redirect'), x => x.handle + ': ' + x.detail) +
line('Products in no published collection', by('in no published collection'), x => x.handle) +
line('Products with no primary collection', by('no primary collection'), x => x.handle) +
line('Vendors with no brand page', by('no brand page'), x => x.handle + ' (' + x.detail + ')') +
line('Theme', f.filter(x => x.kind === 'theme'), x => x.handle.replace('templates/', '') + ': ' + x.issue) };
})()) }}
```
On our test store, the audit run took about 2.3 seconds. Before the Link lane wrote anything, it reported 14 orphan pages, 2 weak collections, 1 product in no published collection, 37 products with no primary collection, and 2 vendors with no brand page; after the live Link run, the next audit had zero orphans and flagged only real catalogue exceptions, including three single-product brand pages with one link in (`alogic`, `uniview`, `dahua`), eight solar cameras that sit only in a tag-based collection outside the menu tree, a broken link added to the Networking description (`networking > /products/tp-link-vigi-c300hp-discontinued`), and a link through a redirect (`networking: /collections/old-poe-switches > /collections/poe-switches`). With `check_theme` turned on against an unchanged Horizon before the setup steps, it also reported `collection.json: products load on scroll, so page 2 has no link`, `collection.json: no breadcrumb block`, `collection.json: no sub-collection links block`, `product.json: no product breadcrumb block`, `product.json: no brand link block`, and, once products had spec links, `product.json: no linked specs table`.
## What it costs
Because the workflow uses no AI model and no paid third-party APIs, your only cost is n8n itself (prices checked November 2026). The Link lane runs about 30 times a month and the Audit lane about 4 times a month, which fits inside [n8n Cloud Starter](https://n8n.io/pricing/) (about €20 a month billed annually for 2,500 executions) or runs for $0 on [self-hosted n8n Community Edition](https://docs.n8n.io/hosting/). Shopify Admin API requests are free; the product pass makes 1 request per 100 active products, every day in the Link lane and once a week in the Audit lane.
| Tool or component | 500 products | 2,000 products | 10,000 products |
|---|---|---|---|
| This template on self-hosted n8n | $0 / month (5 product requests a run) | $0 / month (20 product requests a run) | $0 / month (100 product requests a run) |
| This template on n8n Cloud Starter | ~€20 / month (~34 runs/month) | ~€20 / month (~34 runs/month) | ~€20 / month (~34 runs/month) |
| [Catalinks](https://apps.shopify.com/catalinks-internal-linking) (Shopify app, rule-based) | Free plan; Pro US$11.99 / month (adds orphan scans); Scale US$24.99 / month | Same plans (plans scale by links per rule, not catalogue size) | Same plans |
| [InterLinks](https://apps.shopify.com/interlinks) (Shopify app, keyword auto-linking) | Free for 1 link; Professional US$19 / month (US$180 / year) | Professional US$19 / month | Professional US$19 / month |
| [Screaming Frog SEO Spider](https://www.screamingfrog.co.uk/seo-spider/pricing/) | £199 / year (free version caps at 500 URLs, which a 500-product store exceeds once collections and pages are counted) | £199 / year | £199 / year |
Screaming Frog is the crawl you still run to see the rendered site; the template doesn't replace it. If your store rarely adds collections, you can run the Link lane weekly instead of daily, or turn off the fields you don't show in your theme (`write_related` and the others).
## Common mistakes
### Letting a model write links
Language models guess URLs and collection handles that look plausible but return 404 errors. Always pass verified handles from Shopify into deterministic code, as **Plan the links** and `linkFirstMentions` (in Make it your own) do, so every link points to a live page.
### Connecting a list field to a section that shows placeholders when it's empty
When Horizon's native Collection list section is connected to a dynamic source that evaluates to empty, it fills the container with four placeholder cards, so leaf collections show misleading dummy content. Use Custom Liquid blocks that output clean markup and collapse when empty.
### Assuming related products count as links
Horizon loads related and complementary product recommendations via client-side JavaScript from `/recommendations/products`. Because Shopify's default `robots.txt` disallows this path, search crawlers never see or follow these links.
### Leaving auto-load on
Leaving "Auto load products on scroll" on stops search engines from reaching products beyond the first 24 in a collection. Turn it off in your collection template so Horizon renders numbered `` pagination links.
### A menu with every collection in it
Stuffing every sub-category and brand into your header navigation overwhelms shoppers and spreads your strongest links too thin. Keep `main-menu` to the primary categories people browse by and let `custom.sub_collections` carry the narrower children on each parent page.
### Linking to empty collections
A collection with no products left (every product archived, unpublished or moved) becomes a dead end for shoppers and crawlers. Filter child collections by `min_products` in **Plan the links** and check `c.products_count > 0` in your Liquid snippets so empty collections hide immediately.
### A product breadcrumb that changes every run
If a product belongs to several collections, resolving its breadcrumb arbitrarily makes the trail change between runs. Always use a strict deterministic rule (deepest category tree collection, skipping vendor rules, ties broken by menu order) so the URL path stays stable.
### Leaving broken and redirected links in old copy
When handles change or old products are retired, links typed into collection descriptions and blog posts get left behind, pointing at a redirect or a 404 page. The weekly audit reads every published description, page and post and checks each link against your live collections, products and Shopify's URL redirects, so update the link to its new target when it's flagged.
### Trusting Search Console's Links report as complete
Store owners often assume that if a page is missing from Google Search Console's internal links table, nothing links to it. Google's [Search Console Links report documentation](https://support.google.com/webmasters/answer/9049606) notes that the report isn't a comprehensive list of every link on your site and caps tables at 1,000 rows, so use the weekly Audit lane to check your entire catalogue.
### Liquid lists that stop at 50
If you build a directory page (all your categories, say) from metaobjects, Shopify's [metaobject Liquid limits](https://shopify.dev/docs/apps/build/metaobjects/metaobject-limits) return at most 50 entries in a standard loop and silently drop every entry past 50. Wrap the metaobject loop in a `{% paginate ... by 250 %}` tag so all of them render.
### A filter inside square brackets in Liquid
Liquid syntax does not support applying filters inside square bracket lookups (writing `collections[vendor | handleize]` evaluates to empty). Assign the handle string to a variable first (`assign brand_handle = vendor | handleize`), then access `collections[brand_handle]`.
## Make it your own
### Brand links on product cards
Horizon's product card takes a **Custom Liquid** block. In the theme editor, open the Collection template, select the product card inside the **Collection** section, click **Add block > Custom Liquid**, drag it under the product title and paste:
```liquid
{%- assign brand = closest.product.metafields.custom.brand.value -%}
{%- if brand and brand.products_count > 0 -%}
{{ brand.title }}
{%- endif -%}
```
The card's own link covers the card as an empty `` beside the content, so this link sits in valid HTML and stays clickable. Swap `custom.brand` for a spec collection by reading `custom.spec_links` the same way the specs table does.
### Accessories and "compatible with" lists
To link compatible products directly in HTML, create a product metafield named `custom.accessories` of type `list.product_reference`. In your product template, add a Custom Liquid block below the product details that iterates over `product.metafields.custom.accessories.value` and renders links to each accessory's canonical URL (`item.url`), skipping out-of-stock items.
### Product group links
If you separate hardware models into distinct product handles rather than variants (such as switches offering 8, 16, or 24 ports), link the group with a product metafield list pointing to the other models in it. Render them as an HTML unordered list of text links under the title so crawlers can navigate between models.
### Links in product descriptions, in code
To add contextual links inside product descriptions without a model guessing URLs or a broken handle, pass verified collections into this helper function in an n8n Code node:
```javascript
// Link the first mention of each related collection, longest title first, capped.
// The model never writes a URL: links come only from the handles you pass in.
const esc = t => String(t).replace(/&/g, '&').replace(//g, '>');
const rx = t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
function linkFirstMentions(text, family, maxLinks) {
let html = esc(text), budget = maxLinks;
const linked = [];
for (const f of [...family].sort((a, b) => b.title.length - a.title.length)) {
const re = new RegExp(`(^|[^\\w>])(${rx(esc(f.title))})(?![\\w<])`, 'i');
if (budget > 0 && re.test(html)) {
html = html.replace(re, `$1$2`);
linked.push(f.handle);
budget--;
}
}
return { html, linked };
}
// linkFirstMentions('Pair these cameras with a PoE switch from our PoE Switches range.',
// [{ title: 'PoE Switches', handle: 'poe-switches' }], 2)
```
To link a product description back to its primary category and brand page, run `linkFirstMentions` over the plain-text description and pass only that product's primary collection and brand collection in `family` with `maxLinks` set to `2`. Re-run it whenever the product moves to a different category so the links don't go stale.
### Other themes
On Dawn or an older vintage theme, check product card snippets for [`within: collection`](https://shopify.dev/docs/api/liquid/filters/within) and remove it so cards link directly to `/products/`. Also look for `url_for_vendor` and `url_for_type` in product templates and replace them with a direct lookup to your brand and category collections (Links to avoid explains why). Themes with built-in breadcrumb settings can be pointed at `custom.parent_collection`.
### Other platforms
WooCommerce product categories already have a built-in `parent` field and BigCommerce categories have `parent_id`. If you run either platform, swap the Shopify HTTP Request nodes for WooCommerce or BigCommerce API calls and read the parent ID directly instead of walking the navigation menu.
### When Data Tables aren't enough
n8n [Data Tables share a 200 MiB storage limit](https://docs.n8n.io/build/work-with-data/data-tables/) per instance by default, and `link_findings` only grows by a few hundred rows a week on most stores, while `link_changes` gets one row per changed field (so the first run on a large catalogue adds a lot at once). If you manage a massive catalogue or keep years of history, swap the Data Table nodes for Postgres (for example, [Supabase's free plan](https://supabase.com/pricing) includes 500 MB per project, checked November 2026); the repo has a Supabase version of the template.
## FAQ
### How many internal links should a page have?
Google states in its [link best practices](https://developers.google.com/search/docs/crawling-indexing/links-crawlable) that there's no magical ideal number of links a given page should contain. For body copy, [Shopify's internal linking guide](https://www.shopify.com/blog/internal-links-seo) suggests roughly two to five contextual links per 1,000 words, while for category navigation and sub-collection pills you should include as many links as help shoppers narrow their search.
### What is an orphan page in an online store?
As [Ahrefs defines it](https://ahrefs.com/blog/internal-links-for-seo/), orphan pages are pages with no internal links pointing to them from anywhere else on your site. In an online store, an orphan is almost always a smart collection created by rules that was never added to a menu or parent category, a brand collection no product links to, or an active product that sits in no published collection.
### Do related products count as internal links?
Not on Horizon: it loads both related and complementary products via client-side JavaScript from `/recommendations/products`, which Shopify's default `robots.txt` blocks from search crawlers. For crawlers to see product-to-product links, they must be rendered directly in server-side HTML.
### Should I use an internal linking app?
Rule-based apps can save time for blog articles if you review what they link, cap the links per post and keep anchors varied. However, the highest-value links in an online store come from breadcrumbs, sub-collection lists and brand relationships stored in your catalogue structure, which a keyword-matching app can't see, and links written into your own fields and theme stay put if you ever cancel an app, whereas [links an app injects with JavaScript](https://allintitle.co/blog/best-internal-linking-tools-tested/) go with it.
### Does Shopify have breadcrumbs built in?
Horizon has no breadcrumbs or BreadcrumbList structured data, and because Shopify stores all collections at a flat `/collections/` path, themes have no native parent structure to read. Some other themes include a breadcrumb, and a theme that lets you choose its source can read the same `custom.parent_collection` field to show a multi-level trail.
---
Turn off auto-load in your collection template today, create the six link fields, and paste the Custom Liquid blocks into an unpublished theme preview. From there, populate a few fields by hand or import the n8n template, run Setup and Link in dry-run mode, and review your store's first automated audit.
- Fills six link fields (breadcrumb parent, sub-collections, brand, primary collection, spec links, "Shop more like this") from your menu, collection rules and vendors, every day.
- Starts as a dry run and logs every change with its old value before anything is written.
- Posts a weekly Slack audit of orphan pages, weak pages, broken links and links through redirects.