What is an @id in Structured Data?

In JSON-LD structured data, an @id is a property that assigns a unique resource identifier (URI) to an entity. This identifier allows you to refer back to a specific entity as you’re building your Content Knowledge Graph. It also helps search engines and machines to recognize the relationships between the entities across your site and the web.

In most cases, this unique identifier points to what’s called an Entity Home – a canonical URL on your site that serves as the authoritative source for that entity definition.

By using @id, you create a clear identifier for your entities, ensuring search engines interpret them correctly and deliver richer search experiences. But how does this work in practice, and why is it important for your structured data strategy?

Let’s break it down.

How do @ids Show Up in JSON-LD Structured Data?

@id’s On Your Website

In JSON-LD structured data, an @id typically appears as a URL, often with a fragment identifier (#). This format makes it easy for search engines to recognize and reference the same entity across different structured data elements on your site.

For example, Schema App might display an @id like this to call out their organization on their homepage:

This unique identifier represents Schema App as an entity. Anywhere else on the site that references the organization can simply point back to this @id instead of redefining the organization each time.

In this case, the homepage URL (www.schemaapp.com) acts as the Entity Home—the authoritative page that best describes the Schema App organization. Defining the organization here and referencing it consistently across the site helps establish clarity for search engines and within our Knowledge Graph.

Each entity should be defined only once in the world. By reusing @id values consistently, we consolidate references, creating a central point of truth and improving overall data quality.

The W3C defines this approach as a node reference: “node object containing only the @id property, which may represent a reference to a node object found elsewhere in the document.”

Instead of treating each mention of an entity separately, @id node references allow you to unify them under a single definition. This is critical when building a Content Knowledge Graph that accurately reflects the relationships between entities in your content.

@id’s Across the Web

You’ll also see @id used beyond your own website—on platforms like Wikipedia, Wikidata, and in Google’s Knowledge Graph.

For instance, Wikidata assigns a unique identifier to each entity in its database, such as this one for London, England: https://www.wikidata.org/entity/Q84. These identifiers help connect facts about an entity across different sources in a structured, machine-readable way.

Similarly, Google’s Knowledge Graph uses unique entity identifiers behind the scenes to consolidate information about people, places, and things from across the web.

When you reference these well-established @id values—or clearly define your own—you help search engines better understand the meaning behind your content and how it connects to broader concepts.

Example: Using @id for Shared Staff Across Multiple NYC Locations

Let’s say Dr. Alice Smith is a general dentist who works at two clinics: one in Brooklyn and one in Manhattan. Rather than repeating her details in every location’s structured data, we can define her once — on her staff bio page — and use the @id to reference that same definition wherever she appears elsewhere on the site.

This approach reduces duplication, improves data quality, and helps search engines and AI systems understand that both references point to the same person.

Define Dr. Smith Once (Entity Home):

{
  "@context": "https://schema.org",
  "@type": "Person",
  "@id": "https://www.exampledental.com/staff/dr-alice-smith",
  "name": "Dr. Alice Smith",
  "jobTitle": "General Dentist",
  "worksFor": {
    "@type": "Organization",
    "name": "Example Dental"
  }
}

Brooklyn Location Schema:

{
  "@context": "https://schema.org",
  "@type": "Dentist",
  "@id": "https://www.exampledental.com/locations/brooklyn",
  "name": "Example Dental - Brooklyn",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "101 Flatbush Ave",
    "addressLocality": "Brooklyn",
    "addressRegion": "NY",
    "postalCode": "11217",
    "addressCountry": "US"
  },
  "employee": {
    "@id": "https://www.exampledental.com/staff/dr-alice-smith"
  }
}

Manhattan Location Schema:

{
  "@context": "https://schema.org",
  "@type": "Dentist",
  "@id": "https://www.exampledental.com/locations/manhattan",
  "name": "Example Dental - Manhattan",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "350 5th Ave",
    "addressLocality": "Manhattan",
    "addressRegion": "NY",
    "postalCode": "10118",
    "addressCountry": "US"
  },
  "employee": {
    "@id": "https://www.exampledental.com/staff/dr-alice-smith"
  }
}

Read our support article to learn more about disambiguation properties in Schema.org.

Why it’s Important to Include @id in Your Schema Markup

Using @id in your structured data isn’t just a technical detail—it’s a strategic tool that plays a key role in how your content is interpreted by search engines and connected across the web.

1. Establishes Clear Entity Relationships

By assigning a unique identifier to an entity, @id signals to search engines that all references point to the same thing. This prevents fragmentation of entity data, ensuring consistency and clarity in how your content is understood. It also helps search engines connect related pieces of content.

When that @id points to an Entity Home, it further reinforces to search engines that this is the central, canonical source of truth for that entity. This is especially powerful when building a connected, meaningful Content Knowledge Graph.

2. Improves SEO and Strengthens Your Content Knowledge Graph

When your structured data clearly links entities together using @id, it enhances Google’s understanding of your content and how it fits into broader topics and domains. This can contribute to stronger performance in search through improved representation in Google’s Knowledge Graph.

@id also supports the development of your internal Content Knowledge Graph—a framework that connects your organization’s key topics, people, products, services, and other content entities. This graph isn’t just for search engines; it gives your team more control and structure when organizing and scaling your content strategy. Refining your data with a @id strategy improves the data integrity of your Content Knowledge Graph.

By referencing authoritative external entities, like those on Wikidata or Wikipedia, you can strengthen these connections and improve the semantic clarity of your content. The clearer your content is to machines, the more likely it is to be surfaced meaningfully in AI-powered search experiences.

3. Prevents Duplicate Data Issues

If the same entity appears on multiple pages, using the same @id ensures consistency across your site. This prevents the creation of multiple, redundant entity definitions and helps search engines maintain a single, unified view. This reduces the impact of Schema Drift, which happens when web content changes—whether through updates, site migrations, or evolving SEO strategies—but the structured data remains static, creating a gap between the two.

4. Enables More Advanced Schema Strategies

@id is foundational for building complex, interconnected structured data models. It allows you to link related entities—like a product to its brand, or an article to its author—in a clear and scalable way.

By properly including @id in your markup, you can take your strategy from simply implementing Schema Markup for the sake of rich results, all the way to developing a rich Content Knowledge Graph and optimizing for semantic AI search.

5. Googlebot Follows @id References Around the Web

One powerful but often overlooked capability of @id is that it acts as a connective tissue not just within your site—but across the web. When you reference an entity using a resolvable @id (ideally pointing to its Entity Home), you’re inviting Googlebot to crawl that URL and absorb additional context about that entity.

At Schema App, we’ve observed that Googlebot has been following @id links since as early as 2017. This crawling behavior signals that @id isn’t just for internal clarity—it’s a tool search engines actively use to connect the dots across multiple sources and feed them the connective data required to build a unified, semantically-rich understanding of your brand and content.

Without @id, your structured data is an island of information with limited value beyond the page it lives on. This strategy doesn’t just enhance discoverability; it lays the foundation for long-term success in semantic search and AI experiences.

Best Practices for Using @id

To get the most out of @id, we recommend following these best practices:

• Use Canonical URLs Whenever Possible: If an entity has a dedicated webpage/URL (e.g., an organization’s About page or a Wikipedia/Wikidata entry), use that URL as the @id.
• Leverage Fragment Identifiers (#): If no URL exists, create a unique identifier like https://example.com/#author-john-doe.
• Ensure Consistency Across Your Site: Reuse the same @id for an entity wherever it appears in your structured data. This ensures clarity and helps avoid duplication.

How Schema App Can Help

The @id property is a small but powerful element in your structured data strategy. It helps search engines recognize entities more accurately, connect content more intelligently, and understand your site in context.

Schema App makes it easy to define and manage @id values at scale, so you can focus on building a connected, well-structured Content Knowledge Graph without manually coding every relationship.

Want to scale your Schema Markup strategy to the next level? Get started with Schema App.