What does an entity graph add over page-level markup?

An entity graph adds identity that persists across pages: every page points to the same Organization and Person nodes instead of declaring its own copies. Google's Organization guidance describes markup that helps it disambiguate an organization in search results, and a shared graph gives that markup one consistent source. This post covers markup correctness and makes no claim about ranking or AI-answer citation outcomes.

Layer 1 gives each entity the address that every other node references.

Layer 1: What is an Entity Home?

An Entity Home is the single page on your domain that holds the canonical record of one entity, identified in JSON-LD by a persistent @id. The term comes from Jason Barnard of Kalicube. Assign each entity one @id as a URI fragment, such as https://yourdomain.com/#organization and https://yourdomain.com/#person, and reference that @id from every service page and article instead of redeclaring the entity.

Markup without an @id creates a blank node, so 2 pages that each declare an Organization produce 2 unconnected Organizations instead of 1 shared one. A service page that references the Entity Home's @id joins the existing node:

{
  "@context": "https://schema.org",
  "@type": "Service",
  "name": "Local SEO for HVAC Companies",
  "provider": { "@id": "https://farrukh.top/#organization" }
}

Once each entity has an @id, layer 2 connects that node to Wikidata, ORCID, GitHub, and Crunchbase.

Layer 2: What belongs in a sameAs array?

4 types of identity nodes belong in a sameAs array: structured knowledge bases, researcher registries, developer hubs, and B2B verification directories. schema.org defines sameAs as an identity assertion, so every URL in the array must be a page about the entity itself.

• Structured knowledge bases, such as Wikidata item Q141886354
• Researcher registries, such as ORCID profile 0009-0001-9570-3897
• Developer hubs, such as the GitHub profile yes155
• B2B verification directories, such as GoodFirms and Crunchbase

Each node belongs on the entity it describes: a Crunchbase person profile belongs on the Person, and a GoodFirms company profile belongs on the Organization. Open every target before adding it, and confirm that it describes the same entity.

2 further node types attach through other properties. Published research, such as the Zenodo whitepaper (DOI 10.5281/zenodo.23701870), belongs on a CreativeWork node whose author is your Person @id. Industry credentials belong under hasCredential. Those pages describe your work and qualifications rather than your identity, so sameAs is the wrong property for them.

The full graph looks like this:

{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://farrukh.top/#organization",
      "name": "Farrukh Abdullah Advisory",
      "url": "https://farrukh.top/",
      "sameAs": [
        "https://www.goodfirms.co/company/farrukh-abdullah-geo-semantic-seo-consultant"
      ]
    },
    {
      "@type": "Person",
      "@id": "https://farrukh.top/#person",
      "name": "Farrukh Abdullah",
      "jobTitle": "Semantic SEO & GEO Consultant",
      "worksFor": { "@id": "https://farrukh.top/#organization" },
      "sameAs": [
        "https://orcid.org/0009-0001-9570-3897",
        "https://www.wikidata.org/wiki/Q141886354",
        "https://github.com/yes155",
        "https://www.crunchbase.com/person/farrukh-abdullah"
      ]
    },
    {
      "@type": "CreativeWork",
      "url": "https://zenodo.org/records/23701870",
      "identifier": "https://doi.org/10.5281/zenodo.23701870",
      "author": { "@id": "https://farrukh.top/#person" }
    }
  ]
}

Which attributes must match across every node?

3 attributes must match character for character on every node: the entity name, the job title, and the third-person description. Entity reconciliation compares strings first, so "SEO Consultant" on one profile and "SEO Specialist" on another introduces an ambiguity that a single canonical string prevents. Copy each value from the Entity Home into every external profile, and re-check them whenever one changes.

With identity established, layer 3 attaches typed location attributes.

Layer 3: How do you map service and local entities?

To map service and local entities, declare areaServed with a typed City or GeoCircle on each service or business node. The following example declares 1 named city and a 50 km radius for a hypothetical HVAC business:

{
  "@context": "https://schema.org",
  "@type": "HVACBusiness",
  "@id": "https://example-hvac.com/#organization",
  "name": "Example HVAC Co.",
  "areaServed": [
    { "@type": "City", "name": "Austin" },
    {
      "@type": "GeoCircle",
      "geoMidpoint": { "@type": "GeoCoordinates", "latitude": 30.2672, "longitude": -97.7431 },
      "geoRadius": 50000
    }
  ]
}

areaServed accepts City, GeoShape, and plain text; a typed City or GeoCircle states the service area exactly, while plain text leaves it open to interpretation. geoRadius takes meters, so 50000 is 50 km.

Layer 3 completes the graph, and the next step is checking that it holds together.

How do you validate the graph?

To validate the graph, run the combined JSON-LD through the Schema Markup Validator, then check that every @id reference resolves to a declared node. The validator covers syntax and schema.org types, and the script below covers the reference check on its own.

import json
import sys


def walk(node, declared, refs):
    if isinstance(node, dict):
        if "@id" in node:
            # A node holding only an @id is a reference; any other node declares it.
            (refs if len(node) == 1 else declared).add(node["@id"])
        for value in node.values():
            walk(value, declared, refs)
    elif isinstance(node, list):
        for item in node:
            walk(item, declared, refs)


declared, refs = set(), set()
for path in sys.argv[1:]:
    with open(path, encoding="utf-8") as f:
        walk(json.load(f), declared, refs)

print("Declared:", sorted(declared))
print("Unresolved @id references:", sorted(refs - declared) or "none")

Run it as python check_ids.py graph.json service.json. A service page that references #organization resolves only when the file declaring that Organization is in the same run: the graph file plus the service file prints none, and the service file alone lists https://farrukh.top/#organization as unresolved.

What are the limits of this approach?

This approach delivers consistent, machine-readable identity, not ranking or citation outcomes. No markup change in this post is tied to a measured traffic or citation result, so test every claim about AI-answer visibility on your own site before relying on it.

Where can you read more?

The 4 primary references are the schema.org pages for sameAs, hasCredential, and GeoCircle, and Google's Organization structured data guidance. The Schema Markup Validator checks syntax and types, and the JSON-LD 1.1 specification defines @id and blank nodes.

My related work: Local Entity SEO: Accurate Business Information and Useful Service Content extends layer 3 to location-based businesses, and awesome-geo-seo is the open-source curated list for generative engine optimization.

I'm Farrukh Abdullah, a Semantic SEO & GEO Consultant, and the identifiers in the examples are my own.