Learn how NLP shapes Google and AI search: entities, salience, embeddings, a 6-step page audit with code, writing rules and the mistakes to avoid.

On this page
In short
NLP SEO means writing and structuring pages so that the language models used by Google and AI assistants understand exactly what your page is about: which entities it covers, which question each passage answers and how it relates to the rest of your site. In practice, you run your text through the same kinds of tools (entity extraction, classification, embeddings), fix what the machine misreads, and rewrite sentences so the main subject, its attributes and its answers are explicit. It is not a new trick to rank: it is a way to remove ambiguity, and ambiguity is what costs you rankings and AI citations.
Want to go further? Ask
Quick quiz
Is SEO right for you, and how should you start?
Sorank matches your answers
Test it for 3 days on your own site and see where you stand on Google, ChatGPT and the other AIs.
Start 3-day free trial3 days free, then stop whenever you want. 90-day results guarantee, conditions apply.
Natural language processing (NLP) is the branch of AI that turns human text into data a machine can reason with: words, sentences, entities, relations and meaning. If you want the general definition first, read our glossary entry on natural language processing. For SEO, the definition that matters is narrower: NLP is how a search engine decides what your page means before it decides where to rank it.
NLP SEO therefore has three layers. You need all three to get results.
What NLP SEO is not: it is not stuffing a list of "NLP keywords" into a page, and it is not chasing a score from a content tool. Google says it plainly in its guide to creating helpful, reliable, people-first content: if you write to a word count because you heard Google has a preferred one, the answer is "No, we don't." The same logic applies to term lists. The goal is to be understood, not to look optimized.
Why language understanding changed SEO
Sources: Google, Pandu Nayak, "Understanding searches better than ever before" (2019) and "MUM: A new AI milestone for understanding information" (2021)
When Google introduced BERT, Pandu Nayak (Google Fellow and Vice President, Search) explained in the official announcement of October 25, 2019 that the model would help Search better understand one in 10 searches in the U.S. in English. His example was the query "2019 brazil traveler to usa need a visa": before BERT, the word "to" was largely ignored and Google returned results about U.S. citizens travelling to Brazil. After BERT, the direction of travel was understood. That one preposition is NLP SEO in a nutshell: small words carry meaning, and models now read them. Our glossary page on the BERT algorithm goes deeper into the model itself.
Two years later, Google presented MUM in a post dated May 18, 2021, describing it as 1000 times more powerful than BERT and trained across 75 languages. The example query was a hiker who has climbed Mt. Adams and wants to prepare for Mt. Fuji next fall: a question that requires comparing two entities and inferring what "prepare" means. Today, AI Overviews, ChatGPT, Perplexity and Gemini all work on the same principle: they read passages, resolve entities and assemble answers. Your page is raw material for that process.
You do not need to know the maths. You need to know the steps, because each step is a place where your page can be misread. Here is the pipeline in the order a typical system runs it.
The 7 steps a machine goes through to read your page
The table below maps each NLP task to the concrete risk on a page and the fix you control.
| NLP task | What the machine does | Typical problem on a page | What you change |
|---|---|---|---|
| Boilerplate removal | Separates main content from template | The intro is buried after 600 words of menus and widgets | Put the answer in the first paragraph of the main content, in plain HTML |
| Sentence splitting | Cuts text into sentences | Bullet fragments with no verb, 60-word sentences | One idea per sentence, full sentences in lists that carry facts |
| Dependency parsing | Finds subject, verb, object | The subject is "it" or "this" three sentences away from its noun | Repeat the noun, keep subject and verb close |
| Named entity recognition | Detects and types names | Your product is written five different ways | Pick one canonical name, use variants only once they are introduced |
| Entity linking | Maps names to known concepts | Ambiguous brand name with no context | Add the category next to the name ("Sorank, the SEO software...") and schema with sameAs |
| Embeddings | Compares meaning of query and passage | The passage that should answer is generic and could fit any page | Write passages that restate the question's terms and give a specific answer |
| Classification | Assigns topics and intent | A product page full of blog-style digressions | One dominant intent per URL, other intents moved to other pages |
Note
Nobody outside Google knows the exact models used in ranking. The tools in this guide are proxies: they read text the way modern language models do, not the way Google's ranking system does. Use them to find ambiguity, not to predict positions.

Five signals are measurable with free or cheap tools. Each tells you something different, and none of them is a ranking factor on its own.
An entity is a named "thing": a brand, a product, a person, a place, a concept such as "keyword cannibalization". Google's Cloud Natural Language API returns, for each entity, a type, its mentions and, in version 1 of the API, a salience score. The v1 Entity reference describes it as "the salience score associated with the entity in the [0, 1.0] range". The entity types are UNKNOWN, PERSON, LOCATION, ORGANIZATION, EVENT, WORK_OF_ART, CONSUMER_GOOD, OTHER, PHONE_NUMBER, ADDRESS, DATE, NUMBER and PRICE.
Salience is relative to the document: the scores of all entities in a text compete with each other. So the useful reading is the ranking, not the number. If your page targets "NLP SEO" and the top entity is "Google", the page is, for a machine, mostly about Google. The detail is in our glossary entry on entity salience.
Warning: v1 versus v2
The v2 Entity object of the Natural Language API lists only name, type, metadata, mentions and sentiment: there is no salience field. If a tutorial shows salience scores, it calls v1. If you build a script today, call the v1 endpoint explicitly for salience and check the documentation before you rely on it.

The classifyText method returns categories from a fixed taxonomy (for example a path such as /Internet & Telecom/Web Services). Google's documentation on Natural Language basics notes that classification needs a text of at least twenty tokens. The use for SEO: if a page meant for "SEO software" is classified under a generic marketing category, its vocabulary is too generic.
Sentiment analysis returns a score from -1.0 (negative) to 1.0 (positive) and a magnitude that measures how much emotion the text carries. At document level, magnitude starts at 0.0 and is not normalized, so a long text with mixed opinions can show a neutral score and a high magnitude. For SEO, sentiment matters mostly on review pages, comparisons and "best X" lists, where a flat, opinion-free text answers a question that asks for an opinion.
Syntax analysis returns each token's part of speech, lemma and dependency. Two checks are worth running: how often your main entity is the grammatical subject of a sentence, and how many sentences start with a pronoun ("It", "This", "They"). A page where the main entity is the subject of many sentences is a page that talks about it, not around it.
Embeddings turn a passage into a vector. Comparing the vector of a query with the vectors of your passages (cosine similarity) shows which passage a retrieval system would pick for that query. This is the closest public proxy to how AI assistants select the chunk they quote. It is also the best test for "does this page actually answer the question, or just mention it".
"NLP SEO" covers six different methods. Vendors usually sell one of them as if it were the whole field. Here is each one, with when to use it and where it stops working.
Principle: identify the entities a complete answer must contain (the main entity, its attributes, related entities), check that your page names them clearly and that the main entity dominates. When to use it: on pages about a product, a brand, a person, a place or a well-defined concept. Strengths: it matches how knowledge graphs and AI answers are built, and it fixes ambiguity at the root. Limits: entity extraction misses domain jargon and new concepts; salience is unavailable in v2 of Google's API. Example: a page on "Shopify SEO" where "WordPress" comes out as a top entity because of a long comparison paragraph: the paragraph moves to its own page and the Shopify page gains focus. Our guide to entity SEO covers the strategy side.
Principle: compare the terms used by the top-ranking pages with yours, weighted by how specific they are (TF-IDF), and fill the gaps. This is what most content scoring tools do. When to use it: to spot subtopics you forgot on an informational page. Strengths: fast, easy to explain to a writer. Limits: it copies the average of the SERP, rewards repetition and says nothing about whether you answer the question. A term list is a checklist of subtopics, not a quota of words. Example: top pages on "technical SEO audit" all mention "crawl budget" and "canonical"; yours does not: two missing sections, not two missing words.
Principle: encode queries and passages as vectors and measure how close they are. When to use it: to check that each target question has one passage that clearly answers it, to detect two pages competing for the same meaning, and to map internal links by meaning. Strengths: works without shared words, close to how retrieval for AI answers works. Limits: scores depend on the model; a high score means "on topic", not "correct" or "useful". Example: the passage answering "how long does SEO take" scores lower than an unrelated intro paragraph: the answer passage is too vague and gets rewritten with the timeline stated first.
Principle: classify the query (informational, commercial, transactional, navigational) and the format Google rewards (guide, list, tool, product page), then match it. When to use it: before writing, and when a good page does not rank at all. Strengths: fixes the most expensive mistake, the wrong format. Limits: mixed SERPs exist; intent shifts over time. See our glossary entry on search intent.
Principle: extract the questions people ask (People Also Ask, forums, AI prompts, your support tickets) and give each one a self-contained passage. When to use it: for AI visibility and featured snippets. Strengths: directly produces citable passages. Limits: can fragment a page into a FAQ with no depth if you do not group questions by subtopic.
Principle: group keywords and pages by meaning to decide which page covers what, then link them. When to use it: at site level, before producing content and when pages cannibalize each other. Strengths: builds topical authority and a clean architecture. Limits: clustering by SERP overlap and clustering by embeddings give different groups; you need a rule to arbitrate. Our guide to keyword clustering details both approaches, and the topical map entry explains how to turn clusters into a plan.
| Method | Level | Best for | Main risk | Tools |
|---|---|---|---|---|
| Entity optimization | Page | Product, brand and concept pages | Treating salience as a ranking factor | Google Cloud Natural Language (v1), spaCy |
| Term coverage (TF-IDF) | Page | Finding missing subtopics | Writing the SERP average, stuffing | Content scoring tools, Python scikit-learn |
| Embedding similarity | Passage and site | Answer quality, cannibalization, internal links | Confusing "on topic" with "good" | Sentence Transformers, vector databases |
| Intent classification | Query and page | Choosing the right format | Ignoring mixed SERPs | Manual SERP review, classifiers |
| Question mining | Passage | AI citations, snippets | Shallow FAQ pages | People Also Ask, prompt research |
| Topic clustering | Site | Architecture, topical authority | Inconsistent cluster rules | Clustering tools, embeddings |
Term-list optimization vs entity and passage optimization
This is the method we recommend to start: one important page, one afternoon. You need the page text, three to five competing pages and either the free online tools or a few lines of Python.
The 6-step NLP page audit
spaCy is a free, open-source Python library. Its small English model runs on a laptop in seconds. The script below lists the most frequent entities and the most frequent grammatical subjects of your page: the second list is often more revealing than the first.
import spacy
from collections import Counter
nlp = spacy.load("en_core_web_sm") # pip install spacy, then: 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}")
# Who is the subject of your sentences?
subjects = Counter(t.lemma_.lower() for t in doc if t.dep_ in ("nsubj", "nsubjpass"))
print(subjects.most_common(15))
# How many sentences start with a vague pronoun?
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")
Read the subject list carefully. On a page about a software product, if "you" and "it" dominate and the product name never appears as a subject, the page describes actions without saying who performs them. That is fixable in an hour.

spaCy's general models do not compute salience. For that, call the v1 analyzeEntities endpoint of Google Cloud Natural Language. Create a project, enable the API, authenticate with the gcloud command line, then send your text. Save this request body as request.json:
{
"document": {
"type": "PLAIN_TEXT",
"language": "en",
"content": "Paste the clean main text of your page here."
},
"encodingType": "UTF8"
}
Then call the endpoint:
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"
The response lists entities with their type, salience, mentions and, when the entity is linked, a metadata object that can contain a wikipedia_url and a mid (a Knowledge Graph identifier). An entity with a Wikipedia URL in the metadata has been linked to a known concept; an important entity without one may be ambiguous or too new. Replace analyzeEntities by classifyText to get the content categories. Check the current pricing and quotas on Google Cloud before you run it on hundreds of pages.
The Sentence Transformers library compares the meaning of a question with every passage of your page. The model all-MiniLM-L6-v2 is small and good enough for this check.
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")
Two outcomes deserve action. If the best passage for a question is not the one you wrote to answer it, your answer passage is too generic. If the best score for a question is far below the others, the page does not really answer it. Compare scores between questions on the same page, not with an absolute threshold: values depend on the model.

Tip
No Python? Our free LLM Readability Checker scores a page for AI extraction, and the Heading Structure Analyzer shows whether your H2 and H3 announce the questions your passages answer.
Most NLP problems are fixed in the writing, not in a tool. These rules come straight from the pipeline above: each one removes a step where a machine can go wrong.
Use the full name of the main entity as the subject of the first sentence of each section. Avoid opening a paragraph with "It" or "This". Pronouns are fine inside a paragraph, once the noun is close.
A definition that states the category (Y) and the distinguishing feature (Z) is the easiest structure for a model to extract and for an AI assistant to quote. "Entity salience is a score from 0 to 1 that measures how central an entity is to a text" beats three sentences of context.
Prices, dates, sizes, compatibilities and limits must sit next to the entity they describe. "Sorank tracks visibility in ChatGPT, Gemini, Claude and Perplexity" is one extractable fact. The same information split across a heading, a bullet and a footnote is three fragments.
Pick one name for each product, feature and concept. Introduce a synonym once ("query fan-out, the way AI assistants split a question into several searches") and then stick to one form.
Under a heading that asks a question, the first sentence gives the answer. The rest of the passage gives the conditions, the example and the exceptions. This is what makes a passage self-contained.
One paragraph, before and after an NLP rewrite
The "after" sentence is an illustration of the structure, not a description of a real product: adapt the attributes to what your page really offers.
Python NLP for semantic SEO means running the same kind of embedding model as the passage test above, but over whole lists: your keywords and the pages of your site. Two short scripts answer questions that a single-page check cannot. Which keywords belong on the same page? Which of your pages compete for the same meaning? Both run on your own machine at no cost, and both produce candidates for you to review, not verdicts.
Install the libraries in a virtual environment, so that they do not clash with other Python projects:
python3 -m venv nlp-seo
source nlp-seo/bin/activate
pip install sentence-transformers scikit-learn
The first run downloads the all-MiniLM-L6-v2 model once. After that, both scripts run offline.
Clustering turns a flat keyword list into groups that one page could answer. Each keyword becomes a vector, and keywords whose vectors are close in cosine distance land in the same group. Keep your keywords in a text file, one per line, and run this 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, # cosine distance: lower values give stricter groups
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)
The threshold is the setting that matters. Start at 0.35 and read the output. If unrelated keywords share a group, lower it. If the topic of one page is split across several groups, raise it. Average linkage reduces chaining, the effect where a string of loosely related keywords joins two unrelated groups.
The second script compares your pages with each other. Put one row per page in a tab-separated file with a header row, using the columns url and title. Titles are a rough proxy, so for a sharper test, paste the first paragraph of each page into the title column.
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: # starting point: adjust after reading the results
print(f"{score:.2f} {rows[i][0]} vs {rows[j][0]}")
Each printed pair is a candidate, not a verdict. Open both URLs and ask whether a reader would expect either page to answer the other's question. If the answer is yes, merge the two pages, or keep one as the main page and narrow the focus of the other. The keyword cannibalization entry explains how to choose.
| Script | Input | Output | What you decide |
|---|---|---|---|
| Keyword groups | One keyword per line | Groups of keywords that share a meaning | Whether each group needs one page or several |
| Competing pages | URL and title, or first paragraph, per page | Pairs of pages above your threshold | Whether to merge, refocus or keep both pages |
Three limits matter:
These scripts are the site-level counterpart of the passage test above: one tells you what belongs together, the other tells you where your pages overlap. If you would rather not maintain the scripts, Sorank's Topic Cluster Generator runs the grouping step with an anti-cannibalization check built in.
Language models read more than your paragraphs. Three elements around the text carry strong signals.
Schema.org markup does not make a page rank by itself, but it states in a machine format what the page is about and which known concepts it refers to. The about and mentions properties, with sameAs links to reference pages, remove ambiguity for entity linking.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "NLP SEO: How Search Engines Read Your Content",
"about": {
"@type": "Thing",
"name": "Natural language processing",
"sameAs": "https://en.wikipedia.org/wiki/Natural_language_processing"
},
"mentions": [
{
"@type": "Thing",
"name": "Search engine optimization",
"sameAs": "https://en.wikipedia.org/wiki/Search_engine_optimization"
}
]
}
</script>
Generate and test yours with our free Schema Markup Generator and Structured Data Validator.
Headings are the first thing a model uses to split your page into passages. A heading that names the entity and the question ("How entity salience is calculated") produces a cleaner chunk than a clever one ("Under the hood"). Keep the H2 and H3 hierarchy strict: no H3 without a parent H2, no skipped levels.
Anchor text is one of the oldest NLP signals in search: it tells the engine what the target page is about, from the outside. Use descriptive anchors that name the target entity, link pages that are close in meaning, and avoid sending the same anchor to two different pages. A semantic cocoon is the most structured way to organize this, and our guide to automated internal linking explains how to scale it without creating noise.
AI assistants push NLP logic to its end. They do not rank whole pages: they retrieve passages, compare them by meaning with sub-queries, and assemble an answer that sometimes cites the source. Three consequences follow.
For the full method applied to AI answers, see our guide to LLM content optimization.
These are the errors we see most often on audited sites. Each one has a symptom you can spot and a fix you can apply today.
What it is: rewriting until the API gives your keyword a high salience, or until a tool shows a green score. How to spot it: the page reads worse after optimization; the same phrase appears in every paragraph. How to fix it: use salience only to check the order of entities, then judge the page on answers and Search Console data. Google has never said it uses this API's scores in ranking.
What it is: adding "crawl budget" in a sentence because five competitors mention it. How to spot it: terms appear once, out of context, with no explanation. How to fix it: each missing entity becomes a question: does my reader need this? If yes, write a passage; if no, ignore it.
What it is: pasting the whole page, menu and footer included, into an NLP tool. How to spot it: your top entities are your brand name, "cookies", "contact" or footer categories. How to fix it: extract only the article body before running any analysis.
What it is: following an old tutorial with the current endpoint. How to spot it: the JSON response has entities and mentions but no salience. How to fix it: call /v1/documents:analyzeEntities for salience, and keep in mind that v1 may change.
What it is: paragraphs where "it", "this" and "they" refer to nouns several sentences back. How to spot it: the spaCy script above counts sentences that start with a pronoun; more than one in five on a key page is a red flag. How to fix it: restate the noun at the start of each paragraph and after each heading.
What it is: a single URL trying to define a concept, compare tools and sell a product. How to spot it: the page ranks for many queries at positions 15 to 40 and for none in the top 5. How to fix it: keep the dominant intent, move the others to dedicated pages, link them.
What it is: padding a page to reach a target word count or keyword density. How to spot it: repeated introductions, generic paragraphs that could fit any page. How to fix it: cut every passage that does not answer a question a reader would ask. Our Keyword Density Calculator is useful in reverse: to find where you repeat too much.
What it is: using a brand or product name that a machine cannot tell apart from a common word or another company. How to spot it: the API returns your brand as OTHER or CONSUMER_GOOD without metadata, or links it to the wrong concept. How to fix it: add the category next to the name, use Organization or Product schema with sameAs to your official profiles, and keep the name identical everywhere.
NLP SEO checklist for one page
You do not need a large stack. Pick tools by the question you need answered.
| Tool | Type | What it tells you | Skill needed | Best use |
|---|---|---|---|---|
| Google Cloud Natural Language | Cloud API (see Google Cloud pricing) | Entities, salience (v1), categories, sentiment, syntax | Medium: a Google Cloud project and a few commands | Checking how a Google model reads your key pages |
| spaCy | Open-source Python library | Entities, sentence structure, subjects, lemmas | Basic Python | Auditing many pages locally, at no cost |
| Sentence Transformers | Open-source Python library | Meaning similarity between queries and passages | Basic Python | Answer checks, cannibalization, internal link mapping |
| Google Search Console | Free Google tool | The queries each URL really appears for | None | Measuring the effect of a rewrite |
| Content optimization tools | SaaS | Term and entity gaps against top pages | None | Quick subtopic check before writing |
| Sorank | SEO and GEO software on autopilot | Rewrites, topic clusters, AI visibility tracking | None | Applying the method across a whole site |
For a side-by-side review of the commercial options, read our comparison of the best content optimization tools. If you have dozens of older pages to fix, Sorank's Content Optimization feature audits and rewrites existing pages on autopilot, and the Topic Cluster Generator groups your keywords by meaning before you write, with a built-in check against cannibalization.
NLP changes are about understanding, so measure understanding first, then traffic.
In Google Search Console, filter the Performance report on the rewritten URL and count the distinct queries with impressions over 28 days, before and after. A page that is better understood usually appears for more long-tail variants within a few weeks, often before clicks move.
Track the 5 to 10 questions you used in the passage test. If impressions rise but position does not, the page is understood but not preferred: work on depth, examples and links.
Ask the same prompts in ChatGPT, Gemini, Claude and Perplexity before and after, and note whether your page is cited. Repeat monthly: AI answers vary from one run to the next, so one test proves nothing. For a structured version of this check, run a semantic SEO audit on the whole cluster rather than on a single page.
Pick the page that brings you the most business and run the six-step audit on it. Fix the first two problems you find, usually a main entity that is not dominant and an answer passage that is too vague. Then note the date, and check its queries in Search Console in four weeks.
NLP in SEO means making your content easy for language models to understand: which entities a page covers, which questions each passage answers and how the page relates to the rest of the site. Google has used language models such as BERT in Search since 2019, and AI assistants rely on them entirely, so clear, unambiguous writing has become a ranking and citation factor in practice.
No public statement from Google says that the salience score of its Cloud Natural Language API is used in ranking. The score is a useful proxy to check whether your main topic dominates the page, but you should read the order of entities rather than chase a number. Note that salience is only returned by version 1 of the API.
spaCy and Sentence Transformers are free open-source Python libraries for entity extraction and passage similarity. Google Search Console, also free, then shows whether a rewritten page appears for more queries. Google Cloud Natural Language adds salience and categories, with usage billed according to Google Cloud pricing.
