Veel trajecten met schema markup stranden op dezelfde fout: prioriteiten blijven impliciet. Je bent druk, maar merkt pas laat dat de verkeerde zaken al maanden aandacht krijgen. Leg vooraf vast wat ‘goed’ betekent (doel, tijd, stop-moment) en toets elke stap daaraan.
Kort stappenplan:
- Kies je doelen en prioritaire content – focust waar de winst waarschijnlijk het grootst is
- Selecteer passende schema.org-types en properties – maakt de betekenis van je pagina’s expliciet
- Maak compacte JSON-LD-snippets – houdt implementatie los van je HTML
- Plaats de markup via CMS, tag manager of code – rolt snel en netjes uit
- Test met Rich Results Test en Schema Markup Validator – helpt fouten te voorkomen vóór publicatie
Herken je deze uitdaging?
Veel organisaties lopen vast bij Schema markup: onduidelijke keuzes, verkeerde prioriteiten, of resultaten die tegenvallen. Krijg helder welke aanpak bij jouw situatie past en waar je nu moet beginnen.
Wat is schema markup?
Bij schema markup helpt het om eerst helder te krijgen wat ‘goed’ betekent voor jouw situatie (doel, tijd, budget, risico), voordat je keuzes maakt. Praktisch: leg vooraf één meetpunt en één stopmoment vast, dan voorkom je bijsturen op gevoel. Je start meestal zonder duidelijk kader. Drie weken later discussieer je nog over wat ‘goed’ is. Leg daarom vooraf vast welke uitkomst acceptabel is (tijd, budget, risico) en toets elke keuze daaraan. Je wint vaker door te schrappen dan door toe te voegen.
Schema markup is gestructureerde data waarmee je zoekmachines expliciet vertelt wat er op je pagina staat en hoe onderdelen zich tot elkaar verhouden. Schema markup helpt zoekmachines de context van je content beter te begrijpen, wat vaak leidt tot rijkere zoekresultaten en hogere doorklikratio’s.
Je voegt het toe als code die voor bezoekers onzichtbaar is, maar voor crawlers helder maakt of iets bijvoorbeeld een artikel, product, recept, evenement of organisatie is. Meestal gebruik je hiervoor JSON-LD, een compact gegevensformaat dat je in de head of body van je pagina plaatst.
Het “woordenboek” waarop de markup is gebaseerd komt van Schema.org en bevat honderden types en eigenschappen waarmee je entiteiten en details kunt beschrijven, zoals titel, auteur, prijs, beschikbaarheid, locatie en datums.
In de praktijk betekent dit dat je content niet verandert, maar dat je er een laag betekenis aan toevoegt. Zoekmachines kunnen die laag gebruiken om rich results te tonen, zoals sterrenbeoordelingen bij een product, breadcrumbs in het resultaat, een FAQ-uitklapper of een event met datum en locatie. JSON-LD is doorgaans de eenvoudigste en door zoekmachines zoals Google aangeraden manier om dit te implementeren, al worden microdata en RDFa ook ondersteund.
Belangrijk is dat je markup klopt met wat er zichtbaar op je pagina staat en dat je alleen relevante eigenschappen invult; anders maak je je pagina minder betrouwbaar en verklein je de kans op weergave als rich result. Door consistent, actueel en correct te markeren, leg je een stevige basis voor betere vindbaarheid en een duidelijker presentatie van je content in de zoekresultaten.
In gewone taal uitgelegd
Schema markup is extra uitleg in je pagina die zoekmachines vertelt wat elk stukje inhoud betekent, zodat ze je resultaat duidelijker kunnen tonen. Je voegt het toe als een kleine portie code die bezoekers niet zien, maar die aangeeft: dit is een product met een prijs en voorraad, dit is een recept met bereidingstijd, dit is een evenement met datum en locatie.
Zie het als labels op dozen in een opslag: zonder label moet iemand raden, met label vindt alles sneller de juiste plek.
Het meest gebruikte jasje heet JSON-LD; dat plak je in de code van je pagina zonder je zichtbare tekst te veranderen. Belangrijk is dat je alleen informatie labelt die ook echt op de pagina staat en dat je velden correct invult. Doe je dat consequent, dan snappen zoekmachines je inhoud beter en maak je de kans op aantrekkelijke, informatieve zoekresultaten groter.
Belangrijke formaten en begrippen (JSON-LD, microdata, RDFA)
De onderstaande vergelijking zet de belangrijkste schema.org-formaten (JSON-LD, microdata en RDFa) naast elkaar op implementatie, sterke punten en aandachtspunten, zodat je snel het juiste format voor jouw schema markup kiest.
| Formaat | Implementatie | Sterke punten | Aandachtspunten |
|---|---|---|---|
| JSON-LD | Los scriptblok met type “application/ld+json” in head of body; entiteiten beschreven in JSON. | Door Google aangeraden waar mogelijk; los van HTML-structuur dus minder breekbaar; eenvoudig te genereren en te onderhouden. | Moet inhoudelijk overeenkomen met zichtbare content; bij meerdere entiteiten consistente @id en referenties nodig. |
| Microdata | Inline attributen op HTML-tags: itemscope, itemtype, itemprop. | Annotatie direct aan elementen; werkt zonder scripts; bruikbaar als je alleen HTML kunt aanpassen. | Maakt markup snel uitgebreid en minder leesbaar; foutgevoeliger bij layout-wijzigingen; minder flexibel voor hergebruik. |
| RDFa | Inline attributen zoals typeof, property, vocab (en eventueel about/prefix) voor semantische relaties. | Zeer expressief; geschikt voor linked data en meerdere vocabularies; nuttig voor semantisch rijke documenten. | Complexer om correct te modelleren; minder gangbaar voor SEO-richte implementaties; onderhoud intensiever in grote templates. |
Samengevat: voor SEO-implementaties is JSON-LD doorgaans het meest onderhoudsvriendelijk en door Google aangeraden, terwijl microdata en RDFa nuttig zijn wanneer je inline annotatie of RDF-flexibiliteit nodig hebt. Maak het concreet voor jouw situatie: wat is het doel, welke randvoorwaarden zijn hard, en wanneer is het “goed genoeg”?
Je beschrijft schema markup doorgaans met drie formaten: JSON-LD, microdata en RDFa. In de meeste situaties kies je JSON-LD, omdat het los staat van je HTML, makkelijker te onderhouden is en je het in één scriptblok kunt beheren. JSON-LD voeg je toe met een script type application/ld+json en gebruikt @context (meestal https://schema.org) en @type om aan te geven welk entiteitstype je beschrijft, gevolgd door eigenschappen zoals name, description of offers.
Microdata zet je juist ín je HTML met attributen als itemscope, itemtype en itemprop; dat werkt prima, maar kan je templates druk en foutgevoelig maken wanneer je veel velden hebt.
RDFa lijkt daarop, maar gebruikt attributen als typeof, property en vocab, en kan ook in XML werken; het is flexibel, maar vaak technischer. Ongeacht het formaat gebruik je het Schema.org-woordenboek met “types” (bijv. Product, Article) en “eigenschappen” (bijv. price, author) en kun je geneste entiteiten beschrijven wanneer een eigenschap zelf weer een object is.
Weet je niet waar te beginnen?
Bij Schema markup is het verschil tussen succes en vastlopen vaak de vraag: wat doe je eerst? Plan een 30-min gesprek en krijg 3 concrete prioriteiten.
Voordelen en toepassingen
- Bij een SaaS-platform in Nederland liep schema markup vast op één fout: alles tegelijk starten. Na 3 weken was nog onduidelijk welke aanpassingen iets deden voor aanvragen.
- Alles werd tegelijk aangepakt zonder te meten, waardoor focus wegviel en budget aan ruis opging.
- De aanpak werd teruggebracht naar één hypothese en één meetpunt. Er werd een nulmeting gedaan, daarna volgden twee meetmomenten met een vooraf gekozen stopmoment.
- De conversie steeg met 40 procent, waardoor het risico op bijsturen op aannames kleiner werd. Binnen 3 maanden waren er genoeg meetpunten om te zien wat schaalbaar was en waar bijsturen loonde. Als prioriteiten vaag blijven, herhaalt dezelfde discussie zich elke week zonder extra budget.
- Zonder focus voelt optimaliseren als vooruitgang, maar zonder meetpunt is het ruis.
Dit werkt minder goed als je weinig tijd of draagvlak hebt; begin dan kleiner en maak eerst de randvoorwaarden scherp. Als het risico hoog is (bijv. afhankelijkheden of compliance), dan loont het om extra controle en documentatie in te bouwen.
Begin met het kiezen van het juiste schema-type, valideer de JSON-LD, en monitor prestatieverschillen via Search Console en webanalyse.
Schema markup voegt context toe aan je content, waardoor zoekmachines beter begrijpen wat er op de pagina staat. Dat kan helpen bij duidelijkere snippets, meer relevant verkeer en minder verwarring rond namen of termen.
- Waarom het belangrijk is: het verduidelijkt entiteiten (zoals auteur, organisatie of locatie), helpt zoekmachines relaties te zien en vergroot de kans op rijke zoekresultaten. Gevolg is vaak een herkenbaardere weergave in de SERP en een betere aansluiting bij de zoekintentie.
- Welke rijke resultaten mogelijk zijn: sterren bij reviews, breadcrumbs, sitelinks, FAQ-uitklappers, how-to-stappen, productdetails (zoals prijs of voorraad) en evenementinformatie. Dit zijn voorbeelden die, afhankelijk van content en richtlijnen, kunnen verschijnen.
- Toepassingen per contenttype: artikelen/nieuws, recepten, how-to’s, producten en aanbiedingen, reviews, podcasts/afleveringen, vacatures, lokale bedrijven en evenementen. Goede markup kan ook het begrip in voice assistants en de Knowledge Graph ondersteunen.
Welke rich results daadwerkelijk verschijnen bepaalt de zoekmachine; volledige en correcte markup verhoogt doorgaans de kans. Begin met de typen die het best aansluiten op je doelpagina’s en breid daarna uit.
Waarom het belangrijk is
Het is belangrijk omdat schema markup je inhoud ondubbelzinnig maakt voor machines en daarmee je zichtbaarheid en relevantie in zoekresultaten versterkt. Door expliciet te labelen wat er op je pagina staat, word je beter gematcht met zoekintentie en kom je vaker in aanmerking voor rijke weergaven die de aandacht trekken.
Dit weegt extra mee als je veel vergelijkbare pagina’s hebt, als je merknaam op iets anders lijkt, of als je productdetails (zoals prijs en beschikbaarheid) snel veranderen. Goede markup vermindert ruis: zoekmachines hoeven minder te raden, wat misinterpretaties en verkeerde koppelingen verkleint.
Voor je doelgroep levert dat duidelijkere snippets op, meer vertrouwen en vaak hogere doorklik. Daarnaast helpt schema bij consistentie in je contentproductie: door te werken met vaste types en eigenschappen dwing je structuur af, wat onderhoud en schaalbaarheid vereenvoudigt. Tot slot maakt gestructureerde data het eenvoudiger om prestaties te meten en te verbeteren, omdat je kunt testen welke velden en pagina’s het meeste effect hebben op zichtbaarheid en interactie.
Toepassingen per type content
Je past schema markup per contenttype toe om precies te vertellen wat je publiceert en welke details daarbij horen. Zo maak je het voor zoekmachines eenvoudiger om je pagina’s te begrijpen en in aanmerking te laten komen voor relevante, rijke weergaven.
Voor artikelen kun je het type Article gebruiken met headline, auteur en publicatiedatum, terwijl je bij Product kiest voor prijs, valuta, beschikbaarheid en eventueel een aggregateRating als je daadwerkelijk reviews toont. Recepten vragen om kook- en bereidingstijd, ingrediënten en voedingswaarden, en bij evenementen leg je locatie, datum, tijd en organisator vast.
Vacatures profiteren van functiebenaming, locatie, salaris en geldigheidsdatum; lokale bedrijven van adres, openingstijden en contactopties; en how-to’s van stapsgewijze instructies met benodigde items en tijdsduur. Video’s en podcasts kun je verrijken met duur, thumbnail en publicatiedatum. Belangrijk is dat je alleen informatie markeert die zichtbaar is, dat je data actueel blijft en dat je per pagina één primair onderwerp duidelijk maakt, ook als je meerdere entiteiten nestelt.
Implementatie: van plan tot publicatie
Van plan tot publicatie werk je stapsgewijs: bepaal wat je wilt markeren, implementeer JSON-LD zonder de zichtbare content te wijzigen, en stuur bij op basis van test- en monitoringresultaten.
- Juiste types en eigenschappen kiezen: inventariseer pagina’s, entiteiten en zichtbare velden; kies per sjabloon één primair type; leg verplichte en aanbevolen properties vast en bepaal datakoppelingen vanuit je CMS of datalaag.
- Implementeren en testen (JSON-LD): genereer JSON-LD waar mogelijk dynamisch; valideer met een schema-validator; controleer dat waarden overeenkomen met wat op de pagina staat; plan releases met duidelijke QA-momenten.
- Monitoring en onderhoud: volg dekking en fouten, en let op veranderingen in vertoningen en klikken; update markup bij template- of contentwijzigingen; documenteer keuzes en houd eigenaarschap en processen actueel.
Met deze aanpak maak je schema markup schaalbaar en beheersbaar. Begin klein, leer van tests en rol daarna gecontroleerd verder uit.
Juiste types en eigenschappen kiezen
Je kiest de juiste schema-types door eerst te bepalen wat de hoofdentiteit van je pagina is en welke informatie je zichtbaar toont, daarna pak je het meest specifieke type dat daarbij past en vul je verplichte én relevante aanbevolen eigenschappen in. Als je pagina meerdere elementen bevat, kies je één primair type en nest je de rest, zodat de structuur logisch blijft.
Begin bij de intentie van de pagina en het template: is het een productdetail, een artikel, een event of een bedrijfsprofiel? Kies liever een subtype dan iets algemeens, en zorg dat de eigenschappen de zichtbare content exact weerspiegelen.
Voor producten betekent dat bijvoorbeeld prijs, valuta, beschikbaarheid en eventueel een beoordeling die echt op de pagina staat; voor artikelen zijn headline, auteur en publicatiedatum cruciaal; voor lokale bedrijven spelen naam, adres en openingstijden. Gebruik consistente identifiers zoals URL, merk of SKU, houd datums en tijden in het juiste formaat, en vermijd dubbele of conflicterende primaire types. Zo maximaliseer je relevantie én de kans op rijke weergaven.
Implementeren en testen (JSON-LD)
Je wilt schema markup verbeteren, maar het is nog onduidelijk welke stap het meeste effect geeft en waar je moet beginnen. Je start meestal zonder duidelijk kader. Drie weken later discussieer je nog over wat ‘goed’ is. Leg daarom vooraf vast welke uitkomst acceptabel is (tijd, budget, risico) en toets elke keuze daaraan.
Gebruik consistente identifiers met @id, houd datums in ISO 8601, prijzen met priceCurrency als ISO-valutacode en zorg dat URL’s canoniek zijn.
Test vervolgens elke variant van je templates met de Rich Results Test voor geschiktheid en met de Schema Markup Validator voor syntaxis en vocabulaire, en vergelijk de getoonde waarden met je pagina om afwijkingen te spotten. Check na livegang in Search Console de URL-inspectie en relevante rapporten, kijk naar dekking, fouten en waarschuwingen, en herhaal dit bij elke release.
Als je JSON-LD via JavaScript injecteert, controleer dan of de markup stabiel rendert en niet wordt overschreven door andere scripts.
Monitoring en onderhoud
Je borgt effect door schema markup continu te monitoren en bij te werken, zodat je data klopt met wat je toont en je in aanmerking blijft komen voor rijke weergaven. Richt je workflow op vroeg signaleren en snel herstellen: check na elke release of je JSON-LD nog overeenkomt met de pagina, volg in Search Console de rapporten voor rich results en URL-inspecties, en let op nieuwe fouten of waarschuwingen.
Houd dynamische velden zoals prijs, voorraad, datums en beschikbaarheid synchroon met je brondata en verwijder eigenschappen die je niet langer zichtbaar toont.
Zet validatie in je ontwikkel- en publicatieproces, bijvoorbeeld met een automatische check op syntaxis, verplichte eigenschappen en ID-consistentie, en test regelmatig een steekproef van templates handmatig om rendermissers of JavaScript-conflicten te vinden. Bewaak trends in vertoningen, klikken en doorklikratio’s per type rich result, koppel spikes aan codewijzigingen, en reageer op wijzigingen in richtlijnen of ondersteunde features door je types en eigenschappen tijdig aan te passen.
Kosten en keuze: zelf of uitbesteden
De kosten van schema markup hangen af van omvang, complexiteit en onderhoud, en je keuze draait meestal om zelf doen of uitbesteden aan een bureau. Je beslist op basis van tijd, expertise, schaal en risico; met een beperkt aantal templates en een vaardig dev- of contentteam is zelf doen vaak logisch, terwijl veel varianten, strakke deadlines of compliance-eisen uitbesteden aantrekkelijker maken.
Grote kostenposten zijn inventarisatie en modellering, het bouwen van dynamische JSON-LD in je CMS of datalaag, validatie en QA, release- en regressietesten, en doorlopend onderhoud bij prijswijzigingen, events of nieuwe contenttypes. Tel daar tooling en automatisering bij op als je validatie in je CI/CD wil opnemen. Houd ook rekening met herstelkosten als inconsistenties ontstaan tussen zichtbare content en markup.
Zelf doen geeft je maximale controle, directe kennisopbouw en doorgaans lagere externe kosten, maar vraagt projectdiscipline, duidelijke eigenaarschap en tijd om best practices te borgen. Uitbesteden levert tempo, gespecialiseerde ervaring en herbruikbare frameworks op, met als keerzijde budget en afhankelijkheid. Een hybride aanpak werkt vaak goed: laat een bureau architectuur, templates en validatieregels neerzetten, en beheer zelf de uitrol en het onderhoud.
Maak je keuze door doelen te concretiseren, scope en bronnen te inventariseren, en een pilot te draaien op een paar representatieve templates om impact, effort en foutreductie te meten. Reken op variatie in zichtbare resultaten, want rich results blijven aan richtlijnen en algoritmen gebonden; kies daarom de route die het beste past bij je schaal, snelheid en kwaliteitsambities.
Wat bepaalt de kosten en doorlooptijd
Kosten en doorlooptijd worden vooral bepaald door omvang, complexiteit en afhankelijkheden: hoeveel templates en pagina’s je hebt, hoe specifiek de schema-types zijn en hoeveel teams je nodig hebt om het live te krijgen. Als je data goed beschikbaar is in je CMS of datalaag en je één primair type per template kunt definiëren, gaat het sneller en is het goedkoper.
Wanneer je eerst datamapping moet uitzoeken, content moet aanpassen of ontbrekende velden moet toevoegen, lopen uren op. Ook de techniek telt mee: dynamische JSON-LD with server-side rendering of een stabiele tagmanager versnelt, terwijl client-side rendering met race conditions of legacy-templates vertraging geeft.
Validatie en QA (inclusief testomgevingen, releasevensters en approvals) verlengen de doorlooptijd, net als vertalingen, meerdere landen of migratie van microdata naar JSON-LD. Tot slot sturen governance en onderhoud de totale kosten: monitoring, foutafhandeling en periodieke updates vragen structurele tijd en budget, zeker als richtlijnen wijzigen.
Zelf doen vs uitbesteden
Je kiest voor zelf doen als je voldoende tijd, technische skills en een beheersbaar aantal templates hebt; je kiest voor uitbesteden als je snel wilt opschalen, complexe contentmodellen gebruikt of strengere kwaliteitseisen en deadlines hebt. Zelf doen geeft je maximale controle, directe kennisopbouw en doorgaans lagere externe kosten, maar vraagt discipline in modellering, documentatie, QA en onderhoud.
Je team moet JSON-LD kunnen genereren, valideren, releasen en monitoren zonder dat het productiewerk stokt. Uitbesteden levert tempo, ervaren ogen en herbruikbare patronen op, met minder risico op beginnersfouten, maar je betaalt voor die snelheid en je wordt afhankelijk van planning en beschikbaarheid van een partner.
Een hybride aanpak werkt vaak het beste: laat een specialist architectuur, templates en validatieregels neerzetten, en beheer zelf de implementatie per template en het doorlopende onderhoud. Maak je keuze op basis van schaal, complexiteit, releaseproces, compliance en interne bezetting, en toets dit met een korte pilot op representatieve pagina’s.
Wanneer werkt schema niet (goed)?
Schema werkt niet goed als je markup niet overeenkomt met wat zichtbaar op de pagina staat, onvolledig is of misleidend wordt ingezet; dan kom je zelden in aanmerking voor rijke weergaven. Het hapert ook wanneer je een type gebruikt dat niet wordt ondersteund voor rich results of wanneer je meerdere primaire types op één pagina probeert te forceren, waardoor de intentie onduidelijk wordt.
Fouten nemen toe bij inconsistenties tussen pagina, feed en JSON-LD, ontbrekende verplichte eigenschappen, of velden in het verkeerde formaat. Technisch kan het misgaan als je markup pas laat via JavaScript rendert, als crawlers worden geblokkeerd door noindex of robots.txt, of als je HTML/microdata kapot is.
Verder beperken richtlijnen wat mag: zelfverzonnen of niet-zichtbare reviews, irrelevante properties of spamachtige overmarkering verkleinen je kansen. Houd er rekening mee dat rich results nooit gegarandeerd zijn; wijzigingen in beleid en features, dunne of sterk duplicatieve content en gebrek aan actuele gegevens kunnen er bovendien voor zorgen dat je markup geen zichtbaar effect oplevert.
Dit gaat vaak fout
- Je kiest een te algemeen schema type (bijv. Article) en laat belangrijke eigenschappen weg die bij jouw content horen. Maak eerst een content-inventaris en koppel elk onderdeel aan het best passende schema type; noteer de belangrijke vereiste en aanbevolen eigenschappen en vul die volledig in, in lijn met de zichtbare tekst.
- Je mixt formaten: microdata in de HTML én JSON-LD in de head, waardoor dubbele of tegenstrijdige markup ontstaat. Kies één formaat (bij voorkeur JSON-LD) voor je markup, verwijder oude microdata/RDFa, en zorg dat één consistente bron alle belangrijke gegevens bevat.
- Je publiceert zonder te testen, waardoor begrippen of waarden niet overeenkomen met wat op de pagina staat en rich resultaten uitblijven. Test je schema vooraf met een structured-data testtool, controleer of alles klopt met de in gewone taal uitgelegd content op de pagina, en voeg ontbrekende eigenschappen toe voordat je live gaat.
Veelgestelde vragen over schema markup
Wanneer is uitbesteden of inhuren voor schema markup verstandig?
Uitbesteden is vaak zinvol bij complexe sites met meerdere contenttypes (producten, events, vacatures), beperkte interne kennis van JSON-LD, behoefte aan schaalbare implementatie en monitoring, of wanneer je migratie van microdata/RDFA naar JSON-LD plant. Een specialist versnelt type- en property-keuze, validatie en publicatie.
Welke factoren bepalen prijs, kwaliteit en bureaukeuze bij schema markup?
Prijs en kwaliteit worden bepaald door omvang en variatie van content, aantal benodigde types en eigenschappen, mate van maatwerk, gebruikte tooling voor crawling en testen, documentatie-eisen, integratie met CMS of datafeeds, ervaring met vergelijkbare content, en afspraken over onderhoud, rapportage en doorlooptijd.
Welk risico ontstaat bij een verkeerde selectie of verwachting rond schema markup?
Verkeerde selectie of verwachting kan leiden tot ongeschikte types, ontbrekende properties en validatiefouten, waardoor rich results uitblijven. Te veel mark-up kan inconsistenties geven na CMS-wijzigingen. Verwachting van directe SEO-rankings kan teleurstellen; structured data ondersteunt zichtbaarheid, maar vereist testen, monitoring en iteratie voor duurzame opbrengst.
Wil je hier geen tijd aan verspillen?
Bespreek jouw situatie rond Schema markup, krijg een lijst met 3 prioriteiten en een realistische inschatting van wat er nodig is.
Over de auteur
