Missing schema webpage

Moderate effort

Found on 94% of audited stores.

Add WebPage schema markup to every page so search engines and AI answer engines can precisely understand and describe your content.

What it is

Schema markup is a small block of invisible, structured code you add to a web page that tells search engines and AI systems exactly what the page is — its title, description, URL, and type. The `WebPage` schema type is the foundational label that says "this is a web page, here is its name, here is what it's about." Without it, search engines and AI tools have to guess this information by reading your page like a human would, which is less reliable. Think of it like a name tag for your page that any machine can instantly read.

Why it matters

Adding `WebPage` schema directly supports Answer Engine Optimization (AEO) — the emerging discipline of making your content eligible to be quoted or cited by AI assistants like Google's AI Overviews, ChatGPT, and Bing Copilot. AI systems rely heavily on structured data to identify authoritative, trustworthy sources to pull answers from; a missing `WebPage` schema means your pages are less likely to be chosen. It also strengthens your baseline for rich results eligibility and helps Google correctly index and understand every page on your site, which supports rankings and organic traffic. For ecommerce stores in particular, this can mean more product pages, category pages, and content pages surfacing in both traditional search results and AI-generated answers.

How to fix it

  1. Decide which pages need WebPage schema — at minimum: your homepage, about page, contact page, blog/article pages, policy pages, and any content or landing pages. (Product pages typically use Product schema; category pages may use CollectionPage, a sub-type of WebPage.)
  2. Craft a JSON-LD script block for each page containing @context, @type, name (the page's SEO title), description (a concise 1–2 sentence summary), and url (the canonical URL of that page).
  3. Optionally enrich the schema with additional properties such as 'datePublished', 'dateModified', 'inLanguage', 'breadcrumb', and 'isPartOf' (linking to your WebSite schema) to give search engines even more context.
  4. Inject the JSON-LD block inside the <head> element of each page, or just before the closing </body> tag — either location is accepted by Google.
  5. After deploying, validate each page using Google's Rich Results Test (search.google.com/test/rich-results) and the Schema Markup Validator (validator.schema.org) to confirm the markup is parsed correctly with no errors.
  6. Monitor Google Search Console's 'Enhancements' section over the following weeks to confirm Google has detected the structured data across your site.

Fix it on your platform

Pick your platform for the exact steps.

How to fix missing schema webpage on Shopify
  1. In your Shopify admin, go to Online Store → Themes → click the three-dot menu next to your active theme → Edit code.
  2. Open 'theme.liquid' (the global layout file) inside the Layout folder — this file wraps every page.
  3. Paste your WebPage JSON-LD <script> block inside the <head>...</head> section, ideally just before the closing </head> tag.
  4. Because Shopify uses Liquid templating, use Liquid variables to make the schema dynamic: {{ page_title | json }} for the name, {{ page_description | json }} for description, and {{ canonical_url | json }} for the url property.
  5. Save the file. Verify with Google's Rich Results Test on several page types (homepage, an About page, a policy page).
  6. For Product pages, Shopify already injects some Product schema; add WebPage/ItemPage schema via a separate product.liquid or product.json template section if needed.
Full Shopify guide →Official Shopify docs ↗
How to fix missing schema webpage on WooCommerce
  1. Install the free 'Yoast SEO' plugin (or 'Rank Math SEO') — both automatically generate WebPage/WebSite schema across all page types with no code required.
  2. For Yoast: go to SEO → Search Appearance, and ensure Schema settings are enabled (they are by default). Yoast outputs context-aware schema (WebPage, ItemPage, ProductPage, etc.) on every page automatically.
  3. For Rank Math: go to Rank Math → Titles & Meta → set the Schema Type per post type (Page, Post, Product). Rank Math outputs WebPage schema globally.
  4. To add custom or supplemental JSON-LD without a plugin, open your child theme's header.php and paste the JSON-LD block inside the <head> section, using PHP to echo dynamic values: <?php echo get_the_title(); ?> and <?php echo get_permalink(); ?>.
  5. Validate with the Rich Results Test after saving.
Full WooCommerce guide →Official WooCommerce docs ↗
How to fix missing schema webpage on BigCommerce
  1. In your BigCommerce admin, go to Storefront → Themes → click 'Advanced' → Edit Theme Files on your active theme.
  2. Open the 'templates/layout/base.html' file (the global layout template used by Stencil themes).
  3. Paste your WebPage JSON-LD <script> block inside the <head> section of base.html.
  4. Use Handlebars variables to make it dynamic: {{settings.store_name}} for name, {{page.description}} for description, and {{urls.canonical}} or {{canonicalUrl}} for the url property (variable names may vary slightly by theme version).
  5. Save and push the theme. Validate a representative set of pages with the Rich Results Test.
Full BigCommerce guide →Official BigCommerce docs ↗
How to fix missing schema webpage on Wix
  1. In the Wix Editor, click on the page you want to edit.
  2. Open the left panel and click the page settings icon (Page SEO or Page Settings).
  3. Scroll down to find 'Advanced SEO' → 'Schema Markup' (or '<head> tags'). Wix provides a structured data field where you can paste JSON-LD directly per page.
  4. Paste your WebPage JSON-LD block into this field for each page.
  5. Alternatively, use the Wix SEO Wiz or a Wix App Market app such as 'SEO Schema Markup by Storeya' to manage schema globally.
  6. Validate the live page URLs with Google's Rich Results Test after publishing.
Full Wix guide →Official Wix docs ↗
How to fix missing schema webpage on Squarespace
  1. In your Squarespace dashboard, go to Settings → Advanced → Code Injection.
  2. Paste your WebPage JSON-LD <script> block into the 'Header' injection field — this applies it site-wide to every page.
  3. To make the schema dynamic (different title/description per page), you'll need to use a static fallback or consider a per-page approach: on individual pages, go to Pages → click the gear icon for a specific page → Advanced → Page Header Code Injection, and paste the page-specific JSON-LD there.
  4. Squarespace does not natively support Liquid/Handlebars variables in code injection fields, so either use static JSON-LD per page or use a third-party SEO app from the Squarespace Extensions marketplace (e.g., 'SEOSpace') that automates schema generation.
  5. Validate injected schema using the Rich Results Test on your live Squarespace domain.
Full Squarespace guide →Official Squarespace docs ↗
How to fix missing schema webpage on Webflow
  1. In the Webflow Designer, open Project Settings → Custom Code tab.
  2. Paste a global WebPage JSON-LD <script> block in the 'Head Code' section for site-wide injection.
  3. For per-page dynamic schema, select a specific page in the Pages panel → click the gear icon → 'Custom Code' → 'Head Code', and paste the page-specific JSON-LD there.
  4. For CMS-driven pages (blog posts, landing pages), open the Collection template page, go to its Page Settings → Custom Code, and use Webflow CMS field embed variables (e.g., {{Name}}, {{Slug}}) inside a custom HTML Embed element placed in the body to output dynamic JSON-LD.
  5. Publish your site and validate with Google's Rich Results Test.
Full Webflow guide →Official Webflow docs ↗
How to fix missing schema webpage on Adobe Commerce (Magento)
  1. The cleanest approach is to create or edit a layout XML file for the relevant page type, e.g., cms_index_index.xml for the homepage, in your custom theme under app/design/frontend/<Vendor>/<theme>/Magento_Cms/layout/.
  2. Add a block of type 'Magento\Framework\View\Element\Template' referencing a .phtml template file that outputs your JSON-LD <script> block, and set the block's container to 'head.additional'.
  3. In the .phtml template, use Magento's escaping helpers and store/page data to dynamically populate name, description, and url fields.
  4. Alternatively, install a structured data extension from the Magento Marketplace (e.g., 'Schema.org Structured Data' by various vendors) which handles WebPage and other schema types automatically across all page types.
  5. After deploying (and flushing the full-page cache: System → Cache Management → Flush Magento Cache), validate with the Rich Results Test.
Full Adobe Commerce (Magento) guide →Official Adobe Commerce (Magento) docs ↗
How to fix missing schema webpage on WordPress.org
  1. Install Yoast SEO or RankMath SEO — both output WebPage and Organization schema automatically.
  2. For Yoast: Yoast SEO → Settings → Site representation → choose 'Organization', fill in name, logo URL, and social profile URLs. WebPage schema is output automatically on every page.
  3. For RankMath: RankMath → Titles & Meta → set a default Schema Type of 'WebPage'. Configure Organization details under RankMath → General Settings → Local SEO.
  4. To add schema manually without a plugin, add a wp_head action hook in your child theme's functions.php that outputs the JSON-LD <script> block, using get_the_title() and get_permalink() for dynamic values.
  5. Validate using Google's Rich Results Test.
Full WordPress.org guide →Official WordPress.org docs ↗
How to fix missing schema webpage on Wix eCommerce
  1. Follow the same steps as standard Wix above — the Structured Data Markup tool and Custom Code injection both apply to Wix eCommerce stores.
  2. For product pages, prioritize adding Product schema (which wraps WebPage context); for non-product pages (homepage, about, policy), add Organization + WebPage schema via Custom Code in the <head>.
  3. Validate using Google's Rich Results Test.
Full Wix eCommerce guide →Official Wix eCommerce docs ↗
How to fix missing schema webpage on Squarespace Commerce
  1. Follow the same steps as standard Squarespace — use Page Header Code Injection for per-page WebPage schema and Site-wide Header Code Injection for Organization schema.
  2. For product pages in Squarespace Commerce, Squarespace auto-generates some Product schema; supplement with a WebPage block via page-level code injection if needed.
  3. Validate using Google's Rich Results Test.
Full Squarespace Commerce guide →Official Squarespace Commerce docs ↗
How to fix missing schema webpage on Webflow Commerce
  1. Follow the same Designer steps as standard Webflow.
  2. For product Collection pages, open the Product template page → gear icon → Head Code, and insert a WebPage JSON-LD block using CMS dynamic fields (e.g. {Product Name}, {Slug}) so every product page gets unique schema values.
  3. For the store homepage and static pages, use Project Settings → Custom Code → Head Code for sitewide Organization schema.
  4. Validate using Google's Rich Results Test after publishing.
Full Webflow Commerce guide →Official Webflow Commerce docs ↗
How to fix missing schema webpage on Next.js
  1. Create a reusable `SchemaMarkup` component at `components/SchemaMarkup.tsx` that accepts `WebPage` and `Organization` JSON-LD props and renders them via a Next.js `<Script>` tag (or a plain `<script>` inside the component) with `type='application/ld+json'`.
  2. Populate the `Organization` schema once with your brand's canonical details (name, URL, logo, sameAs social profiles) — ideally sourced from a central `lib/config.ts` constants file so they never go out of sync.
  3. For the `WebPage` schema, pass per-page values (`name`, `description`, `url`, `breadcrumb`, `dateModified`) as props. In the App Router fetch these from `generateMetadata` data so they share the same fetch; in the Pages Router pass them as `getStaticProps`/`getServerSideProps` return values.
  4. In the *App Router* (`app/`): import `SchemaMarkup` inside every `page.tsx` (or in `app/layout.tsx` for the global `Organization` block) and render it directly in the JSX — Next.js serialises it into the `<head>` automatically.
  5. In the *Pages Router* (`pages/`): import `SchemaMarkup` into `pages/_app.tsx` for the `Organization` block and into each individual page component for the `WebPage` block, or use `next/head` inside the component if you prefer inline `<Head>` management.
  6. Validate the output with Google's Rich Results Test and Schema.org's validator, then confirm the `<script type='application/ld+json'>` tags appear in `view-source` before caching/CDN layers to ensure crawlers see them.
Full Next.js guide →Official Next.js docs ↗
How to fix missing schema webpage on Nuxt.js
  1. Create a reusable composable `composables/useSchemaOrg.ts` that accepts page-level overrides and returns both a `WebPage` and `Organization` JSON-LD object, sourcing site-wide values (name, URL, logo) from `useRuntimeConfig` / `app.config.ts`.
  2. In `app.config.ts` (or `nuxt.config.ts` → `runtimeConfig.public`), add your site-wide Organisation fields: `siteName`, `siteUrl`, `logoUrl`, `socialProfiles[]` so they are available everywhere without hard-coding.
  3. In every page component (e.g. `pages/index.vue`, `pages/products/[slug].vue`), call `useSchemaOrg()` with page-specific values (`name`, `description`, `url`, `breadcrumb`, `dateModified`, etc.) and inject the result into `<head>` via Nuxt's `useHead()` composable as a `<script type='application/ld+json'>` tag.
  4. For dynamic routes (PDPs, PLPs, blog posts), forward the SSR-fetched product/collection data directly into `useSchemaOrg()` inside the same `<script setup>` block so the JSON-LD is rendered server-side and present in the initial HTML.
  5. Use Nuxt Devtools (or `curl` + `grep 'application/ld+json'`) to verify the tags appear in the SSR-rendered HTML, then validate the output with Google's Rich Results Test and Schema.org validator.
Full Nuxt.js guide →Official Nuxt.js docs ↗
How to fix missing schema webpage on Gatsby
  1. Create (or open) a reusable SEO component at `src/components/Seo.jsx`. This component will use Gatsby's *Head API* (exported `Head` function, available in Gatsby v4.19+) to inject JSON-LD `<script>` tags — no third-party helmet library needed.
  2. Inside `Seo.jsx`, compose two JSON-LD objects: a `WebPage` schema (using props like `title`, `description`, `url`, and `breadcrumb`) and an `Organization` schema (using your site's name, logo URL, and canonical URL). Merge them into a JSON-LD `<script type='application/ld+json'>` tag.
  3. Pull global site metadata (name, siteUrl, logo, social links) from `gatsby-config.js` via a `useSiteMetadata` custom hook that calls Gatsby's `useStaticQuery` + `graphql` — this keeps values DRY and sourced from one place.
  4. In every page file (e.g. `src/pages/index.jsx`, `src/pages/products/[handle].jsx`, collection pages, blog posts, etc.) export a named `Head` function that renders `<Seo />` with the page-specific props. Gatsby automatically hoists whatever the `Head` export returns into `<head>`.
  5. For dynamic/template pages created via `gatsby-node.js` (`createPage`), pass `title`, `description`, `url`, and optional `breadcrumb` through the page's `pageContext` so the template's `Head` export can forward them to `<Seo />`.
  6. Run `gatsby build && gatsby serve`, open DevTools → View Page Source, and confirm `<script type='application/ld+json'>` blocks containing `@type: WebPage` and `@type: Organization` appear in the static HTML of every page. Validate with Google's Rich Results Test or schema.org validator.
Full Gatsby guide →Official Gatsby docs ↗
How to fix missing schema webpage on Elementor
  1. Install and activate the Yoast SEO plugin (or RankMath) alongside Elementor — these plugins are the recommended way to inject WebPage schema on Elementor-built pages, since Elementor's native settings do not output schema markup by default.
  2. In the WordPress dashboard, go to Yoast SEO → Search Appearance → Content Types. For each post type (Pages, Posts, Products, etc.), ensure the 'Schema' tab is visible and set 'Page type' to the appropriate WebPage subtype (e.g., WebPage, AboutPage, ContactPage, FAQPage) so the correct schema is emitted site-wide by default.
  3. For individual pages built with Elementor, open the page in the Elementor editor, then click the Yoast SEO metabox at the bottom of the WordPress editor (outside the Elementor canvas) or use the Yoast sidebar panel. Navigate to its 'Schema' tab and override the 'Page type' dropdown to the most precise WebPage subtype for that specific page.
  4. To add or extend WebPage schema with custom properties not covered by Yoast/RankMath, use an Elementor Custom Code snippet: go to Elementor → Custom Code → Add New, set the location to 'Head', and paste a JSON-LD <script> block containing your full WebPage schema object (include @context, @type, name, url, description, and breadcrumb where relevant).
  5. Validate the output by opening any Elementor-built page URL in Google's Rich Results Test (https://search.google.com/test/rich-results) and the Schema Markup Validator (https://validator.schema.org). Confirm that a WebPage (or subtype) entity appears with no critical errors.
  6. If your site uses Elementor Pro's Theme Builder, open the header/footer templates via Elementor → Theme Builder and verify no conflicting or duplicate schema blocks are injected there; remove any manual JSON-LD snippets that conflict with the plugin-generated WebPage schema.
Full Elementor guide →Official Elementor docs ↗
How to fix missing schema webpage on Next.js (Headless)
  1. Create a reusable `WebPageJsonLd` component at `components/seo/WebPageJsonLd.tsx` that accepts page-level props (name, description, url, dateModified, breadcrumb) and renders a `<script type='application/ld+json'>` tag using Next.js's `<Script>` strategy or a plain `<script>` inside the JSX return.
  2. In the App Router, add the `<WebPageJsonLd>` component directly inside each page's default export (e.g. `app/page.tsx`, `app/products/[slug]/page.tsx`, `app/blog/[slug]/page.tsx`) so it is rendered server-side in the HTML response.
  3. For every page, also export a `generateMetadata()` function (or static `metadata` object) to keep the `<title>` and `<meta name='description'>` in sync with the same values passed to `WebPageJsonLd` — single source of truth via a shared `getSeoData()` helper.
  4. Derive the canonical `url` field from `headers().get('host')` + `pathname` (server component) or from a `NEXT_PUBLIC_SITE_URL` environment variable so the schema URL always matches the canonical link.
  5. For content pages (blog, landing pages) use `@type: 'WebPage'`; for product listing pages use `@type: 'CollectionPage'`; for product detail pages use `@type: 'ItemPage'`; for the homepage use `@type: 'WebPage'` with `isPartOf: { @type: 'WebSite', ... }` — pass `pageType` as a prop to the shared component.
  6. Validate the output in Google's Rich Results Test and the Schema.org validator after deployment to confirm every route emits a valid, crawlable JSON-LD block.
Full Next.js (Headless) guide →Official Next.js (Headless) docs ↗

Does your site have this issue?

Run a free SEOLZ scan to find missing schema webpage — and every other issue — across your whole site in minutes.

Scan my site free

Frequently asked questions

What is Missing schema webpage?

Schema markup is a small block of invisible, structured code you add to a web page that tells search engines and AI systems exactly what the page is — its title, description, URL, and type. The `WebPage` schema type is the foundational label that says "this is a web page, here is its name, here is what it's about." Without it, search engines and AI tools have to guess this information by reading your page like a human would, which is less reliable. Think of it like a name tag for your page that any machine can instantly read.

Why does missing schema webpage matter?

Adding `WebPage` schema directly supports Answer Engine Optimization (AEO) — the emerging discipline of making your content eligible to be quoted or cited by AI assistants like Google's AI Overviews, ChatGPT, and Bing Copilot. AI systems rely heavily on structured data to identify authoritative, trustworthy sources to pull answers from; a missing `WebPage` schema means your pages are less likely to be chosen. It also strengthens your baseline for rich results eligibility and helps Google correctly index and understand every page on your site, which supports rankings and organic traffic. For ecommerce stores in particular, this can mean more product pages, category pages, and content pages surfacing in both traditional search results and AI-generated answers.

How do I fix missing schema webpage?

Add WebPage schema markup to every page so search engines and AI answer engines can precisely understand and describe your content.

Authoritative references

Related Answer Engine Optimization issues