---
title: "sameAs in Schema.org: How Machines Identify Who or What You Mean"
description: "Excerpt: sameAs is not an arbitrary collection of external links. The Schema.org property connects a person, organization, or other entity with pages that unambiguously represent the same identity."
url: https://johannesbecht.com/blog/sameas-schema
date: 2026-07-19
modified: 2026-07-19
author: "Johannes Becht"
image: https://johannesbecht.com/wp-content/uploads/2026/07/sameAs-Schema-Code-Structured-Data.png
categories: ["Marketing Blog"]
tags: ["SEO Blog"]
type: post
lang: en
---

# sameAs in Schema.org: How Machines Identify Who or What You Mean

When I first encountered `sameAs` in structured data, the property seemed fairly unremarkable. You add LinkedIn, perhaps include Instagram or an author profile, and then return to the supposedly more important parts of the markup.

However, `sameAs` is not quite as insignificant as it appears.

Every URL entered there makes a specific statement: the entity described by the schema node is the same entity represented at that other URL.

This is more than an external link or a reference to further information. `sameAs` is intended to help machines connect different representations of the same person, organization, brand, publication, or thing.

That can be relevant to Google and Bing, but also to [knowledge graphs](https://johannesbecht.com/blog/personal-knowledge-graph), databases, web crawlers, and AI-powered search systems. The property is nevertheless neither a guaranteed ranking factor nor a magic switch that suddenly makes a person appear more frequently in ChatGPT or Perplexity.

Unfortunately, the property is not called `pleaseUnderstandWhoIAm`. Conceptually, however, that is fairly close to what it does.

## What `sameAs` Really Means

[Schema.org defines `sameAs` as the URL of a reference page](https://schema.org/sameAs) that unambiguously indicates the identity of the item being described. Schema.org gives Wikipedia pages, Wikidata entries, and official websites as examples. The property belongs to `Thing` and can therefore theoretically be used with all Schema.org types derived from it.

These include, for example:

- `Person`
- `Organization`
- `Brand`
- `Product`
- `Place`
- `Event`
- `CreativeWork`

The fact that a property is technically available does not mean that it is useful in every possible situation. The decisive part of the definition is easy to overlook: the referenced page must identify the entity **unambiguously**.

A newspaper article may discuss a person in detail, mention their profession, and include several quotations. Nevertheless, that article is usually not an identity page for the person. It is a document **about** them.

An official author page, personal website, or clearly attributable LinkedIn profile represents the person more directly.

`sameAs` should therefore not be used to say:

> I am mentioned on this page.

The intended statement is closer to:

> This URL represents the same entity described by this schema node.

This distinction is not merely semantic nitpicking. If an ordinary mention is marked as `sameAs`, the markup claims a stronger relationship than the pages actually have.

## Why Machines Need Help Resolving Identity

People often recognize identities through context. We see a name, photograph, employer, and job title and can usually infer which person is being discussed.

A machine initially receives separate signals:

- a name,
- a URL,
- visible text,
- structured data,
- internal connections,
- external profiles,
- mentions on other domains.

These signals may be clear, but they do not have to be.

Several people can share the same name. A company may appear under its brand name, full legal name, and several abbreviations. After a rebrand, both old and new names may continue to circulate online.

The underlying problem is often called **entity resolution**. A system attempts to determine whether several records, pages, or references describe the same real person, organization, or object.

`sameAs` provides an explicit connection that can support this process. It does not replace the surrounding information, however. A name, image, official website, description, and consistent profile details are still needed to make the relationship plausible.

An incorrect connection does not become correct simply because it is written in JSON-LD. Structured data only expresses the statement in a format that machines can process more easily.

## The Role of `sameAs` for Google, Bing, and AI Systems

Schema.org is not a Google-only format. The vocabulary was developed to embed structured information into websites so that search engines and other applications can process content and relationships more effectively.

Google documents several concrete uses. [Within `Organization` markup, `sameAs` can reference external profiles](https://developers.google.com/search/docs/appearance/structured-data/organization), including social-media and review-platform pages. Multiple URLs are permitted. Google also describes organization structured data as a way to help it understand and distinguish an organization from others.

For [articles](https://developers.google.com/search/docs/appearance/structured-data/article), Google can use both `author.url` and `author.sameAs` to identify an author more precisely. Google additionally recommends `ProfilePage` markup for internal author pages.

Bing also processes structured data and supports Schema.org in JSON-LD. Microsoft describes structured data as information that can help Bing understand the content and relationships on a page. Microsoft also warns against placing false or misleading claims in markup that users cannot see.

Less is publicly documented about AI-powered search and answer systems.

OpenAI states that `OAI-SearchBot` crawls websites so that they can appear in ChatGPT search features. According to OpenAI, pages that block this bot will not be shown in ChatGPT Search.

Perplexity describes `PerplexityBot` as a crawler used to discover and link websites in Perplexity search results. The company recommends allowing the bot if a website should be eligible to appear in those results.

Anthropic gives Claude access to web search, allowing the system to research current webpages and use them as sources. Its public documentation does not describe any special handling of `sameAs`.

None of these AI providers publicly confirms that merely adding `sameAs` directly leads to more mentions, higher placement, or more frequent citations.

Its potential value lies elsewhere. Web-connected AI systems must also decide which person a name refers to, which domain is official, and whether two profiles belong to the same organization. A consistent schema graph can offer additional machine-readable clues, provided the system reads and uses them.

`sameAs` is therefore not a generative-engine-optimization shortcut. It is part of clean entity data.

## The Difference Between `sameAs`, `url`, `@id`, and Similar Properties

Several structured-data properties can appear to perform the same function because they contain URLs or identifiers. In practice, they serve different purposes.

| Element | Purpose |
| --- | --- |
| `@id` | Gives a schema node a stable, reusable identifier |
| `url` | Points to the entity’s primary or official webpage |
| `sameAs` | Connects the entity with other pages representing the same identity |
| `mainEntityOfPage` | States that an entity is the principal subject of a particular page |
| `identifier` | Contains a formal identifier such as an ISBN, GTIN, or UUID |
| `rel="canonical"` | Identifies the preferred URL among duplicate or similar documents |
| `hreflang` | Connects language or regional variants of a page |

`**@id**`** as an internal entity identifier**

`@id` should not be confused with an ordinary clickable profile URL. It gives a JSON-LD node an unambiguous identifier that other parts of the graph can reference.

A person could, for example, receive the following `@id`:

```
"@id": "https://example.com/about/#person"
```

The `#person` fragment does not have to open a separate visible page. It acts as the identifier for the person within the data model.

When that person is later listed as the author of an article, the article can point to the same `@id`. This prevents each page from generating a new and isolated Person node.

`**url**`** as the primary page**

`url` normally points to the central webpage associated with the entity.

For a person, this might be a personal About page. For an organization, it is usually the official company website. Google explicitly describes `url` in Organization markup as the organization’s website and as information that can help identify it unambiguously. ([Google Search Central](https://developers.google.com/search/docs/appearance/structured-data/organization))

`**sameAs**`** as an identity connection**

`sameAs` adds other pages that clearly represent the same entity. For a person, those might include LinkedIn, Wikidata, or an official publisher author profile.

The property replaces neither `@id` nor `url`. A well-constructed entity node can contain all three.

`**mainEntityOfPage**`** as a topical relationship**

A page can mainly be about a person or company without being that entity’s official representation.

A company profile published in a magazine might treat the company as its main entity. The article does not therefore become a `sameAs` page for the company.

`**identifier**`** as a formal identifier**

Schema.org provides `identifier` for values such as ISBNs, GTINs, UUIDs, and other formal identification systems. A LinkedIn profile is not such an identifier and therefore generally does not belong in that field. ([Schema.org](https://schema.org/identifier))

**Canonical and **`**hreflang**`** as document relationships**

A canonical tag helps search engines choose a preferred URL from several identical or highly similar documents. It does not connect people or organizations. ([Google Search Central](https://developers.google.com/search/docs/crawling-indexing/consolidate-duplicate-urls))

`hreflang`, by contrast, identifies language or regional versions of a page. The English and French versions of an About page should therefore not be linked with `sameAs` merely to express that they are translations. They can still reference the same Person node and the same `@id`.

The simplest rule of thumb is:

> Canonical and `hreflang` organize documents.`@id`, `url`, and `sameAs` organize entities.

## Which URLs Belong in `sameAs` – and Which Do Not

A URL is suitable when it represents the same entity so clearly that there is little room for interpretation.

For a person, appropriate candidates may include:

- an official personal website,
- a clearly attributable social-media profile,
- an author profile at a newspaper or publisher,
- a Wikidata or Wikipedia entry,
- an official profile in a relevant professional database.

For an organization, suitable pages may include official corporate profiles, business directories, review platforms, or knowledge databases. Google explicitly names external social-media and review profiles as possible values for `Organization.sameAs`.

The platform alone does not make a URL suitable. The profile should clearly show who it belongs to. Matching names, images, job details, company information, and links back to the official website can strengthen the identification.

The following pages normally do not belong in `sameAs`:

- individual press articles about the entity,
- guest articles written by the person,
- general employer or client websites,
- internal search-result pages,
- category pages containing several people,
- pages where the name is only mentioned,
- profiles belonging to similarly named people or companies.

An author profile can represent a person’s identity. An individual article by that author primarily represents an `Article` or `BlogPosting`.

Similarly, an employer’s homepage primarily represents the employer. A dedicated employee profile may, however, clearly represent the person.

Extra care is needed with parent companies, brands, and subsidiaries. A subsidiary is not automatically the same entity as its corporate group. A product brand is not necessarily identical to the company that owns it.

One practical question resolves many borderline cases:

> Would an independent person open this URL and immediately conclude that it represents exactly the same entity?

When the answer is only “more or less,” `sameAs` is probably not the right property.y.

## How to Implement `sameAs` Cleanly

Before collecting external profiles, determine the central entity being described. Is it a person, organization, brand, or creative work?

The entity then needs a stable `@id` and a primary `url`.

A simple Person node might look like this:

```
{
  "@context": "https://schema.org",
  "@type": "Person",
  "@id": "https://example.com/about/#person",
  "name": "John Doe",
  "url": "https://example.com/about/",
  "image": {
    "@type": "ImageObject",
    "url": "https://example.com/images/john-doe.jpg"
  },
  "jobTitle": "SEO Consultant",
  "sameAs": [
    "https://www.linkedin.com/in/john-doe/",
    "https://example-publisher.com/authors/john-doe/",
    "https://www.wikidata.org/wiki/Q123456"
  ]
}
```

In this example, the About page is the primary `url`. The other profiles appear under `sameAs` because they represent the same person on other platforms.

When the person is used as the author of a blog post, a second independent Person node is unnecessary:

```
{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "@id": "https://example.com/blog/sameas-schema-org/#article",
  "headline": "sameAs in Schema.org: How Machines Identify Who or What You Mean",
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/sameas-schema-org/"
  },
  "author": {
    "@type": "Person",
    "@id": "https://example.com/about/#person"
  },
  "publisher": {
    "@type": "Organization",
    "@id": "https://example.com/#organization"
  }
}
```

The article now references the same person already described on the About page. This is cleaner than creating a new author node with slightly different details for every publication.

For a practical implementation, I would follow this order:

1. Identify the central entity.
2. Define a permanent `@id`.
3. Select the official page as `url`.
4. Collect only unambiguous identity profiles for `sameAs`.
5. Inspect markup already generated by the theme or SEO plugin.
6. Consolidate duplicate Person or Organization nodes.
7. Validate the rendered JSON-LD.
8. Confirm that relevant search-engine and AI crawlers can access the page.

Many WordPress websites already generate schema graphs through their theme, Rank Math, Yoast, or another plugin. Adding a separate full JSON-LD block may unintentionally create a second version of the same person or organization.

Before adding custom code, determine whether the existing node can be extended instead.

The syntax can be checked with the Schema Markup Validator. Google’s Rich Results Test focuses primarily on markup supported for specific Google search features. A valid `sameAs` property may therefore not appear as a separate enhancement in the tool.

## Common Mistakes and Realistic Limitations

The most common mistake is treating `sameAs` as a social-link collection. A theme offers fifteen profile fields, so fifteen profiles are added.

Quantity is not a quality signal.

Each additional URL represents another identity claim that must remain accurate, current, and consistent. Three clear profiles are often more useful than twelve weak or outdated connections.

Another mistake is selecting pages based on domain authority. An article on a famous news website does not become an identity page simply because the domain is trusted.

Contradictory schema nodes can also create unnecessary ambiguity. A plugin may create the same person under `/#person`, a custom snippet may use `/about/#author`, and a third tool may output only the name without an identifier. That produces several separate nodes. Search systems may attempt to merge them, but the markup itself does not give them a clean shared reference.

Information in JSON-LD should also match the visible page content. Bing explicitly warns against placing false or misleading information in markup that users cannot see.

If the schema lists ten professional roles, several companies, and numerous profiles while the visible About page contains only a name, the website is presenting two different versions of itself: one to people and another to parsers.

`sameAs` can help machines connect existing identity signals. It cannot compensate for missing authority, weak content, contradictory business information, or an absent external presence.

It is infrastructure, not an amplifier.

## Conclusion: Precision Matters More Than the Length of the Array

In JSON-LD, `sameAs` looks like a small list of URLs. Semantically, however, it makes a strong statement about the identity of a person, organization, or thing.

The property should therefore not be filled according to how many profiles can be found. What matters is which pages truly and unambiguously represent the described entity.

Google documents concrete uses for identifying authors and organizations. Bing also uses structured data as an aid to understanding. ChatGPT, Perplexity, and Claude can access web content, but none publicly confirms that `sameAs` functions as an independent visibility or ranking switch.

That does not make the property unimportant. It simply requires a realistic interpretation.

A clean entity graph gives machines a precise answer to a fundamental question without promising more than the available evidence supports:

**Who or what is actually being described here?**