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

# Schema Entities Auditor

> Finds Schema.org structured data (JSON-LD, Microdata, RDFa) on the page

<Info>
  **SEO Auditor** — checks that the audited page describes itself with Schema.org structured data in at least one of the three formats search engines read: JSON-LD, Microdata or RDFa.
</Info>

<CardGroup cols={2}>
  <Card title="Rich results" icon="star">
    Structured data is what turns a plain search listing into a rich result: ratings, prices, FAQs, breadcrumbs, event dates.
  </Card>

  <Card title="Machine readable" icon="robot">
    Search engines and AI answer engines use the same entities to understand what the page is, who published it and how it relates to other pages.
  </Card>
</CardGroup>

Schema.org is the shared vocabulary that search engines, social networks and AI answer engines use to understand a page: whether it is an article, a product, an organization, an event or a recipe, and which properties describe it. The vocabulary can be embedded as JSON-LD (`<script type="application/ld+json">`, the format Google recommends), as Microdata (`itemscope` / `itemtype` attributes on HTML elements) or as RDFa (`vocab` / `typeof` attributes). This auditor fetches the page once and counts the entities it finds in each format.

## How it works

1. **Fetch** — sends a `GET` request to the audited URL as 37AuditsBot with an `Accept` header that prefers HTML. A blocked request ends the audit with `590`; any other failure (timeout, DNS, TLS, non-2xx answer) ends it with `500`.
2. **JSON-LD** — parses every `<script type="application/ld+json">` block. Each object with a `@type` counts as one entity when its `@context` names schema.org, its type uses the `schema:` prefix or is a bare type name; objects nested under `@graph` are counted too. A block that does not parse as JSON is skipped when counting and recorded for the `300` rule.
3. **Microdata** — every element with `itemscope` and an `itemtype` under `schema.org` counts once per type IRI.
4. **RDFa** — every element with `typeof` counts once per type when it or an ancestor declares `vocab` under `schema.org`, or when the type uses the `schema:` prefix.
5. **Rules** — no entity in any format fails (`400`); each malformed JSON-LD block warns (`300`).
6. **Aggregate** — FAIL wins over WARNING; when every rule passes the audit is `SUCCESS` (`200`) and the message lists the counts per format and per type.

## What it audits

Every row maps to one `checkRule*` method and one `CheckCode`, in the order the auditor runs them. CheckCode suffixes use status ranges: `200` success, `300–399` warning, `400–499` fail, `500–599` error.

| CheckCode | Status | When it fires | Recommendation | Why it matters |
| - | - | - | - | - |
| <a id="37A-SchemaEntitiesAuditor-400" />`37A-SchemaEntitiesAuditor-400` | `FAIL` | No Schema.org entity was found in any format (JSON-LD, Microdata or RDFa). | Add structured data to `{url}`, for example a `<script type="application/ld+json">` block with `"@context": "https://schema.org"` describing the page (Organization, WebSite, Article, Product…). | Without structured data, search engines and AI answer engines have to guess what the page is about, so it is less likely to earn rich results or to be cited. |
| <a id="37A-SchemaEntitiesAuditor-300" />`37A-SchemaEntitiesAuditor-300` | `WARNING` | A `<script type="application/ld+json">` block does not parse as JSON (one check per block). | Fix the JSON in JSON-LD block `{ordinal}` of `{url}` so search engines can read it; the parser reported "`{error}`". | A JSON-LD block that does not parse is ignored by search engines, so the entities it describes bring nothing: no rich results and no better understanding of the page. |
| <a id="37A-SchemaEntitiesAuditor-200" />`37A-SchemaEntitiesAuditor-200` | `SUCCESS` | All rules passed. Message: Found `{total}` Schema.org entities on `{url}` (`{jsonLd}` JSON-LD, `{microdata}` Microdata, `{rdfa}` RDFa); types: `{types}`. | — | — |
| <a id="37A-SchemaEntitiesAuditor-500" />`37A-SchemaEntitiesAuditor-500` | `ERROR` | The page could not be fetched (timeout, DNS, TLS, or a non-2xx answer other than a block). | Make sure `{url}` answers with HTTP 2xx, then run the audit again. Last error: `{error}`. | — |
| <a id="37A-SchemaEntitiesAuditor-590" />`37A-SchemaEntitiesAuditor-590` | `ERROR` | The audited page answered HTTP 403, HTTP 429 or a Cloudflare challenge, so 37AuditsBot was blocked before it could read the page. | Allow 37AuditsBot in your firewall or bot protection: allowlist its user agent, or verify its Web Bot Auth signature. See [https://www.37audits.com/bot](https://www.37audits.com/bot). | While 37AuditsBot is blocked this audit cannot look at the site, so problems on it go unreported. |

## Output documentation

| Status | Description | Test logic |
| - | - | - |
| **SUCCESS** | The page carries Schema.org structured data | At least one entity was found and every JSON-LD block parses (`200`). |
| **WARNING** | A JSON-LD block is unreadable | Entities were found, but at least one `application/ld+json` block does not parse (`300`). |
| **FAIL** | No structured data | No entity in JSON-LD, Microdata or RDFa (`400`). |
| **ERROR** | The auditor could not read the page | Fetch failure or non-2xx answer (`500`); site blocked 37AuditsBot (`590`). |

Every check carries the same `data` map: `totalEntities`, `byFormat` (`jsonLd`, `microdata`, `rdfa` counts), `types` (count per type name), `examples` (up to five snippets of the entities found, omitted when there are none) and `malformedJsonLdBlocks` (block ordinal and parser error for each JSON-LD block that failed to parse).

## Risks and considerations

### Why structured data matters

* Rich results (star ratings, prices, FAQ drop-downs, breadcrumbs, event dates) only appear for pages that describe themselves with Schema.org entities; they take more space on the results page and earn more clicks than a plain listing.
* AI answer engines and search assistants rely on the same entities to tell an article from a product page, to name the publisher and to cite the page with confidence.

### JSON-LD first

* Google recommends JSON-LD: it lives in one `<script>` block, does not depend on the HTML layout and survives redesigns. Microdata and RDFa still count, but they break more easily when templates change.
* A single typo (a trailing comma, an unescaped quote, a truncated block) makes the whole block unreadable. Validate it after every template change with the Schema.org validator or Google's Rich Results Test.

### What this auditor does not check

* Only the audited URL is fetched; other pages of the site may carry different or no structured data.
* The auditor counts entities and parse failures. It does not validate that the properties of an entity are the ones its type requires, nor that the values are correct, so a page can pass here and still not qualify for rich results.
* Structured data injected by JavaScript after the page loads is not seen: the auditor reads the HTML as served.
* Types from vocabularies other than Schema.org are ignored.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.