Preferences

Privacy is important to us, so you have the option of disabling certain types of storage that may not be necessary for the basic functioning of the website. Blocking categories may impact your experience on the website. More information (Cookie Policy)

NLP SEO: How Google and AI Read Your Content, and How to Write for Them

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.

Published on
16/11/2026
Updated on
16/11/2026
Reading time
26 min
NLP SEO: How Google and AI Read Your Content, and How to Write for Them

Tools

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?

Question 1 of 425%
Do people search Google for what you sell?

What NLP SEO actually means (and what it does not)

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.

  1. Understanding how engines read. Google has used language models in ranking since BERT, and AI assistants are built entirely on them. Their failure modes (vague subjects, pronoun chains, missing definitions) are predictable.
  2. Measuring how your page is read. You can run your own text through public NLP tools to see which entities come out, which category the text falls into and which passages match a query.
  3. Writing and structuring for clarity. You fix what the tools misread: you name things, define them, attach attributes to them and link them to the right pages.

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

1 in 10US English searches better understood by BERT at launch (October 2019)
1000xmore powerful than BERT, according to Google, for its MUM model (May 2021)
75languages MUM was trained across

Sources: Google, Pandu Nayak, "Understanding searches better than ever before" (2019) and "MUM: A new AI milestone for understanding information" (2021)

From strings to things

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.

How search engines and AI read your page: the NLP pipeline

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

  1. Extract the main contentNavigation, footer, cookie banners and sidebars are separated from the body. Thin or messy templates blur this step.
  2. Split into sentences and tokensText is cut into sentences, then into tokens (words or word pieces). Very long sentences and missing punctuation degrade this.
  3. Tag and parseEach token gets a part of speech and a role in the sentence: subject, verb, object, modifier.
  4. Recognize entitiesNames of products, people, places, concepts and numbers are detected and typed (organization, location, price, date...).
  5. Link entitiesEach entity is matched to a known concept in a knowledge base, so that "Jaguar" becomes the car brand or the animal.
  6. Embed passagesSentences and passages are turned into vectors so that meaning can be compared with the query, even without shared words.
  7. Classify and scoreThe page gets topics, an intent profile and, for some systems, sentiment. Passages are ranked against queries.

What each step means for your content

The table below maps each NLP task to the concrete risk on a page and the fix you control.

NLP taskWhat the machine doesTypical problem on a pageWhat you change
Boilerplate removalSeparates main content from templateThe intro is buried after 600 words of menus and widgetsPut the answer in the first paragraph of the main content, in plain HTML
Sentence splittingCuts text into sentencesBullet fragments with no verb, 60-word sentencesOne idea per sentence, full sentences in lists that carry facts
Dependency parsingFinds subject, verb, objectThe subject is "it" or "this" three sentences away from its nounRepeat the noun, keep subject and verb close
Named entity recognitionDetects and types namesYour product is written five different waysPick one canonical name, use variants only once they are introduced
Entity linkingMaps names to known conceptsAmbiguous brand name with no contextAdd the category next to the name ("Sorank, the SEO software...") and schema with sameAs
EmbeddingsCompares meaning of query and passageThe passage that should answer is generic and could fit any pageWrite passages that restate the question's terms and give a specific answer
ClassificationAssigns topics and intentA product page full of blog-style digressionsOne 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.

Illustration of a web page whose text is turned into a network of connected blue nodes representing entities and their relationships.
NLP turns the words of your page into entities and relationships: the clearer they are, the better Google and AI assistants understand it.

The NLP signals you can measure on your own page

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.

Entities and salience

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.

Google Cloud Natural Language product page, the API used to extract entities, categories and sentiment from text.
Google Cloud Natural Language: the public product page of the API that returns entities, salience (v1), categories and sentiment.

Content categories

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

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

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 and passage similarity

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 methods compared

"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.

1. Entity optimization

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.

2. Term coverage (TF-IDF and co-occurrence)

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.

3. Embedding similarity

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.

4. Intent classification

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.

5. Question and passage mining

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.

6. Topic modeling and clustering

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.

MethodLevelBest forMain riskTools
Entity optimizationPageProduct, brand and concept pagesTreating salience as a ranking factorGoogle Cloud Natural Language (v1), spaCy
Term coverage (TF-IDF)PageFinding missing subtopicsWriting the SERP average, stuffingContent scoring tools, Python scikit-learn
Embedding similarityPassage and siteAnswer quality, cannibalization, internal linksConfusing "on topic" with "good"Sentence Transformers, vector databases
Intent classificationQuery and pageChoosing the right formatIgnoring mixed SERPsManual SERP review, classifiers
Question miningPassageAI citations, snippetsShallow FAQ pagesPeople Also Ask, prompt research
Topic clusteringSiteArchitecture, topical authorityInconsistent cluster rulesClustering tools, embeddings

Term-list optimization vs entity and passage optimization

Term list (TF-IDF scoring)
  • Quick gap check against competitors
  • Rewards repeating words
  • Copies the SERP average
  • Says nothing about answer quality
Entities and passages
  • Removes ambiguity about the main subject
  • Produces passages AI can quote
  • Works across languages and synonyms
  • Needs a bit more setup

Step by step: run an NLP audit on one page

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

  1. Extract clean textCopy only the main content (no menu, no footer) of your page and of 3 to 5 top-ranking pages into text files.
  2. List entitiesRun entity extraction. Note the top 10 entities of each page and their order.
  3. Check the main entityYour target concept must be in the top 3 of your own page. If not, find which entities steal the focus.
  4. Map missing entitiesEntities present in most competitors and absent from your page are candidate subtopics, not words to insert.
  5. Test passages against questionsWrite the 5 to 10 questions the page must answer and measure which passage matches each one.
  6. Rewrite and re-runFix the weak passages, re-run both checks, then watch Search Console queries for that URL over the next weeks.

Step 1 and 2: extract entities with spaCy

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 documentation page on linguistic features such as named entity recognition and dependency parsing.
spaCy's documentation on linguistic features: entity recognition, part-of-speech tags and dependency parsing, free and open source.

Step 3: get salience from Google's API (v1)

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.

Step 5: test passages against questions with embeddings

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.

Sentence Transformers documentation homepage, the library used to compare the meaning of queries and passages.
Sentence Transformers: the open-source library used to measure how close a passage is to a question.

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.

Writing for NLP: sentence-level rules that work

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.

Name the subject, then keep it

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.

Define with a "X is a Y that Z" sentence

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.

Attach attributes to the entity, in the same sentence

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.

One canonical name per thing

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.

Answer first, then explain

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

Before
  • "It helps you get more visibility. This is done automatically every week."
  • Subject unclear: "it" and "this"
  • No entity, no attribute, no number
  • Could be pasted on any SaaS page
After
  • "The rank tracker checks your 200 target keywords in Google every Monday and emails you the pages that dropped."
  • Named subject: "the rank tracker"
  • Attributes attached: keywords, engine, frequency, output
  • Specific enough to be quoted as a fact

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: group keywords and find competing pages

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.

Set up the environment

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.

Group keywords by meaning

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.

Find pages that compete for the same meaning

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.

ScriptInputOutputWhat you decide
Keyword groupsOne keyword per lineGroups of keywords that share a meaningWhether each group needs one page or several
Competing pagesURL and title, or first paragraph, per pagePairs of pages above your thresholdWhether to merge, refocus or keep both pages

Three limits matter:

  • Scores depend on the model. Compare pairs and groups from the same run, and never copy a threshold from a tutorial.
  • Embeddings capture meaning, not intent. “Best CRM software” and “how to set up a CRM” share a topic but need different pages, so check intent before you merge anything.
  • Brand names, product names and very recent terms may be encoded poorly. Check those groups by hand.

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.

Structured data that names your entities

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 as a table of contents for machines

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.

NLP SEO for AI search: getting quoted by ChatGPT, Gemini and Perplexity

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.

  1. Every passage must stand alone. What gets retrieved is a chunk of your page, not the page. If it depends on a definition given three sections earlier, it loses.
  2. One question becomes several searches. Assistants split a prompt into sub-queries (query fan-out). A page that answers the main question but not its natural follow-ups (price, alternatives, limits, how to start) covers only part of what is searched. Sorank's Query Fan-Out Tracker shows the searches AI really runs behind a prompt.
  3. Entity consensus matters. An assistant is more confident about a fact it finds stated the same way on several sources. Consistent naming and attributes across your site, your profiles and third-party mentions help. Our entry on entity consensus covers this layer.

For the full method applied to AI answers, see our guide to LLM content optimization.

Common NLP SEO mistakes (and how to fix them)

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.

1. Treating salience or a content score as a ranking factor

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.

2. Inserting competitor terms as words, not as content

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.

3. Analyzing the full HTML instead of the main content

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.

4. Calling v2 of Google's API and wondering where salience went

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.

5. Pronoun chains and vague subjects

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.

6. One page, several intents

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.

7. Writing to a length or a density

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.

8. Ignoring entity linking

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

  • The main entity is named in the first sentence and in the H1
  • The main entity is in the top 3 entities of the page
  • Each H2 or H3 announces a question or a subtopic in plain words
  • The first sentence under each question heading gives the answer
  • Fewer than one sentence in five starts with a vague pronoun
  • Every important attribute sits in the same sentence as its entity
  • One canonical name per product, feature and concept
  • Structured data names the main entity with sameAs links
  • Internal links use descriptive anchors that name the target
  • No term inserted only because a tool or competitor uses it

NLP SEO tools: what each one is good for

You do not need a large stack. Pick tools by the question you need answered.

ToolTypeWhat it tells youSkill neededBest use
Google Cloud Natural LanguageCloud API (see Google Cloud pricing)Entities, salience (v1), categories, sentiment, syntaxMedium: a Google Cloud project and a few commandsChecking how a Google model reads your key pages
spaCyOpen-source Python libraryEntities, sentence structure, subjects, lemmasBasic PythonAuditing many pages locally, at no cost
Sentence TransformersOpen-source Python libraryMeaning similarity between queries and passagesBasic PythonAnswer checks, cannibalization, internal link mapping
Google Search ConsoleFree Google toolThe queries each URL really appears forNoneMeasuring the effect of a rewrite
Content optimization toolsSaaSTerm and entity gaps against top pagesNoneQuick subtopic check before writing
SorankSEO and GEO software on autopilotRewrites, topic clusters, AI visibility trackingNoneApplying 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.

How to measure the impact of NLP work

NLP changes are about understanding, so measure understanding first, then traffic.

The number of queries per URL

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.

Position on the questions you targeted

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.

Citations in AI answers

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.

What to do today

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.

Frequently asked questions

What is NLP in SEO?

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.

Is entity salience a Google ranking factor?

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.

Which free tools can I use for NLP SEO?

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.

Get your content plan for 30 days for free

We analyse your competitors, your website and your AI visibility to create a tailored content plan for free.

Our free SEO tools

See all our free tools

Get your content plan for 30 days for free

We analyse your competitors, your website and your AI visibility to create a tailored content plan for free.

Man with dark hair and beard wearing a light brown shirt speaks in front of a microphone on a podcast or recording setup.Portrait of a man with short dark hair wearing a white shirt and dark jacket, looking directly at the camera with a neutral expression.Man with short dark hair, beard, and clear glasses wearing a black t-shirt with a white circular logo, standing in front of a stone wall.Celio fabianoSmiling young woman with long brown hair wearing a red top and necklace, outdoors in a tree-filled background.Profile photo of Xavier Breull, Sorank customer
Google
Solid yellow five-pointed star icon on transparent background.Solid yellow five-pointed star icon on transparent background.Solid yellow five-pointed star icon on transparent background.Solid yellow five-pointed star icon on transparent background.Solid yellow five-pointed star icon on transparent background.
5/5
+5,000
users

Testimonials from ambitious founders

0 to 10000 visitors in 5 months

Celio Fabianomonrobotlavevitre.frGoogleE-commerce

0 to 5000 visits in 8 months

Thibault BMsorank.comGoogleSoftware

0 to 1104 clicks in 4 months

Dominiqueflight-sensations-idf.comGoogleLeisure and aviation

0 to 163 clicks in 6 months

Coworking Pariscoworking-paris.frGoogleOffice broker

x92 clicks in 7 months

Guide Zanzibarguidezanzibar.comGoogleTravel