> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getcited.in/llms.txt
> Use this file to discover all available pages before exploring further.

# JSON-LD Structured Data

> How Cited measures whether your pages declare structured data AI models use to understand what each page is — Organization, Product, Article, FAQPage.

JSON-LD tells AI models exactly what your page is about — an Organization, a Product, an Article, an FAQ. Without it, AI models guess from prose, and the guesses are often wrong: a product page reads as a blog post, a service page reads as a corporate brochure, and the AI cites accordingly.

## Methodology

Cited samples up to 5 pages from your site and extracts every JSON-LD block on each. Schema.org types declared in any sampled page count toward the score — the scanner aggregates across the sample rather than per-page, so a Product type declared on one page and an Organization type on another both contribute.

Schema types are scored in two value tiers based on how strongly AI models use each type for grounded answers:

**High-value types (2 points each).** `Organization`, `LocalBusiness`, `Product`, `Article`, `BlogPosting`, `NewsArticle`, `FAQPage`, `HowTo`. These are the eight types AI models most reliably ground citations against — they answer "who are you," "what do you sell," "what do you say about X," and "how do I do X."

**Medium-value types (1 point each).** `WebSite`, `WebPage`, `BreadcrumbList`, `Review`, `Service`, `Person`, `ItemList`, `SoftwareApplication`. These add context that AI models use as supporting structure, not primary grounding.

The score sums points across all unique types found across the sample, capped at 8. A site with `Organization` + `Product` + `Article` declared scores 6/8 (three high-value at 2 each). A site with `Organization` + `BreadcrumbList` scores 3/8 (one high-value, one medium). A site with JSON-LD present but no scored type — for example, only `Thing` or a custom type — falls through to a 1-point floor for "JSON-LD on the page but not in a useful form."

The signal scores out of 8. Status thresholds: pass at 6/8, partial at 3/8, fail below.

Why aggregate across the sample? AI citation patterns favor sites that declare structured data consistently — a site with `Organization` schema in the global layout and `Product` schema on product pages signals editorial discipline across the whole template. The signal rewards declaring the right type for each page type, not piling all schemas onto one page.

## Verification

You can verify our finding yourself in a browser.

**Step 1: Open the pages we sampled.** Cited reports the URLs we tested. Open each in a new tab.

**Step 2: Extract JSON-LD blocks via the console.** Open DevTools (`Cmd+Option+I` / `Ctrl+Shift+I`), Console tab, and run:

```javascript theme={null}
[...document.querySelectorAll('script[type="application/ld+json"]')].map(s => { try { return JSON.parse(s.textContent); } catch { return 'INVALID JSON'; } })
```

This returns every JSON-LD block on the page. Each block is either a parsed object (success) or `'INVALID JSON'` (the scanner silently skips these — fix the JSON if you see this).

**Step 3: List the `@type` declarations.** For each parsed block, find the `@type` field. It's either a string (`"Article"`), an array (`["Article", "BlogPosting"]`), or nested inside `@graph` (one schema wrapping multiple typed objects). Compare against the scored type lists above — every match adds points.

**Step 4: Validate with Google's Rich Results Test.** Paste the page URL into [Google's Rich Results Test](https://search.google.com/test/rich-results). It returns every schema Google's parser detects, plus any validation errors. The same JSON-LD AI models consume from your page is visible here. Schema.org's own [Schema Markup Validator](https://validator.schema.org) gives a stricter view without Google's rich-results filter.

If your verification disagrees with Cited's finding, that's a bug — let us know.

## Technical detail

Schema.org was launched in 2011 as a joint Google / Microsoft / Yahoo / Yandex initiative to standardize structured data declarations. JSON-LD (JSON for Linked Data) was added as a Schema.org-recognized format in 2013 and is now the dominant serialization — preferred over microdata and RDFa in modern documentation because it lives in the `<head>` separately from rendered HTML, making it easier for both authors and parsers.

**Extraction logic.** Cited's scanner uses regex against the raw HTML to find JSON-LD blocks:

* Pattern: `<script type="application/ld+json">…</script>` (case-insensitive on the type attribute)
* Each block's text content is passed to `JSON.parse()` — blocks that throw are silently skipped (an invalid JSON-LD block contributes nothing but doesn't crash the scan)
* The parsed object is recursively walked: top-level `@graph` arrays expand into their member objects; top-level arrays expand into elements; nested objects in fields like `mainEntity` are NOT recursively traversed (only top-level and `@graph` traversal is performed)
* Each object's `@type` is read — strings count as one type, arrays count as multiple types

**Type aggregation.** The scanner builds a `Set` of all types found across all sampled pages. Duplicates within a page (`Article` declared in two separate blocks) and duplicates across pages (`Organization` on every page) collapse to a single entry. The set is then scored against the high-value and medium-value lists.

**Score calculation.** Points = sum of (high-value matches × 2) + (medium-value matches × 1), capped at 8. If no scored types match but at least one JSON-LD block parsed successfully, score = 1. If no JSON-LD blocks parse, score = 0.

**Edge cases the scanner handles:**

* **`@graph` arrays** — a single JSON-LD block can declare multiple typed objects inside an `@graph` array (Yoast and RankMath both do this). The scanner walks the array and extracts each object's `@type`. A `@graph` with `Organization` + `WebSite` + `BreadcrumbList` contributes all three types.
* **Top-level arrays** — some sites serialize multiple schemas as a top-level array: `[{...Article...}, {...Person...}]`. The scanner walks each element. Equivalent to `@graph` in scoring.
* **Array `@type` values** — Schema.org allows `@type: ["Article", "BlogPosting"]` to declare a type that inherits from both. The scanner counts each string in the array as a separate type. A block with both array entries earns 4 points (2 each).
* **Invalid JSON** — a JSON-LD block with a trailing comma, unquoted key, or other syntax error throws on `JSON.parse()`. The scanner catches the error and continues to the next block. The page isn't penalized beyond the missing schema.
* **Microdata and RDFa** — Schema.org can be expressed inline via `itemtype="https://schema.org/Article"` (microdata) or `typeof="schema:Article"` (RDFa). The scanner does NOT extract these formats — only JSON-LD `@type` declarations count. Sites using microdata get partial credit elsewhere (Article schema's `author` field still satisfies the Author Attribution signal) but score 0 here.

**What this signal does not measure:**

* **Property completeness.** A page with `@type: "Article"` but no `headline`, `author`, or `datePublished` scores the same as a fully-filled Article schema. The scanner counts type presence, not field richness. Other signals (Author Attribution, Content Freshness) check for specific fields independently.
* **Schema validity beyond JSON parsing.** A page with `@type: "Prodcut"` (typo) parses as valid JSON but doesn't match any scored Schema.org type. The scanner treats this as "no recognized type" and falls through to the 1-point floor. Validators like Google's Rich Results Test catch this; Cited reports it implicitly via the missing-types diagnostic.
* **Schema.org version.** Schema.org evolves continuously, and some types (e.g., `Drug`, `Course`) exist only in recent versions. The scanner uses a fixed scored-type list based on what AI models reliably ground against today — newer or specialized types may be present and useful but don't score here.
* **`@context`.** The scanner doesn't validate that `@context: "https://schema.org"` is declared. Custom contexts that happen to use the same type names still count. This is permissive on purpose — Schema.org's identity is widely understood and rarely mis-specified.

For brands scoring 0-1/8, the highest-leverage fix is adding `Organization` schema to the site's global layout and the appropriate page-type schema (`Product` for product pages, `Article` for blog posts, `FAQPage` for FAQ sections) to each page template. Most modern CMSes have plugins that handle this automatically — WordPress (Yoast, RankMath), Shopify (Smart SEO), Webflow (built-in Open Graph and Schema fields), Next.js (next-seo) — but custom themes often need explicit additions to the `<head>`.

See also: [Author Attribution](/signals/author-attribution), [Open Graph Tags](/signals/open-graph-tags), [Content Freshness](/signals/content-freshness).