JSON-LD Schema: How to Build Connected Entity Graphs

Modern search engines no longer rely solely on keyword density and hyperlink citations to understand web pages. Under Google's Knowledge Graph and generative search models, search algorithms operate on the principle of "things, not strings." Search engines aim to identify real-world entities (people, organizations, places, products, and concepts) and understand the explicit semantic relationships connecting them.

Yet, most web applications implement structured data haphazardly. They inject multiple disconnected <script type="application/ld+json"> snippets across their HTML: one isolated block for an Article, another for an Organization, and another for a BreadcrumbList. These fragmented islands of schema force search engines to guess whether the person mentioned as an author is affiliated with the organization that published the article.

The solution is building a Connected Entity Graph using JSON-LD's @graph array and @id node identifiers. By linking individual nodes into an unbroken semantic tree, you provide search engines with an unambiguous machine-readable knowledge map of your brand, content, and author credentials.

In this technical guide, we will analyze the formal specifications defined by Schema.org and the W3C JSON-LD 1.1 specification, explore guidelines from Google Search Central Structured Data documentation, and implement interconnected entity architectures.

The Anatomy of an Entity Node: The Role of @id

In the JSON-LD specification, the @id property serves as the globally unique identifier for an entity node. Think of the @id as an entity's primary key in a relational database. It assigns a permanent Uniform Resource Identifier (URI) to an object so that other nodes can reference it across the web graph without re-declaring its properties.

The Hash Fragment URI Convention

To establish clean, collision-free identifiers, the industry standard is appending specific hash fragments to the canonical URL of the entity:

• Organization Node: https://selestl.com/#organization
• WebSite Node: https://selestl.com/#website
• Author Node: https://selestl.com/author/john-doe/#author
• WebPage Node: https://selestl.com/blog/article-slug/#webpage
• Article Node: https://selestl.com/blog/article-slug/#article

When the Article node needs to declare who wrote the content, it does not repeat a generic string name; it references the author directly via {"@id": "https://selestl.com/author/john-doe/#author"}. Search engines instantly resolve the pointer back to the author's verified credentials.

The 5 Core Nodes of a Connected Schema Graph

A comprehensive connected schema architecture links five primary nodes into an unbroken semantic tree:

Disambiguating Entities with Wikidata and sameAs

One of the most powerful capabilities of connected schema is entity disambiguation. Search engines often encounter ambiguous terms (for example, whether "Java" refers to the programming language, the Indonesian island, or coffee). By using the sameAs and about properties linked to Wikidata URIs, you remove all ambiguity.

Wikidata is the structured knowledge base powering Wikipedia and the Google Knowledge Graph. Referencing Wikidata entries explicitly maps your content directly into Google's entity database:

• For Topics: Use the about or mentions property: {"@type": "Thing", "name": "Search Engine Optimization", "sameAs": "https://www.wikidata.org/wiki/Q180711"}.
• For Organizations: Link your corporate entity to its verified Crunchbase, LinkedIn, and Wikipedia profiles in the sameAs array. Consult the Schema.org Organization specification.
• For Authors: Link contributor profiles to academic citations, Google Scholar profiles, and verified professional portfolios to reinforce Experience, Expertise, Authoritativeness, and Trustworthiness (E-E-A-T). Review our E-E-A-T Optimization Guide.

Production JSON-LD Connected Graph Architecture

Below is a production-grade implementation showing a fully connected @graph structure. All entities are linked seamlessly through @id pointers:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@graph": [
    {
      "@type": "Organization",
      "@id": "https://selestl.com/#organization",
      "name": "Selestl Solutions",
      "url": "https://selestl.com",
      "logo": {
        "@type": "ImageObject",
        "@id": "https://selestl.com/#logo",
        "url": "https://selestl.com/images/logo.png",
        "caption": "Selestl Solutions"
      },
      "sameAs": [
        "https://www.linkedin.com/company/selestl",
        "https://twitter.com/selestl"
      ]
    },
    {
      "@type": "WebSite",
      "@id": "https://selestl.com/#website",
      "url": "https://selestl.com",
      "name": "Selestl Solutions",
      "publisher": {
        "@id": "https://selestl.com/#organization"
      }
    },
    {
      "@type": "Person",
      "@id": "https://selestl.com/authors/tech-team/#author",
      "name": "Engineering Team",
      "worksFor": {
        "@id": "https://selestl.com/#organization"
      },
      "jobTitle": "Technical SEO Architect"
    },
    {
      "@type": "WebPage",
      "@id": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs/#webpage",
      "url": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs",
      "name": "JSON-LD Schema: How to Build Connected Entity Graphs",
      "isPartOf": {
        "@id": "https://selestl.com/#website"
      },
      "breadcrumb": {
        "@id": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs/#breadcrumb"
      }
    },
    {
      "@type": "TechArticle",
      "@id": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs/#article",
      "isPartOf": {
        "@id": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs/#webpage"
      },
      "headline": "JSON-LD Schema: How to Build Connected Entity Graphs",
      "datePublished": "2026-10-12T10:00:00+00:00",
      "dateModified": "2026-10-12T10:00:00+00:00",
      "mainEntityOfPage": {
        "@id": "https://selestl.com/blog/json-ld-schema-how-to-build-connected-entity-graphs/#webpage"
      },
      "author": {
        "@id": "https://selestl.com/authors/tech-team/#author"
      },
      "publisher": {
        "@id": "https://selestl.com/#organization"
      },
      "about": [
        {
          "@type": "Thing",
          "name": "JSON-LD",
          "sameAs": "https://www.wikidata.org/wiki/Q15822158"
        },
        {
          "@type": "Thing",
          "name": "Semantic Web",
          "sameAs": "https://www.wikidata.org/wiki/Q54837"
        }
      ]
    }
  ]
}
</script>

Connected Schema vs Disconnected Blocks Compared

Validation and Diagnostics

Before deploying structured data to production, validate your entity graphs across multiple diagnostic tools:

• Schema.org Validator: Tests the pure semantic syntax against the formal vocabulary specification, ensuring all properties and references resolve cleanly without broken URIs.
• Google Rich Results Test: Verifies whether your structured data qualifies for Google search enhancements like Article carousels, breadcrumbs, and Sitelinks Searchbox features, as detailed in the Google Sitelinks Searchbox guide.
• Technical Infrastructure Coordination: Pair your semantic entity graph with proper canonical tags from our Canonical Tags Guide, complete internal linking from our Internal Linking Architecture Guide, and audit your setup with our Technical SEO Audit Guide.

Need specialized engineering assistance architecting semantic entity graphs, automating headless CMS schema pipelines, or optimizing for generative AI search engines? Discover our custom engineering services or reach out directly through our consultation portal.