The AI-powered Entity Audit
Diagnose and fix how machines understand your site. You will run a complete entity audit on a real website — mine — and come out with a scored diagnosis, a prioritised backlog and a 30/60/90 roadmap you can hand to a client or a content team.
Join agency, freelance and in-house SEOs learning with MLforSEO
Join the waitlist
Be first in line when purchasing opens — and lock in the €100 waitlist price instead of €150.
You’ve been told to “do entity SEO” for three years. Nobody told you how to measure it.
So it stays a vibe. You add some schema, you mention a few related concepts, you hope. And when the client asks whether it worked, you have nothing to show them except rankings that move for fifteen other reasons.
Meanwhile the systems deciding what you are relevant for have stopped reading keywords. They read entities — the real-world things your content is about — and the relationships between them.
This course fixes that specific problem. Not the strategy — the diagnosis. A repeatable audit that produces a number you can put in a deck, re-run in ninety days, and show movement on.
And it is demonstrated on a real site with real problems. Not a fictional client, not a tidy example. My own site, live and unedited, including the findings that are embarrassing.
By the end you will be able to answer, with evidence: what does this site look like to a machine, where is that wrong, and what is the cheapest thing to fix first?
What you’ll take away
Six capabilities that turn entity work from an opinion into a measurement — each one practised on a real site, with the dataset bundled so your numbers match the video.
Read what a machine thinks your page is about
Salience, mentions, types and identifiers — the four signals every entity audit reads, and how to spot a page whose subject is not the one you intended.
Build an audit corpus you can trust
Crawl, extract, exclude and sample properly. The step that decides whether every number after it is true, and the four ways it quietly breaks.
Score any site on the 5C framework
Clarity, Coverage, Consistency, Connection and Corroboration — zero to three each, at page and site level, with a fix mapped to every score.
Audit the Knowledge Graph properly
Reconcile your entities to Google’s graph, and catch over-linking — when Google confidently resolves your brand to something else entirely.
Find your real competitors, with data
Current-state versus aspirational sets, and why the gap between how you are classified and how you want to be is the entity problem.
Fix what you found, and prove it worked
Six repeatable fix patterns backed by published research — then re-run the extraction and show the salience actually moved.
Measured, not asserted
Audited on a real site, including what it got wrong
Every figure in this course comes from one frozen audit of mlforseo.com and academy.mlforseo.com — 647 pages, 102,752 entity mentions, captured before anything was fixed. The site scored 5 out of 15. You see the findings that are unflattering, because those are the ones that teach.
Six tools, free, and yours after the course
An extractor, a scorecard, a Knowledge Graph reconciler, a consistency checker, a gap matrix and a brief generator. They run in your browser, your API keys never leave the tab, and the second audit takes an afternoon instead of a week.
The tactics are research-backed, and the caveats are stated
Why position beats repetition, why how you name a thing beats how often, why spreading an entity through a page beats concentrating it — each traced to published work, with the numbers, and with what the evidence does not support said out loud.
What’s included
A complete diagnostic path: understand entities, build a corpus you can trust, score it, audit the graph, compare against real competitors, fix what you found, and hand over a roadmap.
›Lesson 0.1 — Course Introduction: What You’ll Build and Who This Is For
- What the course produces: a scored diagnosis, a backlog, a roadmap and a toolkit
- Who it is for, and what it assumes you already know (SEO yes, NLP no)
- The demo site, and why it is real rather than fictional
›Lesson 0.2 — Setup: Your Audit Stack, API Keys and What It Costs
- Two Google APIs on one key, plus one optional Anthropic key
- Real cost maths at 1,000, 10,000 and 50,000 pages — and why most audits are free
- Free-tier limits, quota traps, and the habit of pricing a run before you start it
›Lesson 1.1 — Entities, Keywords and Topics: The Mental Model You Actually Need
- What an entity is — a thing, not a string — and why it is not a keyword
- The EAV model, applied to auditing rather than theory
- Three places entities live, and why each one is a different audit
›Lesson 1.2 — How Machines Decide What Your Page Is About
- The four signals: salience, mentions, type and machine identifier
- Reading a real API response, field by field
- The version trap, and four ways extraction quietly breaks
›Lesson 1.3 — The 5C Entity Audit Scorecard
- Clarity, Coverage, Consistency, Connection, Corroboration — defined and scored
- The rubric: zero to three, and why precision you cannot defend is worse
- Scoring the demo site live — it gets 5 out of 15
›Lesson 2.1 — Building an Audit Corpus You Can Actually Trust
- The five columns you need, and the one that takes real setup
- Isolating main content — the selector that decides everything downstream
- What to exclude, and how to sample a large site honestly
›Lesson 2.2 — Entity Extraction with the Google NLP API
- The Entity Extractor, step by step, on one page and then a whole corpus
- What “most common entity” actually returns on a real site
- Why this course pins API version 1
›Lesson 2.3 — Page Profiles and Prominence Scoring
- Three filters that turn a hundred thousand mentions into an audit
- Intended versus detected — the highest-value single diagnostic here
- Scoring Clarity across the corpus
›Lesson 2.4 — Claude as Your Entity Analyst
- What the NLP API cannot see, and where an LLM adds something
- Structured outputs, so the answer is auditable rather than prose
- Hallucinated entities, and the three checks that catch them
›Lesson 2.5 — Controlling Cost and Runtime
- The four levers: free tier, batching, caching and model tiering
- What an audit costs at three site sizes
- Pricing a run before you spend anything
›Lesson 3.1 — What Google’s Knowledge Graph Can and Cannot Tell You
- What a machine identifier is, and what presence in the graph does and does not buy
- The state of the API in 2026 — legacy, read-only, not production-critical
- Reading resultScore correctly, and why knowledge panels are an outcome not a target
›Lesson 3.2 — Reconciling Your Entities to the Knowledge Graph
- Running the Reconciler across a real 5,000-entity set
- Matched, ambiguous, unmatched — and what each verdict means
- Scoring Connection across your corpus
›Lesson 3.3 — The Unreconciled Entity Report
- Triaging unmatched entities: genuinely novel, badly named, or noise
- Choosing one canonical surface form, and making it stick
- Scoring Consistency
›Lesson 3.4 — Entity Over-Linking: When Google Resolves You to the Wrong Thing
- Two identifiers on one brand — one generic, one that resolves to nothing at all
- Detecting it at scale by clustering on identifier
- Why an over-linked entity is worse than an unlinked one
›Lesson 3.5 — Off-Site Corroboration: Does the Rest of the Web Agree?
- Wikipedia and Wikidata, and why third-party confirmation moves recognition
- Asking a model cold, and the distinction between weights and retrieval
- Scoring Corroboration — and the sentence to get exactly right
›Lesson 4.1 — Entity Gap Analysis: The Right Way to Compare
- Current-state versus aspirational competitor sets — the delta is the entity gap
- Coverage, depth and attribute gaps — three problems, three different fixes
- Choosing comparables, and why the SERP leader usually is not one
›Lesson 4.2 — Finding Your Real Competitors
- Discovery by ranking-keyword overlap: how a site is actually classified today
- The AI-citation set, and why it matches neither of the other lists
- Live on the demo site — which turns out to be classified as data science, not SEO
›Lesson 4.3 — Topic-Level AI Citation Analysis, and How to Not Fool Yourself
- Configuring the query so the answer means something
- The contamination trap, demonstrated on three real queries
- Sanity-checking AI-visibility data before it reaches a client deck
›Lesson 4.4 — Building the Entity Gap Matrix
- Running the same pipeline over real competitor content
- Normalising names across corpora — where most gap analyses break
- Scoring Coverage, and reading the heat map
›Lesson 4.5 — Prioritising Which Gaps Are Worth Closing
- Scoring gaps on impact, effort and confidence
- Quick wins versus structural work
- The prioritised backlog you actually hand over
›Lesson 5.1 — The Six Fix Patterns, and the Research Behind Them
- Disambiguation, canonical naming, attribute completion, entity-first structure, internal linking, corroboration
- Why position beats repetition — with the published numbers
- Each pattern mapped to the dimension it moves and what it costs
›Lesson 5.2 — Fixing Clarity: The Highest-Yield Edits
- The four placements that matter, in order
- A worked fix on a real page, re-measured after every round
- When an edit will not work, and what to do instead
›Lesson 5.3 — AI-Assisted Content Rewriting with Claude
- Building a rewrite brief from audit data, not from a blank prompt
- Guardrails: facts, tone and rankings that must survive untouched
- Proving the fix worked by re-running the extraction
›Lesson 5.4 — Internal Linking on Entity Overlap
- Finding link opportunities from shared prominent entities
- Anchor text that reinforces canonical naming
- Validating against the inlinks report so you do not propose links that exist
›Lesson 5.5 — Structured Data as Entity Definition
- The five properties that actually carry entity weight
- The audit check: schema against content against the graph
- A real contradiction found live on the demo site, and how to repair it
›Coming as a free bonus to everyone who buys the course
- Practical guidance, scripts and tooling for auditing entities at 50,000+ pages
- BigQuery pipelines, Google Cloud enrichment and incremental runs
- Released to all course members at no extra cost — the core 27 lessons are complete without it
›Lesson 7.1 — Your 30/60/90 Entity Remediation Roadmap
- Sequencing the backlog — what genuinely has to happen first
- What to re-run, how often, and which numbers to report
- Built from the demo site’s own audit
›Lesson 7.2 — Everything You Built, and Where to Go Next
- The corpus, the scorecard, the gap matrix, the backlog and the roadmap
- The tools and workbooks you keep and re-use on every client
- How to get your first audit reviewed
Every practical lesson runs on the frozen dataset bundled with the course — so your numbers match the ones spoken on camera, exactly.
Who this course is for
- You are an agency, freelance or in-house SEO who has been asked to “do entity SEO” and wants a repeatable method
- You work on small to mid-size sites — up to around 50,000 pages
- You want a number you can defend in a client meeting, not a list of opinions
- You are comfortable with a spreadsheet and willing to paste an API key into a browser tool
- Enterprise SEO teams: yes — and a dedicated practical module on BigQuery, Google Cloud and very large sites is coming as a free bonus. Start here, prove the method on one section first, then scale. The approach is identical at every size; only the infrastructure changes.
- You want a strategy course on building brand authority and knowledge graphs — that is Beatrice Gamba’s course, and it bundles with this one
- You are looking for a deep theoretical treatment of named entity recognition — Introduction to ML for SEO covers the technique in depth
- You want structured data implementation at scale — that is its own course, launching shortly and bundled with this one
- You are hoping for a guaranteed knowledge panel. Nobody can promise that, and this course says so plainly
What you’ll walk away with
Not notes. Artefacts you re-use on every client, and a toolkit that makes the second audit an afternoon rather than a week.
Entity Audit WorkbookXLSX
The scoring sheets, the prioritisation columns and the mapping tables, ready to fill in for your own site.
The frozen demo datasetCSV
The complete audit of a real site — 647 pages, 102,752 entity mentions — captured before anything was fixed, so your numbers match the video exactly.
Six browser toolsWEB
Extractor, Scorecard, Knowledge Graph Reconciler, Consistency Checker, Gap Matrix and Brief Generator. Free, no account, and your API keys never leave the tab.
A completed 5C scorecardJSON
Saved from the tool, so you have a genuine before state to compare against in ninety days.
Your prioritised remediation backlogXLSX
Every finding scored on impact, effort and confidence, with a named fix pattern and the dimension it moves.
A 30/60/90 roadmapDOCX
Sequenced properly — including the one task that has to start on day one because it is the slowest.
More resources are added over time, and course members get them at no extra cost.
Built by someone who audited her own site on camera and left the bad numbers in.
ML and SEO consultant working at the point where machine learning stops being a demo and starts being a repeatable process.
Lazarina works at the intersection of machine learning and organic search, helping teams apply ML and NLP to problems that actually move the needle rather than to proofs of concept.
This course is built the way she works: on a real site, with every number shown and traceable, and with the unflattering findings left in. The demo site is her own — audited live, unedited, and scoring 5 out of 15 on the day it was recorded.
When it opens, and what it costs
Prices exclude VAT where applicable. Community members get the usual 30% discount, and bundles with the Entity SEO & Knowledge Graph Strategies and Structured Data Automation courses are cheaper again.
Join the waitlist
Be first to know when purchasing opens on 30 September — and lock in €100 instead of the €150 standard price.
Frequently asked
No. The course assumes you know SEO and assumes you know nothing about entities, natural language processing or knowledge graphs. Everything technical is built up from zero, and every concept is defined before it is used.
No. Everything runs in six browser tools built for the course. There is an optional notebook for the one lesson that uses an LLM, but it is copy-and-run — and that lesson works fine if you just watch.
For most sites, nothing. Google gives you 5,000 free units a month and 100,000 Knowledge Graph lookups a day. The entire audit of the demo site — 647 pages, 102,752 entity mentions — cost zero. A 10,000-page site is around €46, and every tool prices the run before it spends anything.
The course is €150. Everyone on the waitlist gets it for €100. Community members get the usual 30% discount on top, and it bundles with the related courses.
Yes, with a sequence. The method is identical at any size — only the infrastructure changes. A dedicated practical module covering BigQuery, Google Cloud and 50,000+ page sites is coming as a free bonus for course members. Learn the approach here and prove it on one section first, then scale it.
That course is the strategy: building brand entity authority and deploying a knowledge graph. This one is the diagnosis: finding out what is broken and proving it. They fit together — this course tells you what to fix, that one tells you what to build — and they bundle.
Nobody can promise that, and the course says so directly. Panels are an outcome of entity recognition, not something you can request. What you can measure and move is recognition itself, which is what the scorecard scores.
Yes — a certificate of completion, plus lifetime access to the course and every update to it.