How to Identify Entities in Your Content Using Schema Markup

7bb6d7f4177f5ea11fde1ce5e40a3e77

Written By: Ishan Makkar Last Updated: November 10, 2026

How to Identify Entities in Your Content Using Schema Markup

TL;DR: Entities are the real-world things a page talks about: people, products, companies, places, concepts. Schema markup gives each one a type, a stable identifier, and links to external knowledge bases so search engines stop guessing. The process is to inventory what a page mentions, separate proprietary entities from public ones, confirm which already exist in the knowledge graph, then define and connect them with JSON-LD.

Search engines use the words and context on a page to understand what it is about, but some names and concepts can still be ambiguous. Structured data provides additional context by identifying the entities discussed on a page, their types, and their relationships. For example, identifying “Mercury” as a planet rather than a chemical element makes the page’s subject more explicit to search engines.

This guide covers what an entity is, why search engines and AI assistants depend on them, and a practical method for spotting the entities already sitting inside existing content.

What Are Entities in Schema Markup?

An entity is one distinct, unambiguous thing. It exists apart from the words used to describe it. Cristiano Ronaldo is the same entity whether a page says “CR7,” “Ronaldo,” or “the Portuguese forward.” When an entity is defined in schema, it gets a type from the Schema.org vocabulary, a machine-readable identity, and properties that describe it.

Schema.org is the shared vocabulary the major search engines agreed to back in 2011. It includes hundreds of types such as Person, Product, Organization, Article, and LocalBusiness, along with the properties each one accepts.

Keywords Describe, Entities Identify

The two concepts get mixed up constantly, so a side-by-side view helps.

Keyword Entity
What it is A string of text people search for A real thing with a stable identity
Ambiguity High (“jaguar” = animal, car, OS) None once tied to an identifier
How Google stores it As text in an index As a node in the knowledge graph
Sensitive to wording Yes No, synonyms resolve to one node
Role in markup Lives in copy, headings, alt text Declared with a type, @id, and properties

How Entities Feed the Knowledge Graph

Google’s knowledge graph is an enormous database of entities and the connections between them. When a page’s structured data references a known entity, it provides search engines with additional context about the subject. An accurate external reference can help clarify which entity the page describes, although it does not guarantee that Google will connect the page’s information to an existing Knowledge Graph entry.

For example, a dental practice can use consistent Organization information across its website and other official business profiles. This helps maintain a consistent description of the business and gives search engines additional context about its identity.

Clear entity descriptions give search engines additional context about a page’s subject and the relationships between the things it discusses. This supports better content understanding, but structured data does not guarantee faster indexing, broader query visibility, or higher rankings.

Why Entity Definition Matters for Rich Snippets, CTR, and AI Search

Clear entity definitions help search engines connect the subjects in your content to relevant search features and interpret their significance. This can affect how your pages appear in search results and how their information is presented in AI-generated answers.

Disambiguation Cuts Out Guesswork

Search engines are good at pulling entities out of raw text through natural language processing. A software company called Phoenix could be confused with the city or other entities with the same name. Using the Organization type, its official website, and a stable @id helps identify the company in structured data.

If an accurate external reference identifies that same organization, a sameAs link can provide additional context. Its software products should be described as separate entities using an appropriate type, such as SoftwareApplication.

Rich Snippets Require Well-Typed Entities

Search enhancements such as product prices, review ratings, and event information can be enabled through supported structured data types. Google requires the appropriate markup, required properties, and compliance with its content guidelines for a page to become eligible. However, using the correct type does not guarantee that Google will display a rich result.

Rich results can make a search listing more informative and visually prominent, which may influence click-through rates. However, the impact varies by search feature, query, and audience. Adding structured data does not guarantee higher CTR or additional traffic.

AI Answers Cite What They Can Verify

AI search tools use different systems to retrieve and understand information from websites. Structured data can provide additional context about a page’s author, publisher, and subject, making those relationships explicit. However, adding entity markup does not guarantee that a page will be selected or cited in AI-generated answers. Accurate content, clear information, and sound technical SEO remain important.

This is the point at which semantic SEO and technical SEO become the same job: what helps Google understand a page also helps a language model decide it is worth quoting.

How to Identify Entities in Content: A Practical Walkthrough

Finding entities across 40 service pages and 200 blog posts is the real work. The method below is the heart of how to identify entities in content and scales from one page to a full audit.

Step 1: Inventory the Named Entities on the Page

Read the page and list every proper noun and every distinct concept it relies on. A post about running shoes for flat feet might contain the publishing brand, the author, three shoe models, two manufacturers, the condition “flat feet,” the concept of overpronation, and a quoted podiatrist. All of these are named entities or candidates for one.

Do not filter yet. A spreadsheet with entity name, mention count, and page section is plenty.

Step 2: Separate Proprietary Entities From Public Ones

Sort the list into two groups. Public entities already live in external databases: Nike, the Wikipedia article on flat feet, a published researcher. Proprietary entities belong to the business alone: its products, staff, locations, service packages, internal terms.

The split matters because the two groups are handled differently. For public entities, look for reliable external references that identify the same person, organization, product, or concept. Use sameAs when an accurate reference is available. Proprietary entities, such as a company’s own products, staff, locations, or services, can be identified using stable @id values based on your website’s URLs.

Important entities may have dedicated pages, but not every entity needs one or an external knowledge graph identifier.

Step 3: Check What Google Already Knows

For each public entity, confirm a stable external identifier exists. Two useful resources are Wikidata, which assigns Q-numbers to its items, and Google’s Knowledge Graph Search API, which can return matching entities, their types, descriptions, and identifiers. These resources can help you check whether an external entity reference exists and whether it matches the subject you are researching.

Reading the API Result

A result with the expected name, type, and description can indicate a relevant match. Google’s resultScore shows how well the result matches the search criteria; it should not be treated as a confidence percentage or definitive confirmation of identity. A low or missing result means the entity is obscure, the name is ambiguous, or Google files it under a different label. Each outcome is useful before any JSON-LD gets written.

Step 4: Score Relevance

A page can mention twenty entities and be about two. If the intended main topic scores low, the text is not communicating its own subject, and fixing the copy comes before fixing the markup. The entities worth marking up are the ones that answer “what is this page fundamentally about” plus the ones that establish who stands behind it.

How to Add Entities to Schema Markup With JSON-LD

JSON-LD is Google’s recommended format because it sits in one script block, leaves the visible HTML alone, and is easy to generate automatically. Every step in how to add entities to schema markup below assumes JSON-LD.

Pick the Most Specific Type

Use the narrowest type that honestly fits. A dentist’s office is a Dentist, not a generic LocalBusiness. A how-to article is a HowTo or TechArticle, not a WebPage. Specific types carry specific properties, and rich result eligibility is tied to exact types.

Give Every Entity a Stable @id

The @id property is the most underused piece of entity schema markup. It assigns a permanent URI so the entity can be referenced from anywhere on the site. A common pattern is the canonical URL plus a fragment:

https://example.com/#organization,
https://example.com/about/jane-doe/#person,
https://example.com/products/trail-runner-x/#product.

Once an @id exists, other pages point to it instead of redefining the entity. The author block on 200 posts becomes a two-line reference to one canonical Person. Google sees one entity instead of 200 near-duplicates.

Connect Outward With sameAs

The sameAs property is how entity linking happens in practice. It states that the entity described here is the same one described at these other URLs. For an organization, that usually means Wikipedia, Wikidata, LinkedIn, Crunchbase, and official social profiles. A Person named “Jane Doe” with a sameAs to a specific Wikidata item cannot be confused with any other Jane Doe.

Express Relationships Through Nesting

Entity relationships in schema markup are declared through properties that accept other entities as values. An Article has an author (Person) and a publisher (Organization). A Product has a brand and a review with its own author. Use consistent @id values for entities that need to be referenced or reused across your website. Simple nested descriptions can also be represented without a separate @id when there is no need to reference that entity elsewhere in the graph.


{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://example.com/#organization",
      "name": "Example Running Co.",
      "sameAs": ["https://www.wikidata.org/wiki/Q000000"]
    },
    {
      "@type": "Person",
      "@id": "https://example.com/about/jane-doe/#person",
      "name": "Jane Doe",
      "sameAs": ["https://www.linkedin.com/in/janedoe"]
    },
    {
      "@type": "Article",
      "headline": "Best Running Shoes for Flat Feet",
      "author": {"@id": "https://example.com/about/jane-doe/#person"},
      "publisher": {"@id": "https://example.com/#organization"},
      "about": {
        "@type": "MedicalCondition",
        "name": "Flat feet",
        "sameAs": "https://www.wikidata.org/wiki/Q1128069"
      }
    }
  ]
}

The about property deserves attention. It tells engines what the page’s central subject is, and pointing it at an external identifier ties the article into the wider web of data on that topic.

Common Mistakes When Defining Entities

Google requires structured data to match visible content. An author who did not write the piece invites a manual action.

1. Skipping @id – Without identifiers, every mention is a fresh, unconnected object the engine has to reconcile on its own.

2. Wrong sameAs targets – A link to a disambiguation page or the wrong “John Smith” actively misleads the knowledge graph.

3. Vague types – Thing and CreativeWork are valid and nearly useless.

4. Letting markup drift – Products get renamed, and staff moves on. Stale entity data is worse than none, which is the strongest case for generating markup from one source of truth instead of hand-coding it page by page.

Validating Entity Markup

Google’s Rich Results Test checks eligibility for Google’s specific enhancements. The Schema Markup Validator checks syntax against the full Schema.org spec, including types Google does not render. Run both.

For websites managing structured data at scale, establish a regular review process. Check that important @id values remain consistent, sameAs references still identify the correct entities, and the markup accurately reflects the visible content. Also monitor supported rich result reports in Google Search Console and investigate any errors or changes.

Conclusion

Identifying entities is mostly a reading exercise: list what a page is about, decide which things are proprietary and which are public, and confirm which already exist in the knowledge graph. Defining them is a structure exercise: pick the specific type, assign a stable @id, connect outward with sameAs, and nest related entities so their relationships are explicit.

Done consistently, this turns a website into a coherent, machine-readable account of a business, which is what search engines and AI assistants need before they can rank, enhance, or cite anything with confidence.

Frequently Asked Questions

What does @id do in JSON-LD?

It assigns a stable URI to an entity so it can be defined once and referenced across the site, which is how internal entity linking works.

When should sameAs be used?

Whenever an entity already exists in an external knowledge base such as Wikidata, Wikipedia, LinkedIn, or Crunchbase. It disambiguates the entity and helps the knowledge graph merge records.

Can entity markup help with AI search?

Entity markup provides additional context about the people, organizations, and subjects described on a page. It supports clearer content representation, but adding structured data does not guarantee citations in AI-generated answers. Accurate, helpful content and sound technical SEO remain important for search visibility.

Do entities need to be visible on the page?

Structured data must reflect content that is actually present. Entities can carry more detail than the visible text, but they cannot describe things the page does not contain.

Does adding entities guarantee rich snippets?

No. Rich snippets depend on an eligible type with all required properties, and Google decides case by case. Accurate entity markup makes a page eligible; it does not force a result.

Google logo

“The agent doesn’t return ten blue links… it pulls from structured business data… to complete the job.”

- Sundar Pichai

JSON Schema App automatically detects, fixes, and manages structured data to help search engines and AI understand your website, improving visibility and rich results.

Try our Other Product

Website Speedy is a SaaS-based website optimization tool that instantly reduces website loading times.

This tool allows you to optimize images automatically on any platform, including Wix, Shopify, BigCommerce, and more.