// Service // Entity Graph

    Schema tags are becoming entity declarations.

    Google's 2026 structured data updates shift markup from decoration to identity. A new Product category property, expanded ProductGroup variants, and an active crackdown on misleading markup — on top of an entity graph that decides whether AI Overviews can cite you at all. Here's the model, and how we implement it.

    Schema markup used to be a rich-result tactic. In 2026 it is the layer where search engines and language models decide what your business actually is. Instead of treating keywords as plain text, modern markup connects entities — people, places, organizations, products — into a logical graph that machines can traverse.

    The practical consequence: standalone schema blocks per page are obsolete. What wins is entity stacking — one sitewide graph, stable identifiers, and every page declaring which known entities it is about. That graph is what feeds the Knowledge Graph, and the Knowledge Graph is what AI Overviews reach for when they choose a source to cite.

    @id
    The anchor that merges duplicate entities into one graph node
    sameAs
    Disambiguation against Wikidata, Wikipedia, and official registers
    knowsAbout
    Explicit expertise declarations that feed E-E-A-T
    category
    New 2026 Product property mapping to Google merchant taxonomy
    // Whats_New_2026

    Three changes that break existing markup.

    1. 1. A new category property on Product.
      Google added an explicit category field to Product structured data, mapping each listing directly to Google's internal merchant product taxonomy. This is no longer inferred from your breadcrumbs or collection names — you declare it. Mis-declare it and your products compete in the wrong set.
    2. 2. ProductGroup variant expansion.
      Enhanced ProductGroup support lets merchants group size, material, and colour variations into one cohesive multi-variant entity via variesBy and hasVariant. Stores still shipping one flat Product per variant fragment their own review, price, and availability signals.
    3. 3. The misleading-markup crackdown.
      Google now officially penalizes content-schema mismatches. Product tags on pages with nothing purchasable, Review markup for reviews users cannot see, FAQPage markup on pages without visible Q&As — these are flagged as misleading rather than quietly ignored. Removing bad markup is now a ranking action, not housekeeping.
    // Entity_Anchor

    @id — the identifier every graph needs

    A unique, machine-readable URL for each entity. Declare the entity once, then reference it by @id everywhere else. This is what stops Google seeing forty separate 'Example Corp' organizations across forty templates and instead merges them into one authoritative node.

    // Authority_Bridge

    sameAs — disambiguate against the open web

    Link your entity to Wikidata, Wikipedia, official company registers, and verified social profiles. sameAs is how a retrieval model confirms that the brand in your markup is the same brand it already knows about — and it is the cheapest trust signal available to a new domain.

    // EEAT_Driver

    knowsAbout — declare expertise explicitly

    Nested inside Person or Organization, knowsAbout states the exact fields you have expertise in. It converts 'we write a lot about X' into a machine-readable claim, and it is the single most under-used property for building conceptual topical authority.

    // Context_Map

    about and mentions — map the page's meaning

    about names the primary entity a page covers; mentions lists the secondary entities. Together they tell a retrieval system exactly which concepts a page is authoritative on, instead of leaving it to embedding similarity.

    // Product_2026

    category — the new merchant taxonomy property

    Google's new explicit category field on Product maps your listing to its internal merchant product taxonomy. Getting it right places your products in the correct comparison set inside Shopping surfaces and AI-assembled product answers. Getting it wrong buries them among the wrong competitors.

    // Variants_2026

    ProductGroup — multi-variant done properly

    Expanded ProductGroup support lets you group size, colour, and material variations under one parent entity with variesBy and hasVariant. Done right, it kills variant-level duplication and consolidates review and price signals onto a single product entity.

    // Reference_Implementation

    One graph, in the head, in JSON-LD.

    Google prefers JSON-LD embedded in your HTML head. This example connects a company entity to its founder, declares that founder's expertise, and maps a page to the entities it covers — all through a single @graph.

    {
      "@context": "https://schema.org",
      "@graph": [
        {
          "@type": "Organization",
          "@id": "https://example.com/#organization",
          "name": "Example Corp",
          "url": "https://example.com",
          "sameAs": [
            "https://www.wikidata.org/wiki/Q000000",
            "https://www.linkedin.com/company/example-corp"
          ],
          "founder": { "@id": "https://example.com/#founder" }
        },
        {
          "@type": "Person",
          "@id": "https://example.com/#founder",
          "name": "Jane Doe",
          "knowsAbout": [
            "Artificial Intelligence",
            "Search Engine Optimization"
          ],
          "sameAs": ["https://www.linkedin.com/in/janedoe"]
        },
        {
          "@type": "WebPage",
          "@id": "https://example.com/guide#webpage",
          "about": { "@id": "https://example.com/#organization" },
          "mentions": [
            { "@type": "Thing", "name": "Knowledge Graph" },
            { "@type": "Thing", "name": "Generative Engine Optimization" }
          ],
          "publisher": { "@id": "https://example.com/#organization" }
        }
      ]
    }

    Paste your own markup into our free schema markup checker to see what's missing, or read the GEO guide for how this feeds citation share.

    // What_You_Get

    The entity optimization engagement.

    • Full entity inventory: every organization, person, product, place, and concept your site should own.
    • A single sitewide @graph architecture with stable @id values per template.
    • sameAs mapping to Wikidata, official registers, and verified profiles — including Wikidata gaps we can close.
    • knowsAbout expertise declarations for every author and for the organization itself.
    • about / mentions maps for every content template, keyed to your topic clusters.
    • Product category and ProductGroup migration for ecommerce, matched to Google's merchant taxonomy.
    • A misleading-markup sweep: everything that must be removed before it triggers a manual action.
    • Validation harness so malformed schema fails your build instead of your rankings.
    // The_Contract

    The 180-day money-back guarantee.

    We can promise this because our methodology already works. Hundreds of pages now sit in position #1 across our clients' catalogs. The risk shouldn't be on you — it's on us.

    • 01We run the full 10-stage audit and deliver a sequenced 90-day plan.
    • 02You implement our recommendations (or hire us to implement them).
    • 03If you don't see measurable ranking and revenue improvement in 3–6 months — we refund you. In full.
    Lock in your audit slot →
    // Frequently_Asked

    Schema and entity questions.

    What changed in Google's schema guidelines in 2026?+

    Three things matter. Google added an explicit category property to Product structured data that maps your listings to Google's internal merchant product taxonomy. ProductGroup support expanded so multi-variant products (size, color, material) can be grouped as one cohesive entity. And Google formally began penalizing misleading markup — content-schema mismatches, such as Product markup on a page with nothing purchasable, are now treated as a violation rather than ignored.

    What is entity-based SEO, in practice?+

    Entity-based SEO means declaring machine-readable identities instead of hoping a crawler infers them from your text. Every organization, person, product, place, and concept on your site gets a stable @id, is disambiguated with sameAs links to authoritative databases, and is connected into a single @graph. Search engines and LLMs then read your site as a knowledge graph rather than a bag of keywords.

    Why does @id matter so much?+

    @id is the anchor. It gives an entity one canonical, machine-readable URL identifier that you can reference from every other page without duplicating the entity. Without @id, each page creates a fresh, unlinked copy of your organization or author — and Google has to guess whether they are the same thing. With @id, your entities merge into one strong node in the Knowledge Graph.

    Does schema actually influence AI Overviews and LLM citations?+

    Yes, indirectly but strongly. Retrieval systems favour content whose claims are unambiguous and attributable. Structured data supplies clean, quotable facts (price, availability, author, expertise, publish date) with no parsing ambiguity, and sameAs links let a model verify the entity against Wikidata or an official register. Pages with a coherent entity graph get cited more often than pages with equivalent prose and no markup.

    Can misleading markup get my site penalized?+

    It can trigger a structured data manual action, which removes your rich results — and in aggressive cases suppresses the page. The common triggers are Product markup on non-commerce pages, Review markup for reviews not visible on the page, FAQPage markup where the Q&As are not user-visible, and aggregate ratings that do not exist. Every audit we run starts by removing markup you should not be shipping.

    How long does an entity graph rebuild take?+

    For a typical ecommerce or SaaS site, we deliver the full entity map and JSON-LD templates in 2–3 weeks. Implementation is usually a single template-level change per page type. Knowledge Graph consolidation and citation lift typically show up 30–90 days after deployment, once Google recrawls and merges the entities.

    Find out what your entity graph is telling Google.

    We'll map your current markup, flag every misleading tag, and show the graph you should be shipping.