Automating Internal Linking in n8n: How to Parse WordPress Sitemaps & Inject Contextual Links with Gemini Flash

┌───────────────────────────────┐
│     Live XML Sitemap          │ (sitemap_index.xml or post-sitemap.xml)
└───────────────────────────────┘
                │
                ▼
┌───────────────────────────────┐
│   Node: Parse sitemap URLs    │───► Regex extraction (no heavy XML parser)
└───────────────────────────────┘     Buckets by language (/de/, /fr/, root)
                │
                ▼
┌───────────────────────────────┐
│   Node: Gemini Flash Matcher  │───► Analyzes candidate URLs against topic
└───────────────────────────────┘     Selects top 4-6 contextual links
                │
                ▼
┌───────────────────────────────┐
│ Node: Anti-Hallucination Gate │───► Host allowlist + Set intersection
└───────────────────────────────┘     Filters out any invented/spoofed URLs
                │
                ▼
┌───────────────────────────────┐
│   Markdown & HTML Assembly    │───► Injects "Related Articles" block &
└───────────────────────────────┘     WordPress Custom HTML format

// Parse sitemap_index + post-* sub-sitemaps via helpers.httpRequest
const CFG = $('CONFIG').first().json;
const urlsByLang = { de: [], en: [], fr: [] };
const LANGS = ['de', 'en', 'fr'];
const ROOT_LANG = CFG.root_language || 'en';

function firstSeg(loc) {
  const path = loc.replace(/^https?:\/\/[^/]+/, '');
  return (path.split('/').filter(Boolean)[0] || '').toLowerCase();
}

function titleFromUrl(u) {
  const path = u.replace(/^https?:\/\/[^/]+/, '').replace(new RegExp('^/(' + LANGS.join('|') + ')/'), '/');
  const segs = path.split('/').filter(Boolean);
  const slug = segs[segs.length - 1] || '';
  return slug.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
}

// 1. Fetch the master sitemap index
const idx = await this.helpers.httpRequest({ url: CFG.sitemap_url, json: false });
const idxStr = String(idx);
const allLocs = [...idxStr.matchAll(/<loc>(.*?)<\/loc>/g)].map(m => m[1]);

let children = [];
if (/<sitemapindex/i.test(idxStr)) {
  // Filter for post sitemaps, capped to top 20 to prevent timeout
  const posts = allLocs.filter(u => /post-sitemap\d*\.xml/i.test(u));
  children = (posts.length ? posts : allLocs.filter(u => /\.xml/i.test(u))).slice(0, 20);
} else {
  children = [CFG.sitemap_url];
}

// 2. Extract active URLs and categorize by language
for (const childUrl of children) {
  const host = childUrl.replace(/^https?:\/\//, '').split('/')[0].toLowerCase();
  if (host !== CFG.brand_domain && host !== ('www.' + CFG.brand_domain)) continue;

  try {
    const xml = await this.helpers.httpRequest({ url: childUrl, json: false });
    for (const match of [...String(xml).matchAll(/<loc>(.*?)<\/loc>/g)]) {
      const loc = match[1].trim();
      const seg = firstSeg(loc);
      const lang = LANGS.indexOf(seg) >= 0 ? seg : ROOT_LANG;
      if (lang) urlsByLang[lang].push(loc);
    }
  } catch (err) {
    // Graceful continuation if a sub-sitemap is 404
  }
}

// 3. Format candidates with auto-generated titles
for (const lang of LANGS) {
  urlsByLang[lang] = urlsByLang[lang].slice(0, 40).map(u => ({
    url: u,
    title: titleFromUrl(u)
  }));
}

return [{ json: { ...$input.first().json, sitemap_urls_by_lang: urlsByLang } }];

You choose relevant internal links for 3 language versions of an article.
For EACH language, you receive candidate URLs (title + URL) and the topic of the current article.

RULES:
1. Use ONLY URLs present in the provided list. NEVER invent or extrapolate a URL.
2. anchor_text: a natural, conversational label in the language (do not just dump the raw slug).
3. Do NOT include the current article itself.
4. Output strictly valid JSON.

JSON Schema:
{
  "de": [{"anchor_text": "...", "target_url": "..."}],
  "en": [{"anchor_text": "...", "target_url": "..."}],
  "fr": [{"anchor_text": "...", "target_url": "..."}]
}

const raw = $input.first().json.content || '';
const previousData = $('Parse sitemap URLs').first().json;
const brandDomain = String($('CONFIG').first().json.brand_domain || '').toLowerCase().replace(/^www\./, '');

// Build set of verified URLs that actually existed in the XML sitemap
const verifiedUrls = new Set();
const sitemapData = previousData.sitemap_urls_by_lang || {};
for (const lg of ['de', 'en', 'fr']) {
  for (const item of (sitemapData[lg] || [])) {
    if (item && item.url) verifiedUrls.add(item.url);
  }
}

// Validate LLM output
let suggestedLinks = { de: [], en: [], fr: [] };
try {
  const match = raw.match(/\{[\s\S]*\}/);
  if (match) suggestedLinks = JSON.parse(match[0]);
} catch (e) {
  suggestedLinks = { de: [], en: [], fr: [] };
}

const cleanLinksByLang = {};
for (const lang of ['de', 'en', 'fr']) {
  const candidates = Array.isArray(suggestedLinks[lang]) ? suggestedLinks[lang] : [];

  // FILTER: Must exist in sitemap AND belong to verified domain
  cleanLinksByLang[lang] = candidates.filter(link => {
    if (!link || !link.target_url) return false;
    const url = link.target_url.toLowerCase();
    const isDomainMatch = url.includes(brandDomain);
    const isActuallyInSitemap = verifiedUrls.has(link.target_url);
    return isDomainMatch && isActuallyInSitemap;
  });
}

return [{ json: { ...previousData, internal_links_by_lang: cleanLinksByLang } }];

## Related Articles
- [How to Build an Autonomous B2B Lead Enrichment Engine](https://example.com/en/blog/b2b-lead-enrichment-guide)
- [n8n vs Make: Enterprise Scalability Comparison](https://example.com/en/blog/n8n-vs-make-enterprise-comparison)