>
Guide

How to write sameAs schema for company entities

Master sameAs schema for company entities to disambiguate your brand, solidify Knowledge Graphs, and clean up messy search engine entity mappings.

How to write sameAs schema for company entities — AutoSEO Stack
Key takeaways
  • The sameAs property is an identity link, not a social media link farm for marketing channels.
  • Google and LLMs use sameAs to cross-reference canonical authority sources like Wikidata, Crunchbase, and official registers.
  • Including non-canonical or third-party URLs in sameAs can pollute your entity graph and cause search engines to merge your brand with competitors.
  • Valid schema validation tools only check syntax; they cannot catch semantic errors in entity mapping.
Quick answer

The primary purpose of sameAs schema is entity disambiguation. It tells search engines and AI models that your company (represented by a specific JSON-LD node) is the exact same real-world entity described on external canonical sites like Wikidata, Crunchbase, Wikipedia, or an official business registry. It converts a string of text into an unambiguous node in a global Knowledge Graph. You should use it whenever your brand name shares terminology with other businesses or generic words. The opposite applies if you are linking to transient social profiles that do not establish unambiguous corporate identity.

What is the primary purpose of sameAs schema for company entities?

AutoSEO Stack · Key takeaways
The sameAs property is an identity link, not a social media link farm for marketing channels.
Google and LLMs use sameAs to cross-reference canonical authority sources like Wikidata, Crunchbase, and official registers.
Including non-canonical or third-party URLs in sameAs can pollute your entity graph and cause search engines to merge your brand w
Valid schema validation tools only check syntax; they cannot catch semantic errors in entity mapping.

You inspect your client’s target Organization node in a rich result inspector, see a green checkmark, and assume search engines understand who you are. Six weeks later, Google’s Knowledge Panel merges your mid-sized B2B software firm with a local plumbing supply business of the same name.

If you have tried setting up structured data before and watched search engines completely ignore your identity—or worse, misattribute your brand—you are not alone. When you write sameAs schema for company entities, you aren’t just filling out a marketing checklist; you are supplying the deterministic identity anchors that search engines and AI citation engines use to disambiguate your business across the web.

Why traditional entity linking breaks for company schema

Most SEO teams treat the sameAs array in an Organization schema block as a place to dump every URL where the company holds an account. They drop in links to Twitter, Instagram, TikTok, a local chamber of commerce profile, three review sites, and an old Medium publication.

This approach fails because it misunderstands what the schema specification actually does. The sameAs property is explicitly defined as a URL of a reference Web page that unambiguously indicates the item’s identity. It is an equivalence statement. In mathematical terms, when you put a URL in sameAs, you are stating: Entity A on my website IS IDENTICAL TO Entity B at this destination.

When you point sameAs to a generic directory listing, a local review site, or a social media profile that lacks verified organizational data, you introduce noise into the engine’s entity graph. Search engines do not treat all links equally. If your sameAs array mixes high-confidence canonical entities (like a Wikidata URI) with low-confidence user-generated profiles, algorithms often discount the entire block or build a confused entity graph.

We frequently see sites pass syntax validation with flying colors while completely failing at semantic identity resolution. If you have run into issues where search tools validate your code but refuse to display rich features, it is worth understanding why your JSON-LD schema passes validation but yields no rich results. Syntax validity is merely the baseline; semantic accuracy is what changes search engine behavior.

man operating laptop on top of table
Photo by Bench Accounting on Unsplash

The mechanics of entity disambiguation with sameAs

To write effective company schema, you must step into the shoes of an entity-matching algorithm. Search engines build internal Knowledge Graphs by crawling unstructured text, parsing structured markups, and cross-referencing external databases.

When an engine crawls your site, it assigns a temporary entity ID to your company. To reconcile that temporary ID with its global Knowledge Graph, it relies on unambiguous nodes. If your company name is “Apex,” the engine has to choose between thousands of active companies named Apex.

{
  "@context": "https://schema.org",
  "@type": "Corporation",
  "@id": "https://example.com/#organization",
  "name": "Apex Software Solutions",
  "url": "https://example.com",
  "sameAs": [
    "https://www.wikidata.org/wiki/Q00000000",
    "https://www.crunchbase.com/organization/apex-software-solutions",
    "https://www.linkedin.com/company/apex-software-solutions",
    "https://en.wikipedia.org/wiki/Apex_Software_Solutions"
  ]
}

Notice the structural decisions in this JSON-LD snippet: 1. The @id property: Gives the local entity a URI (https://example.com/#organization). This allows internal schema blocks (like WebPage or AboutPage) to reference the company without duplicating fields. 2. The Specific @type: Using Corporation or LocalBusiness provides immediate context compared to the generic Organization. 3. Canonical target URLs: Every URL in the sameAs array represents a high-trust platform with strict identity verification.

When Google or an AI system crawls this block, it maps your @id directly to Q00000000 on Wikidata. Wikidata acts as the ultimate authority hub for web entities. Once that connection is sealed, the search engine inherits all verified claims attached to that Wikidata node, clearing up ambiguity instantly.

Defining the canonical tiers for sameAs targets

Not all target URLs carry equal weight. When selecting URLs for your sameAs array, group your candidate links into distinct trust tiers.

Tier Source Types Purpose in Knowledge Graph Inclusion Recommendation
Tier 1: Sovereign & Authority Hubs Wikidata, Wikipedia, DBpedia, SEC Edgar, Official Legal Registries (e.g., Companies House) Sets definitive legal and semantic identity; primary source for entity merging. Mandatory (include every profile that exists)
Tier 2: Enterprise Identifiers Crunchbase, LinkedIn Company Pages, Google Business Profile, Bloomberg, PitchBook Validates operational identity, executive structure, and corporate activity. High Priority (include top 2-4 verified profiles)
Tier 3: Secondary Social & Platforms YouTube Channel, Official X/Twitter, GitHub Organization Signals active brand presences and content ownership across ecosystems. Selective (include main corporate accounts only)
Tier 4: Directories & Review Sites Yelp, Trustpilot, G2, Local Chambers of Commerce Customer sentiment and local verification; rarely used for global entity definition. Avoid (keep out of corporate sameAs)

A common mistake is treating Tier 4 sources as primary identity links. Linking to a G2 profile or a local directory page in your corporate sameAs array introduces unstable entity definitions. These third-party sites frequently change their URL structures, allow user-generated edits, or display competing brand ads on the same page.

person using MacBook Pro
Photo by Glenn Carstens-Peters on Unsplash

How to find and verify authority nodes for your company

Before writing a single line of JSON-LD, you must audit and claim your target reference nodes. Do not guess target URLs. A single typo in a Wikidata ID or Crunchbase slug can permanently misalign your entity graph.

Here is the exact step-by-step workflow to audit and curate canonical entity nodes:

  1. Search Wikidata for existing nodes: Navigate to wikidata.org and search for your exact legal business name, previous names, and primary domain name. If a node exists, check its properties (P856 for official website, P154 for logo) to confirm it belongs to your firm.
  2. Audit Wikipedia eligibility: If your company has substantial, independent coverage in primary media, check if a Wikipedia article exists. If it does, use the direct, non-redirected article URL.
  3. Retrieve government identity records: Locate your legal entity filing on sovereign databases. For US companies, this might be the SEC EDGAR CIK page or state business registry. For UK entities, locate your Companies House entry.
  4. Locate corporate profile identifiers: Extract the canonical, normalized URLs for your official LinkedIn corporate page and Crunchbase organization profile.
  5. Verify target canonicalization: Run every candidate URL through a HTTP header checker (or cURL) to verify it returns a direct 200 OK status without redirecting to a different URL structure or trailing-slash variant.
  6. Clean and format the array: Strip trailing query parameters (such as ?utm_source=) and ensure every protocol uses https://.
# Example cURL command to check for clean 200 responses without redirects
curl -I -L https://www.wikidata.org/wiki/Q00000000

If your search reveals no Wikidata entry, you can create one manually—provided you have secondary references to support the entry. Keep in mind that a clean, accurate Wikidata entry is one of the strongest foundational investments you can make for entity-level SEO.

Integrating sameAs into the complete Organization block

Your sameAs array should not exist in isolation. To maximize its impact, place it within a fully realized Organization (or Corporation) JSON-LD graph on your homepage or About Us page.

Here is a complete production-ready schema block:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Corporation",
      "@id": "https://example.com/#organization",
      "name": "Example Corp",
      "legalName": "Example Corporation Inc.",
      "url": "https://example.com",
      "logo": {
        "@type": "ImageObject",
        "@id": "https://example.com/#logo",
        "url": "https://example.com/assets/logo.png",
        "caption": "Example Corp Logo"
      },
      "sameAs": [
        "https://www.wikidata.org/wiki/Q12345678",
        "https://www.crunchbase.com/organization/example-corp",
        "https://www.linkedin.com/company/example-corp",
        "https://org.companieshouse.gov.uk/12345678"
      ]
    },
    {
      "@type": "WebSite",
      "@id": "https://example.com/#website",
      "url": "https://example.com",
      "name": "Example Corp Online",
      "publisher": {
        "@id": "https://example.com/#organization"
      }
    }
  ]
}

By connecting the WebSite block to the Corporation block using @id references, you explicitly inform search tools that the website is published by the exact physical or legal entity mapped to those external registry links. This eliminates the guesswork that algorithms face when parsing unlinked web pages.

If your content strategy relies heavily on AI engines and modern discovery tools citing your brand, read our breakdown on schema tags that actually help ai engines quote you. Providing explicit relationships between your published content and your core entity graph is essential for generative citation.

Entity mapping for AI engines vs search engines

Search engines like Google use structured data to power rich snippets, Knowledge Panels, and local search cards. AI engines (like Perplexity, ChatGPT, or Claude) use structured data to construct semantic models that evaluate source credibility and truth claims.

For traditional search engines, high keyword relevance and strong backlink signals can occasionally compensate for vague entity setup. For AI engines, ambiguity is fatal. When an AI model synthesizes an answer, it cross-references assertions against its training weights and real-time web retrieval. If your company entity is poorly disambiguated, the model will hesitate to attribute facts to your brand.

For a deeper look into how AI models parse entity structures differently than web crawlers, check our field analysis on schema for AI citations: a practitioner’s field guide.

To optimize sameAs for AI engines:

  • Prioritize open knowledge platforms: LLMs are heavily trained on Wikipedia, Wikidata, and structural web crawls. A strong sameAs link pointing to a clean Wikidata entry directly maps to concepts already baked into the model’s parameters.
  • Maintain consistency across profiles: Ensure that the exact legal name, address, and founding date on your website perfectly match the details on every target URL listed in your sameAs array. Inconsistencies confuse automated verification pipelines.
  • Avoid circular or soft redirects: AI web crawlers often drop extra request cycles when hit with long redirect chains. Ensure every sameAs target returns a clean 200 response code.

Many teams fall for outdated advice regarding how AI models process structured data. Before changing your strategy based on generic recommendations, review our critique on why most schema for AI citations advice is outdated without prior experience.

Costs, maintenance, and technical tradeoffs

Managing entity schema carries ongoing technical and operational tradeoffs. Implementing schema is not a one-time setup task; it requires ongoing monitoring and governance.

Operational Factor Single-Node Approach (Simple) Multi-Node Graph Approach (Advanced)
Setup Effort Low (30-60 minutes) High (Requires site-wide template modification)
Maintenance Burden Minimal High (Requires quarterly audits of external URIs)
Disambiguation Precision Moderate (Sufficient for unique brand names) Maximum (Essential for common brand names)
Risk of Entity Collision Moderate Very Low
LLM Retrieval Performance Baseline High Confidence

The Tradeoff of Oversupplying sameAs URLs

Adding URLs to your sameAs array follows a law of diminishing returns.

[ High Entity Signal ]
  |  Wikidata
  |  Crunchbase
  |  LinkedIn
  |  SEC / Companies House
  v
[ Low / Diluted Signal ]
  |  Local Directory
  |  Secondary Social Profile
  |  Review Site
  |  Blog Feature

Every low-quality link you add dilutes the overall signal strength of the array. If an auditor or automated parser inspects a target page and finds mismatched phone numbers, obsolete business addresses, or third-party advertisements, it decreases the statistical confidence score of the entire entity match.

Code Governance and Schema Drift

Another common operational trap is schema drift. A marketing team changes the company’s LinkedIn URL slug, or an agency updates your Crunchbase profile link without telling the technical SEO team. The JSON-LD schema on your website continues pointing to the old URL, which now yields a 404 or 301 redirect.

To prevent this, treat your schema inputs as production software assets. Put your JSON-LD blocks under automated test coverage or schedule quarterly crawling audits using tools like Screaming Frog or custom scripts to validate that every URL inside your sameAs blocks returns a live 200 OK header.

Debunking 3 persistent entity schema myths

Despite the widespread adoption of JSON-LD, several myths continue to mislead site owners into mismanaging their structured data.

Myth 1: “Adding social media links to sameAs boosts social media rankings”

Reality: The sameAs tag is an incoming signal for the current page’s entity, not an outbound link signal designed to pass PageRank or boost your social media profiles. Placing your Twitter profile inside a sameAs array tells search engines, “The entity described on this page is the exact same entity running this Twitter account.” It does not transfer domain authority or help your tweets rank higher in search results.

Myth 2: “If Google’s Rich Results Test passes, your sameAs setup is perfect”

Reality: The Rich Results Test checks syntax, schema vocabulary compliance, and nesting structure. It cannot validate semantic truth. You can insert https://www.wikidata.org/wiki/Q11696 (the node for Microsoft) inside the sameAs array of a local bakery, and the Rich Results Test will display a green checkmark. Syntax validation merely proves your code is readable; it does not prove your assertions are true.

If you suspect your schema syntax is fine but search engines still refuse to show rich elements, read our full breakdown on what nobody tells you about schema for AI citations.

Myth 3: “You need a sameAs link for every page on your site”

Reality: The sameAs property belongs inside organizational, author, or main entity blocks—typically placed on the homepage, About Us page, or author bio pages. Dumping a massive corporate sameAs array into every single blog post or product page bloats your HTML payload without providing extra semantic value. Define the entity globally using @id references and point child nodes back to that primary @id.

To learn how to properly structure rich schema types across different templates without over-stuffing code, check our comprehensive guide on schema markup that earns rich results.

What to do this week to clean up your sameAs schema

To fix existing errors and build an accurate entity graph for your company, execute these steps this week:

  1. Extract your live schema: Pull the current JSON-LD block from your homepage using your browser’s Developer Tools or a crawling tool.
  2. Audit candidate sameAs URLs: Trim your existing sameAs array down to 3-6 canonical, high-trust platforms (Wikidata, Crunchbase, LinkedIn, official business registries).
  3. Purge low-quality links: Remove links to review aggregators, secondary social channels, blog posts, press releases, and directory pages.
  4. Normalize target links: Test every remaining URL in a terminal or header-checker tool to ensure it returns a direct 200 OK status without redirecting.
  5. Implement URI anchors: Ensure your primary entity node includes a persistent @id (e.g., "@id": "https://example.com/#organization"), and link secondary schema nodes directly to this anchor.
  6. Deploy and re-index: Publish the updated JSON-LD markup to production and request re-indexing for your homepage via Google Search Console.

If you want to automate entity discovery, continuous validation, and technical schema deployment across complex site architectures without writing raw JSON-LD by hand, AutoSEO Stack handles structured data generation natively.

Frequently asked questions

What is the primary purpose of sameAs schema for company entities?

The primary purpose of sameAs schema is entity disambiguation. It tells search engines and AI models that your company (represented by a specific JSON-LD node) is the exact same real-world entity described on external canonical sites like Wikidata, Crunchbase, Wikipedia, or an official business registry. It converts a string of text into an unambiguous node in a global Knowledge Graph. You should use it whenever your brand name shares terminology with other businesses or generic words. The opposite applies if you are linking to transient social profiles that do not establish unambiguous corporate identity.

Should I list all my social media profiles inside the sameAs array?

No, you should only list canonical, authoritative profiles that definitively establish entity identity. Including every secondary profile, regional account, or abandoned platform dilutes the signal. Focus on primary accounts on platforms like LinkedIn, official YouTube channels, Crunchbase, Wikidata, and major corporate registries. If a profile is unverified or frequently changes handle, omit it from sameAs. The rule of thumb is to ask whether an auditor looking at that URL could instantly prove it belongs to your legal corporate entity.

Can incorrect sameAs URLs hurt my search rankings or AI visibility?

Yes, incorrect sameAs URLs can pollute your entity graph and cause search engines to merge your brand with an unrelated company. If you accidentally point a sameAs node to a entity with a similar name, search algorithms may assign your brand attributes, reviews, or knowledge panel details belonging to that third party. Recovery from entity pollution can take months of re-indexing. Avoid pointing sameAs to blog posts, press releases, review aggregators, or shared directory pages where your company is merely mentioned.

What is the difference between sameAs and publisher or author properties?

The sameAs property defines identical target entities across different databases, whereas publisher and author properties define relationships between content and entities. Use sameAs inside an Organization or Corporation node to say 'this entity is the same entity found at Wikidata.' Use publisher or author inside an Article or WebPage node to say 'this content was created by this entity.' Mixing these up leads to invalid syntax or ignored schema nodes.

Does sameAs schema guarantee a Google Knowledge Panel?

No, sameAs schema does not guarantee a Knowledge Panel. Schema acts as a structured suggestion that provides machine-readable evidence to search engines. A Knowledge Panel is generated when Google's algorithms reach a high statistical confidence threshold about an entity based on independent web mentions, authoritative databases, and consistent structured data. Correct sameAs schema drastically speeds up this process by removing ambiguity, but it must be backed by real-world third-party citations.

How many URLs should I include in a company sameAs array?

Quality matters significantly more than quantity in sameAs arrays. A well-tuned array typically contains three to seven high-confidence, canonical URLs. This might include your Wikidata item, Crunchbase profile, main LinkedIn corporate page, Wikipedia article (if eligible), and official government registration page. Adding dozens of low-authority directory links adds noise without increasing entity confidence. Omit any link that cannot independently verify your business identity.

Should I use absolute URLs or relative paths in sameAs arrays?

You must always use fully qualified, absolute HTTPS URLs in sameAs arrays. Relative paths break entity resolution because search engines attempt to resolve them against your local domain, defeating the entire purpose of linking to external canonical entities. Ensure that the target URLs are the direct canonical versions, complete with secure protocols and no trailing redirect chains.

Frequently asked questions

how to track ai answer visibility?

Track impressions, citations, and ranking shifts for your AI-generated content.

how to monitor ai answer visibility?

Use tools like AutoSEO Stack to log citations and visibility trends automatically.

can ai detect website traffic?

No, AI models don’t detect traffic; they use public signals and citations to generate answers.

how to improve ai visibility?

Create clear, citation-friendly content that directly answers user questions.

how to track ai answers?

Monitor how often your content is referenced in AI-generated responses across platforms.

Frequently asked questions

How do I track AI answer visibility for my brand?

Set up a weekly scan using a dedicated visibility tool, then compare appearance rates month-over-month rather than chasing absolute numbers.

What's a good AI visibility benchmark?

Most B2B SaaS brands sit between 8-15% appearance rate in their primary categories; e-commerce typically sees 3-8% depending on product specificity.

Can AI visibility tracking predict traffic changes?

Yes—watch for appearance rate shifts of 3% or more combined with ranking position changes; that combination usually precedes a traffic shift within 30 days.

Should I optimize content specifically for AI answers?

Focus on answering user questions directly in the first 100 words of each page; AI models prioritize clear, concise answers over keyword-stuffed content.

Frequently asked questions

how do i know if my brand appears in AI answers?

run a simple prompt search for your brand name across ChatGPT, Perplexity, and Gemini; if you don't see yourself in the top 3 citations, you're invisible

can i track AI answer visibility in google search console?

no; GSC only tracks traditional web search, not LLM citations; you need a dedicated tool or manual prompt logging

what's a good visibility score for a new product?

most teams we see start between 2% and 8% across the big three engines; anything above 10% is already ahead of the curve

how often should i check AI answer visibility?

weekly is the minimum; anything less and you're flying blind as the models update daily