Ontdek hoe NLP Google en AI-zoeken stuurt: entiteiten, saillantie, embeddings, een pagina-audit in 6 stappen met code, schrijfregels en valkuilen.

Op deze pagina
Kort gezegd
NLP SEO betekent dat je pagina's zo schrijft en structureert dat de taalmodellen van Google en AI-assistenten precies begrijpen waar je pagina over gaat: welke entiteiten ze behandelt, welke vraag elke passage beantwoordt en hoe ze samenhangt met de rest van je site. In de praktijk haal je je tekst door dezelfde soort tools (entiteitsextractie, classificatie, embeddings), corrigeer je wat de machine verkeerd leest en herschrijf je zinnen zodat het hoofdonderwerp, de kenmerken en de antwoorden expliciet zijn. Het is geen nieuwe truc om te ranken: het is een manier om ambiguïteit weg te nemen, en juist die ambiguïteit kost je posities en AI-citaties.
Wil je verder gaan? Vraag het aan
Korte quiz
Is SEO iets voor jou, en hoe begin je?
Sorank past bij je antwoorden
Test het 3 dagen op je eigen website en zie waar je staat in Google, ChatGPT en de andere AI's.
3 dagen gratis testen3 dagen gratis, daarna stop je wanneer je wilt. 90 dagen geld-terug-garantie, onder voorwaarden.
Natural language processing (NLP, natuurlijke taalverwerking) is de tak van AI die menselijke tekst omzet in gegevens waarmee een machine kan redeneren: woorden, zinnen, entiteiten, relaties en betekenis. Wil je eerst de algemene definitie, lees dan onze woordenlijst over natural language processing. Voor SEO is de definitie die ertoe doet smaller: NLP is de manier waarop een zoekmachine bepaalt wat je pagina betekent, voordat ze bepaalt waar die rankt.
NLP SEO heeft dus drie lagen. Je hebt ze alle drie nodig voor resultaat.
Wat NLP SEO niet is: het is geen lijst met „NLP-zoekwoorden” in een pagina proppen, en het is niet de score van een contenttool najagen. Google zegt het duidelijk in zijn gids over het maken van nuttige, betrouwbare content waarbij mensen voorop staan: als je naar een aantal woorden toe schrijft omdat je hebt gehoord dat Google er een voorkeur voor heeft, is het antwoord „Nee”. Dezelfde logica geldt voor termenlijsten. Het doel is begrepen worden, niet geoptimaliseerd lijken.
Waarom taalbegrip SEO heeft veranderd
Bronnen: Google, Pandu Nayak, „Understanding searches better than ever before” (2019) en „MUM: A new AI milestone for understanding information” (2021)
Toen Google BERT introduceerde, legde Pandu Nayak (Google Fellow en Vice President, Search) in de officiële aankondiging van 25 oktober 2019 uit dat het model Search zou helpen om een op de 10 Engelstalige zoekopdrachten in de VS beter te begrijpen. Zijn voorbeeld was de zoekopdracht „2019 brazil traveler to usa need a visa”: vóór BERT werd het woord „to” grotendeels genegeerd en toonde Google resultaten over Amerikanen die naar Brazilië reizen. Na BERT werd de reisrichting begrepen. Dat ene voorzetsel vat NLP SEO samen: kleine woorden dragen betekenis, en modellen lezen ze nu. Onze woordenlijstpagina over het BERT-algoritme gaat dieper in op het model zelf.
Twee jaar later presenteerde Google MUM in een artikel van 18 mei 2021, en beschreef het als 1000 keer krachtiger dan BERT en getraind in 75 talen. De voorbeeldvraag kwam van een wandelaar die de Mount Adams heeft beklommen en zich het volgende najaar wil voorbereiden op de Fuji: een vraag waarvoor je twee entiteiten moet vergelijken en moet afleiden wat „voorbereiden” betekent. Vandaag werken AI Overviews, ChatGPT, Perplexity en Gemini allemaal volgens hetzelfde principe: ze lezen passages, herkennen entiteiten en stellen antwoorden samen. Je pagina is de grondstof voor dat proces.
Je hoeft de wiskunde niet te kennen. Je moet de stappen kennen, want elke stap is een plek waar je pagina verkeerd gelezen kan worden. Dit is de pipeline in de volgorde waarin een typisch systeem hem uitvoert.
De 7 stappen waarmee een machine je pagina leest
De tabel hieronder koppelt elke NLP-taak aan het concrete risico op een pagina en de correctie die jij in de hand hebt.
| NLP-taak | Wat de machine doet | Typisch probleem op een pagina | Wat jij verandert |
|---|---|---|---|
| Boilerplate verwijderen | Scheidt hoofdcontent van template | De intro zit begraven onder 600 woorden menu's en widgets | Het antwoord in de eerste alinea van de hoofdcontent zetten, in eenvoudige HTML |
| Zinssegmentatie | Knipt tekst in zinnen | Opsommingsfragmenten zonder werkwoord, zinnen van 60 woorden | Eén idee per zin, volledige zinnen in lijsten die feiten bevatten |
| Dependency parsing | Vindt onderwerp, werkwoord, lijdend voorwerp | Het onderwerp is „het” of „dit”, drie zinnen van het zelfstandig naamwoord verwijderd | Het zelfstandig naamwoord herhalen, onderwerp en werkwoord dicht bij elkaar houden |
| Named entity recognition | Herkent en typeert namen | Je product wordt op vijf verschillende manieren geschreven | Eén canonieke naam kiezen, varianten pas gebruiken nadat ze zijn geïntroduceerd |
| Entity linking | Koppelt namen aan bekende concepten | Dubbelzinnige merknaam zonder context | De categorie naast de naam zetten („Sorank, de SEO-software...”) en schema met sameAs |
| Embeddings | Vergelijkt de betekenis van zoekopdracht en passage | De passage die zou moeten antwoorden is generiek en past op elke pagina | Passages schrijven die de termen van de vraag herhalen en een concreet antwoord geven |
| Classificatie | Kent onderwerpen en intentie toe | Een productpagina vol uitweidingen in blogstijl | Eén dominante intentie per URL, andere intenties naar andere pagina's verplaatsen |
Opmerking
Niemand buiten Google kent de exacte modellen die in de ranking worden gebruikt. De tools in deze gids zijn benaderingen: ze lezen tekst zoals moderne taalmodellen dat doen, niet zoals het rankingsysteem van Google dat doet. Gebruik ze om ambiguïteit te vinden, niet om posities te voorspellen.

Vijf signalen zijn te meten met gratis of goedkope tools. Elk vertelt je iets anders, en geen van alle is op zichzelf een rankingfactor.
Een entiteit is een benoemd „ding”: een merk, een product, een persoon, een plaats, een concept zoals „keyword-kannibalisatie”. De Cloud Natural Language API van Google geeft voor elke entiteit een type, haar vermeldingen en, in versie 1 van de API, een saillantiescore. De Entity-referentie van v1 beschrijft die als „the salience score associated with the entity in the [0, 1.0] range”, dus een saillantiescore tussen 0 en 1. De entiteitstypen zijn UNKNOWN, PERSON, LOCATION, ORGANIZATION, EVENT, WORK_OF_ART, CONSUMER_GOOD, OTHER, PHONE_NUMBER, ADDRESS, DATE, NUMBER en PRICE.
Saillantie is relatief ten opzichte van het document: de scores van alle entiteiten in een tekst concurreren met elkaar. De nuttige lezing is dus de volgorde, niet het getal. Als je pagina mikt op „NLP SEO” en de bovenste entiteit is „Google”, dan gaat de pagina voor een machine vooral over Google. De details staan in onze woordenlijst over entiteitssaillantie.
Let op: v1 of v2
Het Entity-object van v2 van de Natural Language API bevat alleen name, type, metadata, mentions en sentiment: er is geen veld salience. Als een tutorial saillantiescores toont, roept die v1 aan. Bouw je vandaag een script, roep dan voor saillantie expliciet het v1-endpoint aan en controleer de documentatie voordat je erop vertrouwt.

De methode classifyText geeft categorieën uit een vaste taxonomie terug (bijvoorbeeld een pad als /Internet & Telecom/Web Services). De documentatie van Google over de basis van Natural Language vermeldt dat classificatie een tekst van minstens twintig tokens nodig heeft. Het nut voor SEO: als een pagina die bedoeld is voor „SEO-software” in een algemene marketingcategorie belandt, is de woordenschat te algemeen.
Sentimentanalyse geeft een score van -1,0 (negatief) tot 1,0 (positief) en een magnitude die meet hoeveel emotie de tekst bevat. Op documentniveau begint de magnitude bij 0,0 en is ze niet genormaliseerd, dus een lange tekst met gemengde meningen kan een neutrale score en een hoge magnitude tonen. Voor SEO telt sentiment vooral op reviewpagina's, vergelijkingen en lijstjes met „beste X”, waar een vlakke tekst zonder mening slecht antwoordt op een vraag die om een mening vraagt.
Syntaxanalyse geeft voor elk token de woordsoort, het lemma en de afhankelijkheid. Twee controles zijn de moeite waard: hoe vaak je hoofdentiteit het grammaticale onderwerp van een zin is, en hoeveel zinnen met een voornaamwoord beginnen („Het”, „Dit”, „Ze”). Een pagina waarop de hoofdentiteit het onderwerp van veel zinnen is, praat erover in plaats van eromheen.
Embeddings zetten een passage om in een vector. Door de vector van een zoekopdracht te vergelijken met de vectoren van je passages (cosinusgelijkenis) zie je welke passage een retrievalsysteem voor die zoekopdracht zou kiezen. Dat is de openbare benadering die het dichtst ligt bij hoe AI-assistenten het fragment kiezen dat ze citeren. Het is ook de beste test voor de vraag of de pagina de vraag echt beantwoordt of hem alleen noemt.
„NLP SEO” omvat zes verschillende methoden. Leveranciers verkopen er meestal één alsof het het hele vakgebied is. Hier is elke methode, met wanneer je haar gebruikt en waar ze ophoudt te werken.
Principe: de entiteiten bepalen die een volledig antwoord moet bevatten (de hoofdentiteit, haar kenmerken, verwante entiteiten), controleren of je pagina ze duidelijk benoemt en of de hoofdentiteit domineert. Wanneer gebruiken: op pagina's over een product, een merk, een persoon, een plaats of een goed afgebakend concept. Sterke punten: sluit aan op hoe kennisgrafen en AI-antwoorden worden opgebouwd, en lost ambiguïteit bij de wortel op. Beperkingen: entiteitsextractie mist vakjargon en nieuwe concepten; saillantie is niet beschikbaar in v2 van de Google-API. Voorbeeld: een pagina over „Shopify SEO” waarop „WordPress” bij de bovenste entiteiten staat door een lange vergelijkende alinea: de alinea verhuist naar een eigen pagina en de Shopify-pagina krijgt meer focus. Onze gids over entity SEO behandelt de strategische kant.
Principe: de termen van de best rankende pagina's vergelijken met de jouwe, gewogen naar hoe specifiek ze zijn (TF-IDF), en de gaten vullen. Dat doen de meeste contentscoretools. Wanneer gebruiken: om vergeten subonderwerpen op een informatieve pagina te vinden. Sterke punten: snel, makkelijk uit te leggen aan een schrijver. Beperkingen: kopieert het gemiddelde van de SERP, beloont herhaling en zegt niets over of je de vraag beantwoordt. Een termenlijst is een checklist van subonderwerpen, geen quotum aan woorden. Voorbeeld: de toppagina's over „technische SEO-audit” noemen allemaal „crawlbudget” en „canonical”; die van jou niet: dat zijn twee ontbrekende secties, geen twee ontbrekende woorden.
Principe: zoekopdrachten en passages coderen als vectoren en meten hoe dicht ze bij elkaar liggen. Wanneer gebruiken: om te controleren dat elke doelvraag een passage heeft die haar duidelijk beantwoordt, om twee pagina's te vinden die om dezelfde betekenis concurreren, en om interne links op betekenis in kaart te brengen. Sterke punten: werkt zonder gedeelde woorden, dicht bij hoe retrieval voor AI-antwoorden werkt. Beperkingen: scores hangen af van het model; een hoge score betekent „on topic”, niet „juist” of „nuttig”. Voorbeeld: de passage die antwoordt op „hoe lang duurt SEO” scoort lager dan een ongerelateerde introductiealinea: de antwoordpassage is te vaag en wordt herschreven met de termijn vooraan.
Principe: de zoekopdracht classificeren (informatief, commercieel, transactioneel, navigerend) en het formaat dat Google beloont (gids, lijst, tool, productpagina), en daar vervolgens op aansluiten. Wanneer gebruiken: voordat je schrijft, en wanneer een goede pagina helemaal niet rankt. Sterke punten: lost de duurste fout op, het verkeerde formaat. Beperkingen: gemengde SERP's bestaan; intentie verschuift in de tijd. Zie onze woordenlijst over zoekintentie.
Principe: de vragen verzamelen die mensen stellen („Mensen vragen ook”, forums, AI-prompts, je supporttickets) en elke vraag een zelfstandige passage geven. Wanneer gebruiken: voor zichtbaarheid in AI en voor featured snippets. Sterke punten: levert direct citeerbare passages op. Beperkingen: kan een pagina versnipperen tot een FAQ zonder diepgang als je de vragen niet per subonderwerp groepeert.
Principe: zoekwoorden en pagina's op betekenis groeperen om te bepalen welke pagina wat behandelt, en ze daarna linken. Wanneer gebruiken: op siteniveau, vóór het produceren van content en wanneer pagina's elkaar kannibaliseren. Sterke punten: bouwt topical authority en een schone architectuur op. Beperkingen: clustering op SERP-overlap en clustering op embeddings leveren verschillende groepen op; je hebt een regel nodig om te beslissen. Onze gids over keyword clustering legt beide aanpakken uit, en de woordenlijst over de topical map laat zien hoe je clusters omzet in een plan.
| Methode | Niveau | Het beste voor | Grootste risico | Tools |
|---|---|---|---|---|
| Entiteitsoptimalisatie | Pagina | Product-, merk- en conceptpagina's | Saillantie als rankingfactor behandelen | Google Cloud Natural Language (v1), spaCy |
| Termdekking (TF-IDF) | Pagina | Ontbrekende subonderwerpen vinden | Het SERP-gemiddelde schrijven, keyword stuffing | Contentscoretools, Python scikit-learn |
| Gelijkenis van embeddings | Passage en site | Kwaliteit van antwoorden, kannibalisatie, interne links | „On topic” verwarren met „goed” | Sentence Transformers, vectordatabases |
| Intentieclassificatie | Zoekopdracht en pagina | Het juiste formaat kiezen | Gemengde SERP's negeren | Handmatige SERP-analyse, classifiers |
| Vragen ontginnen | Passage | AI-citaties, snippets | Oppervlakkige FAQ-pagina's | „Mensen vragen ook”, promptonderzoek |
| Topic clustering | Site | Architectuur, topical authority | Inconsistente clusterregels | Clustertools, embeddings |
Optimaliseren met een termenlijst of met entiteiten en passages
Dit is de methode die we aanraden om te beginnen: één belangrijke pagina, één middag. Je hebt de paginatekst nodig, drie tot vijf concurrerende pagina's en de gratis online tools of een paar regels Python.
De NLP-audit van een pagina in 6 stappen
spaCy is een gratis open-source Python-bibliotheek. Het kleine Engelse model draait in een paar seconden op een laptop (gebruik voor Nederlandse tekst het model nl_core_news_sm). Het script hieronder toont de meest voorkomende entiteiten en de meest voorkomende grammaticale onderwerpen van je pagina: de tweede lijst zegt vaak meer dan de eerste.
import spacy
from collections import Counter
nlp = spacy.load("en_core_web_sm") # pip install spacy, daarna: python -m spacy download en_core_web_sm
text = open("page.txt", encoding="utf-8").read()
doc = nlp(text)
entities = Counter((e.text.lower(), e.label_) for e in doc.ents)
for (name, label), n in entities.most_common(20):
print(f"{n:>3} {label:<12} {name}")
# Wie is het onderwerp van je zinnen?
subjects = Counter(t.lemma_.lower() for t in doc if t.dep_ in ("nsubj", "nsubjpass"))
print(subjects.most_common(15))
# Hoeveel zinnen beginnen met een vaag voornaamwoord?
vague = [s.text for s in doc.sents if s[0].lower_ in ("it", "this", "that", "they")]
print(len(vague), "sentences start with a pronoun")
Lees de lijst met onderwerpen aandachtig. Als op de pagina van een softwareproduct „je” en „het” domineren en de productnaam nooit als onderwerp verschijnt, beschrijft de pagina handelingen zonder te zeggen wie ze uitvoert. Dat los je in een uur op.

De algemene modellen van spaCy berekenen geen saillantie. Daarvoor roep je het v1-endpoint analyzeEntities van Google Cloud Natural Language aan. Maak een project aan, activeer de API, log in met de gcloud-opdrachtregel en stuur je tekst. Sla deze request body op als request.json:
{
"document": {
"type": "PLAIN_TEXT",
"language": "nl",
"content": "Plak hier de opgeschoonde hoofdtekst van je pagina."
},
"encodingType": "UTF8"
}
Roep daarna het endpoint aan:
curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
"https://language.googleapis.com/v1/documents:analyzeEntities"
Het antwoord toont de entiteiten met hun type, hun salience, hun mentions en, als de entiteit gekoppeld is, een metadata-object dat een wikipedia_url en een mid (een Knowledge Graph-ID) kan bevatten. Een entiteit met een Wikipedia-URL in de metadata is gekoppeld aan een bekend concept; een belangrijke entiteit zonder URL kan dubbelzinnig of te nieuw zijn. Vervang analyzeEntities door classifyText om de contentcategorieën te krijgen. Controleer de actuele prijzen en quota van Google Cloud voordat je dit op honderden pagina's loslaat.
De bibliotheek Sentence Transformers vergelijkt de betekenis van een vraag met elke passage van je pagina. Het model all-MiniLM-L6-v2 is klein en voldoende voor deze controle op Engelse tekst; voor Nederlandse tekst werkt een meertalig model als paraphrase-multilingual-MiniLM-L12-v2 beter.
from sentence_transformers import SentenceTransformer, util
model = SentenceTransformer("all-MiniLM-L6-v2")
text = open("page.txt", encoding="utf-8").read()
passages = [p.strip() for p in text.split("\n\n") if len(p.split()) > 25]
questions = [
"what is nlp seo",
"how do I find the entities of my page",
"is entity salience a ranking factor",
]
p_vecs = model.encode(passages, convert_to_tensor=True)
for q in questions:
scores = util.cos_sim(model.encode(q, convert_to_tensor=True), p_vecs)[0]
best = int(scores.argmax())
print(f"{q}\n best score {scores[best]:.2f}: {passages[best][:100]}\n")
Twee uitkomsten vragen om actie. Als de beste passage voor een vraag niet de passage is die je schreef om haar te beantwoorden, is je antwoordpassage te generiek. Als de beste score van een vraag ver onder die van de andere ligt, beantwoordt de pagina haar niet echt. Vergelijk scores tussen vragen op dezelfde pagina, niet met een absolute drempel: de waarden hangen af van het model.

Tip
Geen Python? Onze gratis LLM Readability Checker beoordeelt een pagina op extractie door AI, en de Heading Structure Analyzer laat zien of je H2's en H3's de vragen aankondigen die je passages beantwoorden.
De meeste NLP-problemen los je op bij het schrijven, niet in een tool. Deze regels volgen direct uit de pipeline hierboven: elke regel haalt een stap weg waar een machine zich kan vergissen.
Gebruik de volledige naam van de hoofdentiteit als onderwerp van de eerste zin van elke sectie. Begin een alinea niet met „Het” of „Dit”. Voornaamwoorden zijn prima binnen een alinea, zodra het zelfstandig naamwoord dichtbij staat.
Een definitie die de categorie (Y) en het onderscheidende kenmerk (Z) noemt, is de structuur die een model het makkelijkst extraheert en een AI-assistent het makkelijkst citeert. „Entiteitssaillantie is een score van 0 tot 1 die meet hoe centraal een entiteit in een tekst staat” werkt beter dan drie zinnen context.
Prijzen, datums, afmetingen, compatibiliteit en beperkingen horen naast de entiteit die ze beschrijven. „Sorank volgt de zichtbaarheid in ChatGPT, Gemini, Claude en Perplexity” is een extraheerbaar feit. Dezelfde informatie verdeeld over een kop, een opsommingsteken en een voetnoot geeft drie fragmenten.
Kies één naam voor elk product, elke functie en elk concept. Introduceer een synoniem één keer („query fan-out, de manier waarop AI-assistenten een vraag opsplitsen in meerdere zoekopdrachten”) en houd daarna één vorm aan.
Onder een kop die een vraag stelt, geeft de eerste zin het antwoord. De rest van de passage geeft de voorwaarden, het voorbeeld en de uitzonderingen. Dat maakt een passage zelfstandig.
Eén alinea, voor en na een NLP-herschrijving
De „na”-zin illustreert de structuur en beschrijft geen echt product: pas de kenmerken aan wat je pagina werkelijk biedt.
Python-NLP voor semantische SEO betekent dat je hetzelfde soort embeddingmodel gebruikt als bij de passagetest hierboven, maar dan op hele lijsten: je zoekwoorden en de pagina's van je site. Twee korte scripts beantwoorden vragen die een controle per pagina niet kan beantwoorden. Welke zoekwoorden horen op dezelfde pagina? Welke pagina's van je site concurreren om dezelfde betekenis? Beide draaien gratis op je eigen computer en leveren kandidaten op die je beoordeelt, geen oordelen.
Installeer de bibliotheken in een virtuele omgeving, zodat ze niet botsen met andere Python-projecten:
python3 -m venv nlp-seo
source nlp-seo/bin/activate
pip install sentence-transformers scikit-learn
De eerste keer downloadt het model all-MiniLM-L6-v2 eenmalig. Daarna werken beide scripts offline.
Clustering maakt van een platte zoekwoordenlijst groepen die één pagina zou kunnen beantwoorden. Elk zoekwoord wordt een vector, en zoekwoorden waarvan de vectoren dicht bij elkaar liggen in cosinusafstand komen in dezelfde groep terecht. Bewaar je zoekwoorden in een tekstbestand, één per regel, en draai dit script:
from sentence_transformers import SentenceTransformer
from sklearn.cluster import AgglomerativeClustering
from collections import defaultdict
keywords = [line.strip() for line in open("keywords.txt", encoding="utf-8") if line.strip()]
model = SentenceTransformer("all-MiniLM-L6-v2")
vectors = model.encode(keywords, normalize_embeddings=True)
labels = AgglomerativeClustering(
n_clusters=None,
distance_threshold=0.35, # cosinusafstand: lagere waarden geven strengere groepen
metric="cosine",
linkage="average",
).fit_predict(vectors)
groups = defaultdict(list)
for label, keyword in zip(labels, keywords):
groups[label].append(keyword)
for label, members in sorted(groups.items(), key=lambda g: -len(g[1])):
print(f"Group {label} ({len(members)} keywords)")
for keyword in members:
print(" ", keyword)
De drempel is de instelling die ertoe doet. Begin bij 0,35 en lees de uitvoer. Als niet-verwante zoekwoorden in dezelfde groep zitten, verlaag je hem. Als het onderwerp van één pagina over meerdere groepen verdeeld is, verhoog je hem. Average linkage vermindert chaining, het effect waarbij een keten van losjes verwante zoekwoorden twee niet-verwante groepen aan elkaar koppelt.
Het tweede script vergelijkt je pagina's met elkaar. Zet één rij per pagina in een tab-gescheiden bestand met een kopregel, met de kolommen url en title. Titels zijn maar een grove maatstaf. Plak voor een scherpere test de eerste alinea van elke pagina in de kolom title.
import csv
from sentence_transformers import SentenceTransformer, util
with open("pages.tsv", encoding="utf-8") as f:
rows = [(r["url"], r["title"]) for r in csv.DictReader(f, delimiter="\t")]
model = SentenceTransformer("all-MiniLM-L6-v2")
vectors = model.encode([title for _, title in rows], convert_to_tensor=True)
sims = util.cos_sim(vectors, vectors)
for i in range(len(rows)):
for j in range(i + 1, len(rows)):
score = float(sims[i][j])
if score > 0.8: # startpunt: pas aan na het lezen van de resultaten
print(f"{score:.2f} {rows[i][0]} vs {rows[j][0]}")
Elk getoond paar is een kandidaat, geen oordeel. Open beide URL's en vraag je af of een lezer zou verwachten dat een van de twee pagina's de vraag van de andere beantwoordt. Zo ja, voeg de twee pagina's samen, of houd er één aan als hoofdpagina en verscherp de focus van de andere. Het artikel over zoekwoordkannibalisatie legt uit hoe je kiest.
| Script | Invoer | Uitvoer | Wat je beslist |
|---|---|---|---|
| Zoekwoordgroepen | Eén zoekwoord per regel | Groepen zoekwoorden die een betekenis delen | Of elke groep één pagina nodig heeft of meerdere |
| Concurrerende pagina's | URL en titel, of eerste alinea, per pagina | Paren pagina's boven je drempel | Of je samenvoegt, opnieuw focust of beide pagina's behoudt |
Drie beperkingen zijn belangrijk:
Deze scripts zijn de sitebrede tegenhanger van de passagetest hierboven: het ene laat zien wat bij elkaar hoort, het andere waar je pagina's overlappen. Wil je de scripts liever niet zelf onderhouden, dan doet de Topic Cluster Generator van Sorank de groeperingsstap met een ingebouwde controle op kannibalisatie.
Taalmodellen lezen meer dan je alinea's. Drie elementen rond de tekst geven sterke signalen.
Schema.org-markup laat een pagina niet vanzelf ranken, maar zegt in een machineleesbaar formaat waar de pagina over gaat en naar welke bekende concepten ze verwijst. De eigenschappen about en mentions, met sameAs-links naar referentiepagina's, nemen ambiguïteit weg bij entity linking.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "NLP SEO: hoe Google en AI je content lezen",
"about": {
"@type": "Thing",
"name": "Natural language processing",
"sameAs": "https://en.wikipedia.org/wiki/Natural_language_processing"
},
"mentions": [
{
"@type": "Thing",
"name": "Zoekmachineoptimalisatie",
"sameAs": "https://nl.wikipedia.org/wiki/Zoekmachineoptimalisatie"
}
]
}
</script>
Maak en test je eigen markup met onze gratis Schema Markup Generator en Structured Data Validator.
Koppen zijn het eerste wat een model gebruikt om je pagina in passages op te delen. Een kop die de entiteit en de vraag noemt („Hoe entiteitssaillantie wordt berekend”) levert een schoner fragment op dan een slimme kop („Onder de motorkap”). Houd de H2- en H3-hiërarchie strikt: geen H3 zonder bovenliggende H2, geen overgeslagen niveaus.
Ankertekst is een van de oudste NLP-signalen in zoekmachines: hij vertelt de zoekmachine van buitenaf waar de doelpagina over gaat. Gebruik beschrijvende ankers die de doelentiteit noemen, link pagina's die qua betekenis dicht bij elkaar liggen en voorkom dat hetzelfde anker naar twee verschillende pagina's gaat. Een semantische cocon is de meest gestructureerde manier om dit te organiseren, en onze gids over geautomatiseerde interne links legt uit hoe je dit opschaalt zonder ruis te maken.
AI-assistenten trekken de NLP-logica door tot het uiterste. Ze ranken geen hele pagina's: ze halen passages op, vergelijken ze op betekenis met deelvragen en stellen een antwoord samen dat soms de bron citeert. Daar volgen drie dingen uit.
Voor de volledige methode toegepast op AI-antwoorden, zie onze gids over contentoptimalisatie voor LLM's.
Dit zijn de fouten die we het vaakst zien op geauditeerde sites. Elke fout heeft een herkenbaar symptoom en een oplossing die je vandaag kunt toepassen.
Wat het is: herschrijven tot de API je zoekwoord een hoge saillantie geeft, of tot een tool een groene score toont. Hoe je het herkent: de pagina leest slechter na optimalisatie; dezelfde formulering staat in elke alinea. Hoe je het oplost: gebruik saillantie alleen om de volgorde van entiteiten te controleren en beoordeel de pagina daarna op antwoorden en Search Console-data. Google heeft nooit gezegd dat het de scores van deze API in de ranking gebruikt.
Wat het is: „crawlbudget” in een zin stoppen omdat vijf concurrenten het noemen. Hoe je het herkent: termen verschijnen één keer, buiten context, zonder uitleg. Hoe je het oplost: elke ontbrekende entiteit wordt een vraag: heeft mijn lezer dit nodig? Zo ja, schrijf een passage; zo nee, negeer haar.
Wat het is: de hele pagina, inclusief menu en footer, in een NLP-tool plakken. Hoe je het herkent: je bovenste entiteiten zijn je merknaam, „cookies”, „contact” of footercategorieën. Hoe je het oplost: haal vóór elke analyse alleen de artikeltekst eruit.
Wat het is: een oude tutorial volgen met het huidige endpoint. Hoe je het herkent: het JSON-antwoord bevat entiteiten en vermeldingen, maar geen saillantie. Hoe je het oplost: roep voor saillantie /v1/documents:analyzeEntities aan, en houd er rekening mee dat v1 kan veranderen.
Wat het is: alinea's waarin „het”, „dit” en „ze” verwijzen naar zelfstandige naamwoorden een paar zinnen terug. Hoe je het herkent: het spaCy-script hierboven telt de zinnen die met een voornaamwoord beginnen; meer dan één op de vijf op een belangrijke pagina is een waarschuwingssignaal. Hoe je het oplost: herhaal het zelfstandig naamwoord aan het begin van elke alinea en na elke kop.
Wat het is: één URL die een concept wil definiëren, tools wil vergelijken en een product wil verkopen. Hoe je het herkent: de pagina rankt op veel zoekopdrachten op posities 15 tot 40 en op geen enkele in de top 5. Hoe je het oplost: houd de dominante intentie, verplaats de andere naar eigen pagina's en link ze.
Wat het is: een pagina opvullen om een doelaantal woorden of een zoekwoorddichtheid te halen. Hoe je het herkent: herhaalde inleidingen, generieke alinea's die op elke pagina zouden passen. Hoe je het oplost: schrap elke passage die geen vraag beantwoordt die een lezer zou stellen. Onze zoekwoorddichtheid-calculator is andersom nuttig: om te vinden waar je jezelf te vaak herhaalt.
Wat het is: een merk- of productnaam gebruiken die een machine niet kan onderscheiden van een gewoon woord of van een ander bedrijf. Hoe je het herkent: de API geeft je merk terug als OTHER of CONSUMER_GOOD zonder metadata, of koppelt het aan het verkeerde concept. Hoe je het oplost: zet de categorie naast de naam, gebruik Organization- of Product-schema met sameAs naar je officiële profielen en houd de naam overal identiek.
NLP SEO-checklist voor één pagina
Je hebt geen grote gereedschapskist nodig. Kies tools op basis van de vraag die je moet beantwoorden.
| Tool | Type | Wat het je vertelt | Benodigde kennis | Beste gebruik |
|---|---|---|---|---|
| Google Cloud Natural Language | Cloud-API (zie de prijzen van Google Cloud) | Entiteiten, saillantie (v1), categorieën, sentiment, syntaxis | Gemiddeld: een Google Cloud-project en een paar commando's | Controleren hoe een Google-model je belangrijkste pagina's leest |
| spaCy | Open-source Python-bibliotheek | Entiteiten, zinsstructuur, onderwerpen, lemma's | Basiskennis Python | Veel pagina's lokaal en kosteloos auditen |
| Sentence Transformers | Open-source Python-bibliotheek | Betekenisgelijkenis tussen zoekopdrachten en passages | Basiskennis Python | Antwoordcontrole, kannibalisatie, interne links in kaart brengen |
| Google Search Console | Gratis Google-tool | De zoekopdrachten waarop elke URL echt verschijnt | Geen | Het effect van een herschrijving meten |
| Contentoptimalisatietools | SaaS | Gaten in termen en entiteiten tegenover de toppagina's | Geen | Snelle check van subonderwerpen vóór het schrijven |
| Sorank | SEO- en GEO-software op autopilot | Herschrijvingen, topic clusters, monitoring van AI-zichtbaarheid | Geen | De methode op een hele site toepassen |
Voor een vergelijking van de commerciële opties lees je ons overzicht van de beste tools voor contentoptimalisatie. Heb je tientallen oudere pagina's te verbeteren, dan auditeert en herschrijft de functie Contentoptimalisatie van Sorank bestaande pagina's op autopilot, en de Topic Cluster Generator groepeert je zoekwoorden op betekenis voordat je schrijft, met een ingebouwde controle op kannibalisatie.
NLP-wijzigingen gaan over begrip, dus meet eerst begrip en daarna verkeer.
Filter in Google Search Console het Prestatierapport op de herschreven URL en tel de unieke zoekopdrachten met vertoningen over 28 dagen, voor en na. Een beter begrepen pagina verschijnt meestal binnen een paar weken op meer longtailvarianten, vaak voordat de klikken bewegen.
Volg de 5 tot 10 vragen die je in de passagetest gebruikte. Stijgen de vertoningen maar de positie niet, dan wordt de pagina begrepen maar niet verkozen: werk aan diepgang, voorbeelden en links.
Stel voor en na dezelfde prompts in ChatGPT, Gemini, Claude en Perplexity en noteer of je pagina geciteerd wordt. Herhaal dit maandelijks: AI-antwoorden verschillen van keer tot keer, dus één test bewijst niets. Voor een gestructureerde versie van deze controle voer je een semantische SEO-audit uit op het hele cluster in plaats van op één pagina.
Kies de pagina die je de meeste omzet oplevert en voer de audit in zes stappen uit. Los de eerste twee problemen op die je vindt, meestal een hoofdentiteit die niet domineert en een antwoordpassage die te vaag is. Noteer daarna de datum en controleer de zoekopdrachten van die pagina over vier weken in Search Console.
NLP in SEO betekent dat je content makkelijk te begrijpen maakt voor taalmodellen: welke entiteiten een pagina behandelt, welke vragen elke passage beantwoordt en hoe de pagina samenhangt met de rest van de site. Google gebruikt sinds 2019 taalmodellen zoals BERT in Search, en AI-assistenten zijn er volledig op gebouwd, dus helder en ondubbelzinnig schrijven is in de praktijk een factor geworden voor ranking en citaties.
Geen enkele openbare uitspraak van Google zegt dat de saillantiescore van de Cloud Natural Language API in de ranking wordt gebruikt. De score is een nuttige benadering om te controleren of je hoofdonderwerp de pagina domineert, maar kijk naar de volgorde van de entiteiten in plaats van een getal na te jagen. Let op: saillantie wordt alleen door versie 1 van de API teruggegeven.
spaCy en Sentence Transformers zijn gratis open-source Python-bibliotheken voor entiteitsextractie en gelijkenis tussen passages. Google Search Console, ook gratis, laat daarna zien of een herschreven pagina op meer zoekopdrachten verschijnt. Google Cloud Natural Language voegt saillantie en categorieën toe, met gebruik dat wordt gefactureerd volgens de prijzen van Google Cloud.
