Entity SEO API - Google Knowledge Graph for Any URL

What does the Entity SEO API do?

The Entity SEO API is an entity extraction API: give it any URL and it returns the Google Knowledge Graph entities Google associates with that page, each scored 0–100 and resolved to a human-readable name. It's Google's own read of the live page, not a re-analysis of text you paste in.

Real output from two pages competing for "tiktok comments scraper", one ranking #1 and one #6 (abridged, July 2026):

Entity Google credits	Page ranking #1	Page ranking #6
web scraping	60	65
TikTok	57	63
data	53	50
application programming interface	63	15
web crawler	37	not credited
video recording	38	58
JSON	not credited	19
/g/11fy265933 (no public name, see FAQ)	26	36

How to read it:

• 🔍 Both pages get credit for the basics: web scraping, TikTok, data. Google understood what these pages are.
• 🆚 The gap is the content brief. The #1 page scores 63 on API and 37 on web crawler; the #6 page scores 15 and nothing. Own the #6 page? Those two rows are what to add. No claim that this is why #1 wins, but it's what you can measure.
• ⏱️ Scores move on recrawl. Close the gap, re-run: shifted scores mean Google understood your edit, usually weeks before a rank tracker reacts.
• 📡 Any entities at all mean Google has crawled and classified the page. Daily runs show within a day when a new page gets picked up or an edit sinks in.
• 🧩 Not a keyword tool. It shows what Google credits, not what people search. Pick targets with keyword research; check them here.

Each URL returns ranked entities with stable Knowledge Graph IDs, scores, names and descriptions, plus the page's hero image and "about this site" link when Google has them. Plain JSON. Run it from the Apify Console, the Apify API, or n8n, Zapier and Make. Or put it on an Apify Schedule: a daily cron on your key pages is a running entity and indexation monitor, so you know the day Google's read of a page shifts.

How do you find the entities Google associates with a page?

Send URLs, get ranked lists like the table above. 100 means the entity is the page's main subject; lower scores are supporting topics. What's missing tells you as much as what's there.

IDs like /m/053_d are resolved to names and descriptions through Wikidata: Marie Curie (Polish-French physicist and chemist) instead of an opaque code. IDs with no public mapping come back bare, with their score. Those are internal Google entities with no public name anywhere, so there is nothing to resolve them against. You can still infer what one means from the named entities around it, or by checking which competing pages carry the same ID.

What are Knowledge Graph entities and confidence scores?

An entity is a thing Google recognizes (person, product, organization, place, concept) with an ID that stays stable across languages and phrasings: Marie Curie is /m/053_d whether a page writes "Marie Curie", "Madame Curie" or "Maria Skłodowska". Google's model of a page is a set of these entities scored 0–100. Entity SEO means getting the entities you need onto that list with high scores, not just optimizing keyword strings.

How is this different from Google Cloud Natural Language API?

Cloud Natural Language extracts entities from text you supply and scores their relative salience. This API takes a URL and returns Google's own page-level entities with a 0–100 confidence score. An NLP model can only tell you what your text says; your text can be fine while Google's model of the page is not.

• URL in, not text in. Nothing to crawl, clean or truncate first.
• Google's own page-level entities. How Google classifies the live page, not how a model scores a block of text you extracted.
• A 0–100 confidence score. Comparable across pages and trackable over time, instead of relative salience.

	Entity SEO API (this actor)	Google Cloud Natural Language API	TextRazor	InLinks / WordLift
Input	A URL	Text you supply	Text or URL	URL / your CMS
Entities from	Google's own page understanding	Google NLP run on your text	TextRazor's model	Their own model
Score	0–100 confidence	Salience (relative)	Relevance	Varies
Entity IDs	Google KG / Freebase, resolved to names	MID / Wikipedia for some	Wikidata / DBpedia	Wikidata
Hero image + about-this-site	Yes	No	No	No
Pricing model	Pay per URL, no subscription	Usage-based; you crawl (~$0.005/URL)	From ~$200/mo	~$39–49/mo
Built for	Entity SEO / semantic SEO	General NLP	General NLP	SEO platform

Use those tools to extract entities from text you already hold. Use this one to see how Google reads a URL.

Why use the Entity SEO API?

• Any URL, including ones you don't own. Your pages, a competitor's, or every result on a SERP.
• Names, not codes. IDs resolved via Wikidata, no lookup step.
• Built for batches. URLs run in parallel, one JSON record each. A 50-page site section is one run.

What you get, and what you don't

A page has three layers: what it says, what it ranks for, and in between, what Google understood. This API measures the middle layer, nothing else.

You are getting:

• Google's interpretation, not a re-analysis of your text. From a real run: a page with "Exporter" in its headline scored 3/100 for export. The title tag hadn't caught up with the copy, and no text-analysis tool would have caught it.
• Competitor gaps. A scored list of concepts Google credits them for and not you.
• A pre-ranking feedback signal. Scores update on recrawl, usually well before rankings. Edit, re-run, and you know whether the change registered.

You are not getting:

• Keyword or demand data. It reports what Google credits, not what people search. Pick targets with keyword research; verify them here.
• A name for every entity. Some IDs have no public name anywhere and come back bare, occasionally high-scoring ones. The LLM trick in the FAQ resolves most.
• Page-level signal from a single URL. Site-level entities (your platform, brand, domain) score high on every page. Run three URLs (yours, a competitor's, a sibling from your own site) to tell page topics from site background.
• A fix for off-page problems. If the blocker is page type, authority or backlinks, a perfect entity profile won't rank the page.
• Entities for brand-new or thin pages. An empty list means Google has no model of that URL yet. An answer, not an error.

How to use the Entity SEO API

1. Open the actor in the Apify Console.
2. Paste one or more page URLs into the URLs field.
3. Click Start, then download the dataset as JSON, CSV, Excel, or HTML.

Entity extraction API example in Python

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("thodor/entity-seo-api").call(run_input={
    "urls": [
        "https://en.wikipedia.org/wiki/Marie_Curie",
        "https://www.nike.com/",
    ],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["url"], item["entity_count"], "entities")
    for e in item["entities"][:5]:
        print(f'  {e["score"]:>3}  {e.get("name") or e["entity_id"]}')

Entity extraction API example in JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('thodor/entity-seo-api').call({
    urls: ['https://en.wikipedia.org/wiki/Marie_Curie'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((i) => {
    console.log(i.url, i.entity_count);
    i.entities.slice(0, 5).forEach((e) => console.log(e.score, e.name || e.entity_id));
});

Input

Field	Type	Required	Description
urls	array of URLs	yes	The page URLs to analyze

That's the whole input. Bare domains work: https:// is assumed when the scheme is missing. Name resolution, hero image and about-this-site link are always included.

Output

Download as JSON, HTML, CSV or Excel, or read it as a spreadsheet in the Apify Console. One record per successfully analyzed URL. Failed URLs are never charged and never appear in the dataset; they're logged and saved with reasons to the FAILURES record in the run's key-value store.

{
  "url": "https://en.wikipedia.org/wiki/Marie_Curie",
  "entity_count": 34,
  "entities": [
    { "entity_id": "/m/053_d", "score": 100, "name": "Marie Curie", "description": "Polish-French physicist and chemist (1867–1934)" },
    { "entity_id": "/m/059x1", "score": 65, "name": "Nobel Prize", "description": "set of annual international awards" },
    { "entity_id": "/m/063wl", "score": 58, "name": "Pierre Curie", "description": "French physicist (1859–1906)" }
  ],
  "hero_image": "https://encrypted-tbn2.gstatic.com/images?q=tbn:ANd9Gc...",
  "about_this_site": "https://www.google.com/search?q=About+https://en.wikipedia.org/wiki/Marie_Curie&tbm=ilp"
}

Data fields

Field	Description
url	The URL that was analyzed
entity_count	Number of entities returned for the page
entities[]	Ranked entities, highest confidence first
entities[].entity_id	Google Knowledge Graph / Freebase ID (e.g. /m/053_d)
entities[].score	Confidence from 0 to 100
entities[].name	Human-readable name via Wikidata (null for the few IDs with no public mapping)
entities[].description	Short description, when a public mapping exists
hero_image	The page's hero image, when Google has one
about_this_site	Google's "about this site" link, when available

Use cases for entity SEO and semantic SEO

Entity SEO audit. Run your URL. If your target entity isn't near the top, or is missing, Google isn't convinced your page is about it. That's where the next edit goes.

Competitor content-gap analysis. Run both pages, compare lists. The table at the top is this exact analysis on two live pages: it turned "their page is somehow stronger" into "they score 63 on API, we score 15".

Semantic content optimization. Scores tell you what to strengthen and what to prune. The #6 page above scores 15 on API: if developers are its audience, it needs a visible API section. It also gets music at 21, which on a data tool is drift worth cleaning up.

Topical authority mapping. Run a whole site section and aggregate the entities: a map of the topics Google actually associates with your site, ready for a topical authority or content-cluster strategy.

Structured data and schema entity sourcing. The Knowledge Graph IDs are ready-made sameAs targets and schema entity references.

Entity score tracking. Schedule the actor and re-run after significant edits. Scores update on recrawl, usually well before rankings move: if the work is landing, your target entity climbs while your rank tracker is still flat.

Indexation and reprocessing monitoring. Any entities at all prove Google has crawled and classified the page (a site: query only proves inclusion). Run daily: the day an empty list turns into entities is the day Google first classified the page, give or take 24 hours, and the day the profile shifts is the day a recrawl landed. See the FAQ for the limits; the signal only works in one direction.

How to run a competitor content-gap analysis

Submit both pages in one run and diff on entity_id. The table at the top is this analysis: API (63 vs 15) and web crawler (37 vs nothing) are the trailing page's gap, and its content brief.

On the same platform as your competitor (a marketplace, a store)? Add a sibling page from it. Entities scoring high on every page of the domain are site background; ignore them.

The whole analysis is a short script:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("thodor/entity-seo-api").call(run_input={
    "urls": ["https://your-site.com/guide", "https://competitor.com/guide"],
})

pages = {i["url"]: i for i in client.dataset(run["defaultDatasetId"]).iterate_items()}
yours = pages["https://your-site.com/guide"]["entities"]
theirs = pages["https://competitor.com/guide"]["entities"]

covered = {e["entity_id"] for e in yours}
for e in theirs:
    if e["entity_id"] not in covered:
        print(f'{e["score"]:>3}  {e.get("name") or e["entity_id"]}')

To turn the gap into an update brief, paste the gap list and your draft into an LLM and ask which sections to add or expand. The scores tell it what to prioritize.

Entity SEO for AI Overviews and LLM visibility

AI Overviews, ChatGPT and Perplexity cite pages for what they're about at the entity level. So the check is simple: does Google credit your pages for your brand, your products, your core topics? If not, a citation is unlikely however good the writing.

Tips and advanced options

• Run your page and a competitor's together for comparable lists in one pass.
• Add a sibling page from your own site as a baseline. Entities scoring high on both of your pages are site-level, not page topics. Subtract them.
• Diff on entity_id, not names. The ID is stable across languages and phrasings.
• Schedule it daily. Google's cache refreshes about once a day; running more often just returns the cached model. Use Apify Schedules and Webhooks.

How much does the Entity SEO API cost?

You pay per URL analyzed. No subscription, no monthly minimum, and failed URLs are not charged. Apify's free plan includes $5 of platform credit every month, enough to trial comfortably; see the Pricing tab for rates.

FAQ

Is the Entity SEO API free to try? Yes, no credit card required. Apify's free plan includes $5 of monthly credit, enough for several hundred URLs.

What is entity SEO? Optimizing the things (entities) a page is about rather than only the keywords on it. Google understands pages as collections of entities, so being credited for the right ones with high confidence is how you rank for a topic rather than a single phrase.

Where do the entities come from? They're the Knowledge Graph entities Google associates with the page you submit, with Google's own 0–100 score for each. Google's classification of the URL, not a third-party re-analysis of the text.

How is this different from the Google Cloud Natural Language API? Cloud NLP extracts entities from text you supply and returns relative salience. This API takes a URL and returns Google's page-level entities with a comparable 0–100 score. See the table above.

What do the entity IDs mean? Stable Google Knowledge Graph / Freebase identifiers (like /m/053_d), mapped to names and descriptions via Wikidata.

Why do some entities come back without a name? Some IDs have no public name or Wikidata mapping; those come back bare with their score. A trick: give the IDs and the page text to an LLM and ask what each likely refers to.

Why does a page return no entities? Google doesn't associate entities with every URL; new, thin or low-authority pages often have none yet. An empty list means the request succeeded and Google has no classification for that URL. Outright failures are different: not charged, not in the dataset, listed with reasons in the FAILURES record. Input that can't be a URL at all is rejected up front the same way: skipped without charge and listed in FAILURES. Bare domains are fine; https:// is assumed.

Can this tell me when Google indexed my page? Not directly, the response carries no crawl or index date. But entities at all prove Google has crawled and classified the page, and a daily schedule turns that into a monitor: the run where an empty list becomes entities brackets first classification to within a day, and the run where the profile shifts brackets a recrawl. Two limits. The serving cache refreshes about once a day, so resolution is one day at best. And the signal is one-directional: a changed profile proves reprocessing, an unchanged one proves nothing, since a recrawl can land on the same classification.

Does this tell me which keywords to target? No. It reports what Google credits a page for, not what people search for. Pick targets with keyword research; use this to check whether Google's model matches, and to verify after a recrawl that edits registered.

Why do the same high-scoring entities appear on every page of my site? Your brand, platform or domain as Google knows it. Real, but background. Include a sibling page from your site and discount whatever both share.

Can I compare two pages? Yes. Submit both URLs in one run and diff the lists. That's the recommended competitor gap workflow.

Is this legal? The API returns publicly available entity classifications for URLs you choose to analyze; it does not extract private data. As with any SEO tooling, use the output to inform your own content decisions.