How to Add sameAs Links in WordPress (the Right Way)

sameAs is a short property with an outsized job: it's the line in your schema that tells Google and AI systems "the entity described on this page is the same entity you already know about over here." Get it right and you hand search engines a set of confirmed reference points for who you are. Get it wrong (and this is where almost every WordPress site trips) and you either waste the signal or actively confuse it.

This guide covers exactly which links belong in sameAs, which ones don't (this is the part most tutorials skip), how to structure it correctly in JSON-LD, and how to add it in WordPress without creating the inconsistency that undermines the whole point. If you've already added a sameAs array to your Organization schema, there's a good chance part of it is doing nothing, or worse, working against you. Let's fix that.

What does the sameAs property actually do?

sameAs links an entity in your structured data, your Organization, your Person, your Product, to its representation on other websites you don't control, so a machine can confirm it's looking at the same real-world thing.

Google's own documentation defines it plainly: it's the URL of a page on another website with additional information about your organization, most commonly your organization's profile page on a social media platform or a review site, and Google explicitly says you can provide multiple sameAs URLs. Google's general structured-data documentation goes further, noting Google can make broader use of the property beyond any single documented feature: it's one of the properties Google treats as generally useful for understanding what a piece of content or an entity refers to, independent of any specific rich result.

That's the important distinction to hold onto: sameAs isn't tied to a visual rich result the way AggregateRating or startDate are. There's no "sameAs snippet." Its job is disambiguation and entity resolution: helping Google (and increasingly, AI systems) connect the dots between "this website" and "this known thing," which feeds Knowledge Panel eligibility and gives AI systems a corroborated identity to reason about rather than a name they have to guess at.

That also explains why it's the highest-leverage entity property available to you. Most schema properties describe an attribute of your entity: its address, its founding date, its price. sameAs does something different: it connects your entity to independent confirmation that it's real, distinct, and consistently represented elsewhere. That external corroboration is exactly the kind of signal a single self-declared fact can't provide on its own.

Why is sameAs the most misused property in schema?

Because most guides tell you to "add your social links" and stop there. That instruction, followed literally, produces exactly the shallow, inconsistent, sometimes-wrong sameAs arrays that show up across WordPress sites everywhere. The property gets treated as a checkbox instead of what it actually is: a claim that these specific URLs represent the same entity as this page, which only holds up if it's true, current, and consistent.

Here's what "misused" looks like in practice, because naming it precisely is what lets you avoid it:

Linking to profiles that don't match. A sameAs link to a LinkedIn page under a slightly different company name, an old logo, or a stale description isn't confirming your entity: it's introducing doubt about whether it's really the same one. Google's own guidance on quality expects information tied together across these signals to be genuinely trustworthy and consistent, and a mismatched profile undermines that.

Linking to pages you don't control. A news article that mentions your brand, a directory listing someone else created, a Wikipedia disambiguation page: these might be legitimate things to reference elsewhere, but they're not sameAs material. The property is for your own authoritative profiles: pages where you (or your organization) are the subject and the content is something you control or verified.

Linking to search results or category pages instead of a specific profile. A link to a generic marketplace search results page, or a directory's category listing, doesn't point at your specific profile: it points at a page that changes and isn't uniquely about you.

Padding the count. Treating sameAs as a place to stack as many URLs as possible, including thin, abandoned, or barely-branded profiles created solely to have something to list. A handful of genuine, consistent, actively maintained profiles is worth more than a dozen thin ones: quantity isn't the signal, corroboration is.

Letting it go stale. A rebrand, a domain change, a platform your business no longer uses, and the old sameAs link just sits there, now pointing at something outdated or dead. An entity profile that was accurate at launch and never revisited slowly drifts out of truth, and sameAs is one of the properties most prone to this because the linked profiles live entirely outside your CMS, where you're less likely to notice they've changed.

Using it for internal pages. sameAs is for other websites. Linking to your own site's about page or another page on your own domain isn't what the property is for, that relationship is expressed through your url and internal linking, not sameAs.

Every one of these is an easy mistake to make once, and an easy one to leave uncorrected for years, because nothing visibly breaks when sameAs is wrong. There's no error message. The signal just quietly does less than it could, or actively muddies your entity instead of clarifying it.

Which links actually belong in sameAs?

The test is simple: does this URL point to a page, hosted elsewhere, where you (or your organization) are unambiguously the subject, and that you genuinely control or can verify? If yes, it belongs. If you're stretching to justify it, it doesn't.

For an Organization, the strongest candidates, roughly in order of how much corroborating weight they carry:

• Wikidata: your organization's entry in Wikidata, if you have one. This is the single highest-value sameAs link available to most brands, because Wikidata is a structured knowledge base that search engines and AI systems actively consult as a source of truth about entities, and it doesn't carry Wikipedia's notability bar.
• Wikipedia: if your organization has a genuine, notability-compliant article. Don't create one to check this box; Wikipedia's standards are real, and a manufactured article gets removed and looks manipulative.
• LinkedIn company page
• Crunchbase profile
• Official X, Facebook, Instagram, YouTube, TikTok accounts: whichever platforms you're genuinely, actively present on
• GitHub organization, if you're a software company or maintain open-source projects
• Industry-specific authoritative directories: Chamber of Commerce listings, professional association member pages, and similar, where you control or verify the listing
• Your Google Business Profile, for a local or physical business

For a Person (a founder, an author, an executive modeled as their own entity), the same logic applies at the individual level:

• LinkedIn personal profile
• Personal or professional Wikidata entry, if one exists
• ORCID, for academic or research authors
• Official X, Instagram, or other social accounts genuinely run by that person
• Their author page on other publications they've genuinely written for

Notice what's not on either list: your own homepage, generic app-store search results, aggregator "mentions" pages you don't control, or a Google search results page for your brand name. None of those pass the test above.

A quick honest note on quantity

Because sameAs scales so easily to "just add more links," it's worth being direct: breadth is the weakest lever here, and depth is the strongest. Five profiles that are genuinely yours, actively maintained, and consistent with your on-site identity do more for entity resolution than fifteen that include a few dead accounts and a directory listing you forgot you had. If you're deciding whether to add a marginal profile, ask whether it's actively maintained and unmistakably about you, not whether it gets you to a bigger number.

A complete, correct example

Here's a well-formed Organization block with a properly constructed sameAs array, following Google's documented structure:

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Bright Coffee Roasters",
  "url": "https://brightcoffee.example",
  "logo": "https://brightcoffee.example/images/logo.png",
  "description": "Bright Coffee Roasters roasts single-origin specialty coffee sourced directly from farmers.",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q000000",
    "https://www.linkedin.com/company/brightcoffeeroasters",
    "https://www.crunchbase.com/organization/bright-coffee-roasters",
    "https://x.com/brightcoffeeroasters",
    "https://www.instagram.com/brightcoffeeroasters",
    "https://www.facebook.com/brightcoffeeroasters"
  ]
}

Three things to notice. First, every URL points to a specific profile page, not a homepage, a search result, or a category listing. Second, the name and branding on each of those profiles would need to match "Bright Coffee Roasters" consistently, that's not visible in the JSON-LD itself, but it's the condition that makes the markup honest. Third, sameAs takes an array, so there's no limit on how many genuine profiles you list, the discipline is in what qualifies, not in a hard cap.

Here's the same principle applied to a Person, connecting a founder to their own verified profiles:

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Maria Santos",
  "jobTitle": "Founder",
  "worksFor": {
    "@type": "Organization",
    "name": "Bright Coffee Roasters",
    "url": "https://brightcoffee.example"
  },
  "sameAs": [
    "https://www.linkedin.com/in/mariasantos",
    "https://x.com/mariasantos"
  ]
}

Connecting a founder as a real Person entity, with their own sameAs, does double duty: it strengthens the credibility of the individual and it enriches the organization's entity by linking it to a recognized, verifiable person. We cover building strong Person entities, for founders, authors, and credentialed experts, in more depth in our Person and author schema guide.

The consistency requirement most guides skip

This is the part that separates a sameAs array that actually works from one that's just present. Every profile you link needs to agree with your on-site identity, same name (or a clearly stated alternateName if there's a legitimate variation), same logo, same core description. Google recommends using the same name and alternateName that you're using for your site name, and that consistency principle extends naturally to every profile you're claiming as the same entity.

An inconsistent network doesn't just fail to help, it actively works against you. If your LinkedIn page says "Bright Coffee Roasters Ltd," your Instagram bio says "Bright Coffee Co.," and your schema says "Bright Coffee Roasters," you've made it harder, not easier, for a machine to confirm these are the same organization. Each mismatch is a small dose of doubt injected into a signal whose entire purpose is removing doubt.

The practical fix is an audit, not a one-time setup. Periodically open each URL in your sameAs array and confirm: is it still live, is the name still consistent, is the logo current, does the page still genuinely represent you? Profiles decay quietly, a rebrand updates your website instantly but often lags on LinkedIn for months, and nobody re-checks Crunchbase after the initial setup. A sameAs array is a living list, not a launch task.

Does sameAs help with AI search?

Yes, and increasingly this is the more practical reason to get it right. AI systems reason about entities rather than keywords, when ChatGPT, Perplexity, or Google's AI features are deciding whether to trust and surface a source, they're asking whether it's a recognized, consistent entity, not just a page that happens to contain the right words. A sameAs network that consistently corroborates your identity across independent, authoritative sources is a direct answer to that question. It's part of what we mean by building your brand's entity profile, the connected, machine-readable picture of who you are that AI systems can verify rather than infer.

Worth being precise about what this does and doesn't claim: no schema property, sameAs included, guarantees a citation or a Knowledge Panel. What a strong, consistent sameAs network does is remove ambiguity, it gives search engines and AI systems independent points of confirmation instead of a single, unverified claim. That's a meaningfully different (and more honest) promise than "this gets you cited," and it's the one worth making.

How to add sameAs in WordPress

You've got three realistic paths, and which one fits depends on how your site is already set up.

If you're running Yoast or Rank Math, both let you enter your organization's social profile URLs in their SEO settings, and both output those as sameAs in the Organization node of their generated schema graph. This is the fastest path if your needs are a handful of standard social profiles, go to your SEO plugin's site-wide settings, find the social profiles section, and fill in the URLs for the platforms you're actually active on. The gap in this approach is that it typically covers the obvious social platforms well but doesn't prompt you toward the higher-value, less-obvious ones, Wikidata, Crunchbase, an industry directory, which is exactly where a lot of sameAs value gets left on the table.

If you're hand-editing JSON-LD, add the sameAs array directly to your Organization (and Person, where relevant) schema block, following the structure above. This gives you full control, but it puts the ongoing consistency audit entirely on you, nothing will flag it when a linked profile goes stale, gets renamed, or disappears.

If you want the entity profile to be built and scored, not just populated, this is where a dedicated tool does more than fill in a field. AI Schema Gen reads your site content and builds your connected entity profile, including your sameAs network, as part of scoring your External Validation dimension alongside Core Identity and Topical Authority. Instead of wondering whether your sameAs array is thin, inconsistent, or missing the high-value connections like Wikidata, you get a concrete picture of exactly where it stands and what to add next. Because it's generated from and checked against your actual site content, it also catches the consistency drift, a name or logo mismatch between your site and a linked profile, that's easy to miss doing this by hand.

Whichever route you take, the standard is the same: every URL genuinely yours, every one consistent with your on-site identity, and the list revisited periodically rather than set once and forgotten.

Common mistakes to avoid

Linking profiles with mismatched names or logos. The single most common way sameAs quietly stops working. Consistency across every linked profile isn't optional, it's the whole mechanism.

Treating it as a social-links widget. sameAs isn't "here's where to follow us," it's "here's independent confirmation this is the same entity." Some genuinely valuable sameAs targets (Wikidata, Crunchbase) aren't social platforms at all.

Skipping Wikidata because it feels technical. It's one of the highest-value sameAs links available and doesn't require Wikipedia's notability bar. Don't let unfamiliarity keep it off your list.

Faking Wikipedia notability. Creating an article for an organization that doesn't meet Wikipedia's bar to have something to link gets the article removed and looks manipulative. Earn it or skip it.

Linking to pages you don't control. A directory listing someone else made, a news mention, an unclaimed profile, these aren't sameAs material, however flattering.

Linking search results or category pages. A sameAs URL needs to be a specific profile page about you, not a page that lists you among others or changes over time.

Padding the array for volume. A dozen thin, inactive profiles do less than five genuine, maintained ones. Depth over breadth.

Never revisiting it. Profiles rebrand, platforms get abandoned, companies change names. A sameAs array set once at launch and never checked again drifts stale exactly like any other part of your entity profile.

Validating your sameAs markup

Google's Rich Results Test validates your JSON-LD syntax and confirms sameAs is parsing correctly as part of your Organization or Person markup, though remember it won't show a visual result for sameAs specifically, there isn't one, and that's expected.

The Schema Markup Validator at validator.schema.org checks broader schema.org validity, useful for confirming the array structure and URL formatting are correct.

Manually click through every URL in your sameAs array on a regular cadence, quarterly is reasonable for most sites. Confirm each one is live, still represents you, and still matches your name, logo, and description. This is the check no automated validator does for you, and it's the one that actually protects the signal's value.

Search your own brand name periodically and see whether a Knowledge Panel appears and whether its details are accurate, a well-corroborated sameAs network is one of the contributing signals, alongside the rest of your Organization schema.

Building your entity profile in WordPress? AI Schema Gen generates your connected sameAs network as part of a full entity profile scored across Core Identity, External Validation, and Topical Authority, so you know exactly which links are working and which are missing. Start free at aischemagen.com.