Structured data testen: tools en validatiemethoden

Waarom validatie van structured data essentieel is

Het implementeren van Schema.org markup op je website is een krachtige stap richting betere AI-zichtbaarheid. Maar markup die syntactisch incorrect is, ontbrekende verplichte velden bevat of logische fouten heeft, kan meer kwaad dan goed doen. Zoekmachines zoals Google negeren foutieve markup stilzwijgend, en AI-modellen kunnen verkeerde conclusies trekken uit onvolledige of tegenstrijdige gestructureerde data.

Validatie is daarom geen optionele stap, maar een fundamenteel onderdeel van je AEO-strategie. Net zoals je een website test op functionaliteit voordat je hem lanceert, moet je je structured data testen voordat je erop vertrouwt dat AI-modellen deze correct verwerken. In dit artikel doorlopen we de belangrijkste tools, validatiemethoden en veelvoorkomende fouten die je moet kennen.

Google Rich Results Test: de onmisbare eerste stap

De Google Rich Results Test (search.google.com/test/rich-results) is het startpunt voor elke validatie. Deze tool controleert of je markup in aanmerking komt voor rijke zoekresultaten in Google Search. Je voert een URL in of plakt een stuk HTML-code, en de tool analyseert welke structured data types worden gedetecteerd, of er fouten of waarschuwingen zijn, en welke rich results je pagina kan genereren.

• Voer zowel de live URL als de broncode in voor een compleet beeld. Soms wijkt de gerenderde versie af van de broncode.
• Controleer alle gedetecteerde items, niet alleen het eerste. Een pagina kan meerdere structured data blokken bevatten.
• Let op het verschil tussen fouten (rood) en waarschuwingen (geel). Fouten verhinderen rich results; waarschuwingen beperken de functies.
• Test zowel de desktop- als de mobiele versie van je pagina, want de content kan verschillen.

<!-- Voorbeeld: Article markup met veelvoorkomende fouten -->\n<script type="application/ld+json">\n{\n  "@context": "https://schema.org",\n  "@type": "Article",\n  "headline": "Structured Data Testen",\n  "datePublished": "2026-04-24",\n  "author": {\n    "@type": "Person",\n    "name": "Jan de Vries",\n    "url": "https://example.nl/team/jan"\n  },\n  "publisher": {\n    "@type": "Organization",\n    "name": "Voorbeeld BV",\n    "logo": {\n      "@type": "ImageObject",\n      "url": "https://example.nl/images/logo.png"\n    }\n  },\n  "image": "https://example.nl/images/artikel-header.jpg",\n  "description": "Een complete gids voor het testen van structured data."\n}\n</script>

De bovenstaande markup bevat alle verplichte velden voor een Article type. Laat je een van deze velden weg (bijvoorbeeld publisher of image), dan zal de Rich Results Test een fout melden en komt je pagina niet in aanmerking voor rijke zoekresultaten.

Schema Markup Validator: diepgaande syntaxcontrole

Waar de Google Rich Results Test zich richt op Google-specifieke rich results, controleert de Schema Markup Validator (validator.schema.org) of je markup voldoet aan de volledige Schema.org specificatie. Deze tool is strenger en detecteert problemen die de Google-tool over het hoofd ziet.

De Schema Markup Validator controleert of je de juiste property-namen gebruikt, of waarden het verwachte datatype hebben en of je verplichte properties niet mist. Dit is vooral belangrijk voor AI-modellen die de volledige Schema.org vocabulaire interpreteren, niet alleen de subset die Google ondersteunt. Een property als sameAs wordt door Google mogelijk genegeerd, maar door AI-modellen als Perplexity en ChatGPT actief gebruikt voor verificatie.

Verschil tussen Google Rich Results Test en Schema Markup Validator

• Google Rich Results Test valideert alleen types die Google ondersteunt voor rich results (Article, FAQ, HowTo, Product, enzovoort).
• Schema Markup Validator valideert alle Schema.org types en properties, inclusief die welke Google negeert maar AI-modellen wel gebruiken.
• Gebruik beide tools: de Rich Results Test voor Google-specifieke compatibiliteit, de Schema Validator voor volledige correctheid.

Gestructureerde data testen in de browser

Naast online tools kun je structured data ook direct in je browser inspecteren. Dit is bijzonder handig tijdens het ontwikkelproces, wanneer je snel wilt controleren of je wijzigingen correct zijn doorgevoerd.

// Chrome DevTools: structured data inspecteren\n// Stap 1: Open DevTools (F12 of Cmd+Option+I)\n// Stap 2: Ga naar het Elements-tabblad\n// Stap 3: Zoek naar script[type="application/ld+json"]\n// Stap 4: Kopieer de inhoud en valideer via de console:\n\nconst ldJsonScripts = document.querySelectorAll(\n  'script[type="application/ld+json"]'\n);\nldJsonScripts.forEach((script, index) => {\n  try {\n    const data = JSON.parse(script.textContent);\n    console.log(`Schema block ${index + 1}:`, data);\n    console.log(`Type: ${data['@type']}`); \n  } catch (e) {\n    console.error(`Fout in block ${index + 1}:`, e.message);\n  }\n});

Dit script is een snelle manier om te controleren of je JSON-LD parseerbaar is. Syntaxfouten zoals een ontbrekende komma of een extra accolade worden direct zichtbaar in de console. Voor complexere validatie zijn er ook Chrome-extensies beschikbaar die je structured data automatisch analyseren.

• Schema Builder for Structured Data Testing: een Chrome-extensie die alle structured data op een pagina visualiseert in een overzichtelijk paneel.
• Structured Data Testing Tool (SDTT) extension: geeft een snel overzicht van gevonden types en eventuele fouten.
• JSON-LD Playground (json-ld.org/playground): een online tool om JSON-LD te expanderen, compacteren en visualiseren.

Geautomatiseerde validatie in je CI/CD pipeline

Handmatige validatie is goed voor incidentele controles, maar voor een robuust proces wil je structured data validatie automatiseren. Dit kan door validatie op te nemen in je CI/CD pipeline, zodat elke deployment automatisch wordt gecontroleerd.

# Voorbeeld: geautomatiseerde Schema.org validatie met Node.js\n# Installeer de benodigde packages\nnpm install structured-data-testing-tool --save-dev\n\n# Maak een testscript (test-schema.js)\nconst { structuredDataTest } = require('structured-data-testing-tool');\n\nconst urls = [\n  'https://example.nl/',\n  'https://example.nl/blog/voorbeeld-artikel',\n  'https://example.nl/diensten',\n];\n\nasync function validateAll() {\n  for (const url of urls) {\n    try {\n      const result = await structuredDataTest(url);\n      console.log(`OK: ${url} - ${result.schemas.length} schema(s)`);\n    } catch (err) {\n      console.error(`FOUT: ${url}`);\n      err.errors.forEach(e => console.error(`  - ${e.message}`));\n      process.exitCode = 1;\n    }\n  }\n}\n\nvalidateAll();

Door dit script op te nemen in je CI/CD pipeline (bijvoorbeeld als stap in GitHub Actions of GitLab CI), worden broken structured data automatisch gedetecteerd voordat ze productie bereiken. Dit voorkomt dat een onoplettende wijziging in een template al je markup breekt.

# GitHub Actions workflow voor structured data validatie\nname: Validate Structured Data\non:\n  pull_request:\n    branches: [main]\n\njobs:\n  validate-schema:\n    runs-on: ubuntu-latest\n    steps:\n      - uses: actions/checkout@v4\n      - uses: actions/setup-node@v4\n        with:\n          node-version: 20\n      - run: npm ci\n      - run: npm run build\n      - run: node test-schema.js

Veelvoorkomende validatiefouten en oplossingen

Na honderden structured data audits zien we steeds dezelfde fouten terugkomen. Hier zijn de meest voorkomende problemen en hun oplossingen.

1. Ontbrekende verplichte velden: Google vereist specifieke properties per type. Voor Article zijn headline, image, datePublished, author en publisher verplicht. Controleer de Google Search Central documentatie voor de volledige lijst per type.
2. Verkeerd datatype: een datePublished waarde als "april 2026" in plaats van het ISO 8601 formaat "2026-04-24T10:00:00+02:00". Datums moeten altijd in ISO 8601 formaat staan.
3. Ongeldige URL's in image of url properties: relatieve paden zoals "/images/foto.jpg" in plaats van absolute URL's zoals "https://example.nl/images/foto.jpg". Gebruik altijd volledige, absolute URL's.
4. Meerdere conflicterende @type declaraties: twee JSON-LD blokken die dezelfde entiteit beschrijven met verschillende waarden. Zorg dat elk blok een uniek onderwerp beschrijft of combineer ze in een @graph.
5. JSON-syntaxfouten: een vergeten komma, een extra komma na het laatste item of niet-geescapete aanhalingstekens in waarden. Valideer je JSON altijd met een linter voordat je het deployt.

<!-- FOUT: ontbrekend publisher object -->\n<script type="application/ld+json">\n{\n  "@context": "https://schema.org",\n  "@type": "Article",\n  "headline": "Test Artikel",\n  "datePublished": "2026-04-24"\n}\n</script>\n\n<!-- CORRECT: alle verplichte velden aanwezig -->\n<script type="application/ld+json">\n{\n  "@context": "https://schema.org",\n  "@type": "Article",\n  "headline": "Test Artikel",\n  "datePublished": "2026-04-24T10:00:00+02:00",\n  "author": {\n    "@type": "Person",\n    "name": "Jan de Vries"\n  },\n  "publisher": {\n    "@type": "Organization",\n    "name": "Voorbeeld BV",\n    "logo": {\n      "@type": "ImageObject",\n      "url": "https://example.nl/logo.png"\n    }\n  },\n  "image": "https://example.nl/images/header.jpg"\n}\n</script>

Een systematisch validatieproces opzetten

De meest effectieve aanpak is een gelaagd validatieproces dat meerdere tools combineert en op vaste momenten wordt uitgevoerd.

1. Tijdens ontwikkeling: gebruik browser DevTools en de JSON-LD Playground om markup direct te controleren terwijl je bouwt.
2. Bij elke pull request: voer geautomatiseerde validatie uit in je CI/CD pipeline om regressies te voorkomen.
3. Na deployment: test de live URL in de Google Rich Results Test en de Schema Markup Validator.
4. Wekelijks: controleer Google Search Console op structured data fouten en waarschuwingen voor je gehele site.
5. Maandelijks: voer een handmatige audit uit op je belangrijkste pagina's en vergelijk de resultaten met vorige maand.

Structured data validatie is geen eenmalige actie, maar een doorlopend proces. Elke template-wijziging, elk CMS-update en elke nieuwe pagina kan ongemerkt je markup breken.

Samenvatting

• Valideer structured data altijd met meerdere tools: de Google Rich Results Test voor Google-compatibiliteit en de Schema Markup Validator voor volledige Schema.org correctheid.
• Gebruik browser DevTools en extensies voor snelle controles tijdens het ontwikkelproces.
• Automatiseer validatie in je CI/CD pipeline om regressies te voorkomen bij elke deployment.
• De vijf meest voorkomende fouten zijn ontbrekende verplichte velden, verkeerde datatypen, relatieve URL's, conflicterende blokken en JSON-syntaxfouten.
• Stel een gelaagd validatieproces op dat handmatige controles combineert met geautomatiseerde tests en regelmatige audits.

Veelgestelde vragen

Vertrouw niet blind op een groene validatie. Test je markup in meerdere tools, controleer de output in Google Search Console en verifieer dat AI-modellen je gestructureerde data daadwerkelijk oppikken.