← ClickRadius Institute

The sameAs Property and Entity Linking

ClickRadius Institute · Published May 14, 2026

Somewhere on the web right now, your business exists as a dozen disconnected fragments: a website, a Google Business Profile, a LinkedIn page, a Yelp listing, an industry-directory entry, maybe a Wikidata item. To a human, these are obviously the same company. To a machine, they are candidate matches — and machines are trained to be suspicious of candidate matches. The sameAs property is the one line of code whose entire job is to remove that suspicion: a formal, machine-readable declaration that all of these fragments are one thing. This guide covers what sameAs actually does, what belongs in it (and what doesn't), working JSON-LD, and the quiet mistakes that undo its value.

What sameAs is, formally

The schema.org vocabulary — founded in 2011 by Google, Microsoft, and Yahoo, later joined by Yandex, precisely to standardize how websites describe things — defines the property in one sentence worth quoting exactly:

"URL of a reference Web page that unambiguously indicates the item's identity. E.g. the URL of the item's Wikipedia page, Wikidata entry, or official website."

— schema.org, definition of the sameAs property

Note the operative word: unambiguously. sameAs is not "related to," not "we also post here," not "similar." It is an identity assertion — this entity and the thing at that URL are the same real-world object. The concept descends from the semantic web's owl:sameAs, one of the oldest ideas in machine-readable knowledge: that identity links between databases are what turn isolated records into a web of data.

Where the vocabulary comes from — and why engines honor it

It is worth pausing on why a property defined by a standards body carries weight with commercial engines. Schema.org describes its own mandate plainly:

"Schema.org is a collaborative, community activity with a mission to create, maintain, and promote schemas for structured data on the Internet, on web pages, in email messages, and beyond."

— schema.org, project homepage

The collaboration is the point: the vocabulary was founded and is stewarded by the search engines themselves, which means markup written to it is markup written in the consumers' own native format. That lineage carried forward into the AI era intact — the retrieval and grounding systems behind AI answers parse the same JSON-LD, and structured declarations remain the lowest-friction way to hand any machine unambiguous facts. When we say sameAs is "one line of code," the honest expansion is: one line of code in the exact dialect every major knowledge system was built to read.

Why identity links matter more in the AI era

Entity resolution — deciding whether "Acme Plumbing" in one source is the same as "Acme Plumbing LLC" in another — is a genuinely hard problem that knowledge systems spend enormous effort on. Every resolution is probabilistic; every ambiguity costs confidence; and low-confidence entities get described vaguely or omitted from AI answers entirely, as we covered in What Is an Entity in AI Search?. sameAs lets you hand the machine the answer key instead of making it guess.

The stakes are practical. When an AI engine composes an answer about your category, it fuses evidence about each candidate from many sources. If your Yelp reviews, your LinkedIn presence, and your trade-press mention all resolve to one entity, that entity carries their combined weight. If resolution fails, your evidence splits across two or three phantom half-entities, each too weak to cite. Industry data suggests the majority of citation-driving signal lives off-site — but off-site signal only counts when it fuses, and sameAs is the primary on-site tool for making it fuse. According to Google's Organization structured-data documentation, providing identity properties helps Google "better understand" an organization and surface its details accurately — Google's characteristically restrained way of describing the reconciliation process.

What belongs in the array

Every URL in sameAs should pass one test: does this page clearly, exclusively refer to this entity? In practice, for a business:

What does not belong: category or search pages ("all plumbers in Mesa"), your own internal pages (those are yours already — use url), profiles of a different legal entity (your parent company, your founder — those get their own entities), dead profiles you abandoned years ago, and anything you would be embarrassed to have an engine treat as authoritative about you. A sameAs array is a curated identity, not a link dump; fifteen precise URLs outperform forty noisy ones.

Working JSON-LD: the canonical pattern

The full declaration lives once, on your entity home (homepage or About page):

{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "@id": "https://www.example.com/#organization",
  "name": "Acme Plumbing",
  "legalName": "Acme Plumbing LLC",
  "url": "https://www.example.com/",
  "logo": "https://www.example.com/assets/logo.png",
  "description": "Licensed residential and commercial plumbing company serving Mesa, Arizona since 2009.",
  "telephone": "+1-480-555-0100",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "1200 W Main St",
    "addressLocality": "Mesa",
    "addressRegion": "AZ",
    "postalCode": "85201",
    "addressCountry": "US"
  },
  "foundingDate": "2009",
  "sameAs": [
    "https://www.google.com/maps?cid=1234567890",
    "https://www.linkedin.com/company/acme-plumbing-mesa",
    "https://www.facebook.com/acmeplumbingmesa",
    "https://www.yelp.com/biz/acme-plumbing-mesa",
    "https://www.wikidata.org/wiki/Q00000000",
    "https://www.bbb.org/us/az/mesa/profile/plumber/acme-plumbing-0000-00000000"
  ]
}

Three details in that block do disproportionate work. The @id gives your entity a stable node identifier that every other schema block on your site can reference ("publisher": {"@id": "https://www.example.com/#organization"}) instead of re-declaring the organization with slight variations — re-declaration drift is a top source of self-inflicted ambiguity. The legalName alongside name resolves the "Acme Plumbing" vs "Acme Plumbing LLC" split before it happens. And the address block must match your directory listings character-for-character — sameAs asserts identity, but agreement of facts is what makes machines believe the assertion.

sameAs vs. url vs. @id: three properties people conflate

A quick disambiguation, because these three get mixed up constantly. url is the entity's own primary web address — your homepage. @id is the internal node identifier your own site's schema blocks use to reference the entity without re-declaring it — it never needs to resolve to a rendered page, it just needs to be stable and unique. sameAs is the outward-facing set of other places that identify the same entity. Putting your homepage in sameAs is redundant (that's url's job); putting external profiles in url is wrong (that's sameAs's job); and using a different @id string in different templates quietly splits your own site's entity in two. Three properties, three jobs, zero overlap.

Bidirectionality: the trust multiplier

A one-way claim is weak evidence — anyone can put anyone's Wikipedia page in a sameAs array. What resolution systems reward is reciprocity: your site points to the profile, and the profile points back to your site. Your LinkedIn page lists your website URL; your Google Business Profile links your domain; your Wikidata item carries an official website statement; your directory listings include your URL. Audit this deliberately: for every URL in your sameAs array, check that the destination links back. Each closed loop is a verified identity edge; a broken loop is merely an assertion. This site-profile-site triangle is the cheapest strong corroboration available to any business, because you control or influence both ends.

Person entities: the second sameAs

Organizations are not the only entities on your site. Founders and authors should carry their own Person markup with their own sameAs arrays — LinkedIn profile, professional registry entries, publication author pages, conference speaker pages. Google's quality framework explicitly cares about the reputation of content creators, and author-level entity linking is how that reputation becomes machine-readable. We treat this fully in its own article; for now, the rule is: same property, same test, applied to people.

The quiet failure modes

  1. Contradictory duplication. Organization blocks pasted into multiple templates over the years, each slightly different. Machines see three near-identical declarations and must guess which is current. Fix: one canonical block with @id, referenced elsewhere.
  2. Linkrot. Profiles get renamed, directories restructure URLs. A sameAs array pointing at 404s or redirects to generic pages degrades from evidence to noise. Audit twice a year.
  3. Wrong-entity links. Linking the founder's personal LinkedIn from the Organization's sameAs, or a namesake company's Wikipedia page ("close enough" is exactly wrong — this property exists to eliminate close-enough).
  4. Markup that contradicts the page. JSON-LD claiming an address the visible page no longer shows. Structured data is supposed to describe the page's content; divergence reads as either neglect or deception, and neither builds trust.
  5. Doing only this. sameAs is declaration, and declaration is one-third of entity authority — corroboration and association still have to exist to be linked. A perfect array pointing at empty profiles fuses nothing worth fusing. The full stack is laid out in our entity-authority playbook.

Measuring whether it worked

Entity linking has observable outcomes. After implementation and recrawl (allow weeks, not days): search your exact brand name — does a knowledge panel or accurate entity summary appear, with correct facts? Ask the five major AI engines "What is [your business]?" — do descriptions now match your canonical facts, without confusing you with namesakes? Are citations and recommendations attributing your reviews and coverage to you? These resolution outcomes are part of what an AI Readiness Score audits; declaration hygiene is one of the six categories ClickRadius scores and one of the classes of issue it can fix on-site automatically.

Set expectations honestly on timing: structured-data changes are read at recrawl, entity databases reconcile on their own schedules, and AI engines differ — retrieval-heavy systems like Perplexity reflect corrected web data fastest, while knowledge baked into model training updates only when models do. Judge the work over a quarter, not a weekend, and hold it to resolution outcomes rather than validator green checkmarks.

Frequently asked questions

What belongs in a sameAs array?

URLs that unambiguously identify the same entity: Google Business Profile, LinkedIn company page, active social profiles, Wikidata item, Crunchbase, authoritative directory listings, official registry entries. Every URL must pass the test: does this page clearly refer to exactly this entity?

Does sameAs directly improve rankings?

No one should claim that. It is a disambiguation and reconciliation signal: it helps systems fuse your scattered presence into one confident entity. The benefits — accurate AI descriptions, correct attribution, citation eligibility — flow from resolution, not from the property itself.

Where should sameAs markup live — every page or one page?

Declare the full Organization entity with the complete array once, on your entity home (homepage or About), under a stable @id. Other pages reference that @id rather than repeating the block. Consistency at one stable URL beats repetition with drift.

Next step: your structured-data and entity-linking hygiene is measurable in minutes. Get your free AI Readiness Score — it audits declaration, corroboration, and citation-readiness across five AI engines — or see plans to have ClickRadius implement and maintain the whole layer.

Related from the Institute