IntermediateAgent Skill

Schema (formerly Schema Markup)

Prepare ecommerce schema markup that matches what shoppers can actually see on the page. Give your assistant the rendered content, existing JSON-LD and verified entity details; this Skill helps select suitable schema types, connect related entities and check the markup before a developer adds or updates it on the website.

Views
0
Copies
0
Favorites
0
Editorial Score
83/100
01

What this Skill does

Structured data describes a page in a machine-readable format. This Skill helps review an existing implementation or draft new JSON-LD from the page's actual content, using type examples, entity relationships and validation steps.

Use it when product details, business information or other eligible content are missing from the markup or represented inconsistently. Do not add reviews, prices or claims that the page cannot support. Correct markup is one part of implementation; deployment, live testing and search-feature eligibility must still be checked separately.

02

What makes it different

01

Approach and advantage

Start from visible page facts and choose the schema type around them. Linking related entities helps keep a product, its seller and other page information coherent, while the validation steps expose missing or inconsistent fields.

02

What you can use it for

The workflow separates drafting markup from proving that it works on the deployed page. Use the generated JSON-LD as an implementation artifact, then check current eligibility rules and the live result rather than treating a valid code sample as a rich-result guarantee.

03

Before you install

Inputs to prepare

Rendered page content, existing structured data, entity details, and current eligibility requirements.

Agent and runtime

Use a compatible agent that can discover the installed Skill and read its supporting files. Any external service or creative runtime must be configured separately.

Scope to confirm

Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

04

Install and get started

Copy this request into Codex or Claude Code. The assistant downloads the original repository at the specified commit, installs the complete files and checks required dependencies.

  1. Open Codex or Claude Code with local file and terminal access.
  2. Copy the request below into the app you are using. The assistant will select that app’s installation directory.
  3. Check the returned path and file checks. Start a new session if needed, then ask the assistant to use the installed Skill.
Install schema in the app I am using and carry out the file installation, not just explain it. Original repository: https://github.com/coreyhaines31/marketingskills.git Commit: e85f3cbc2e4a79bf33b2a12e9bdd9087d414735b Skill folder: skills/schema 1. Download this exact source into a new directory. Read SKILL.md and its setup references before running any bundled scripts. Do not substitute another author’s package. 2. For Codex, use ~/.agents/skills/schema; for Claude Code, use ~/.claude/skills/schema. Install only for my current app. Install the complete Skill folder, including scripts, references, assets and bundled notices. Keep any root license with the installed folder. Check all destination folders first; if any already exist, report differences before replacing them. 3. Compare the source and installed file lists and hashes. Inspect documented runtimes, dependencies and required connections. Configure only the local dependencies needed for this Skill; use an isolated environment when appropriate. Ask me to complete any account login locally, without putting credentials in chat. 4. Report the source commit, actual installation path, file-check results and any remaining runtime setup. Explain how to invoke schema in this app. Check discovery separately from file copying; start a new session if needed. Do not run production tasks or claim a successful business outcome from installation alone.
05

Original Skill.md

This is the unchanged source SKILL.md for the reviewed version. Install the complete package to retain referenced scripts, assets, and instructions. Starter prompts below are EcomAgentTools examples.

---
name: schema
description: When the user wants to add, fix, or optimize schema markup and structured data on their site. Also use when the user mentions "schema markup," "structured data," "JSON-LD," "rich snippets," "schema.org," "FAQ schema," "product schema," "review schema," "breadcrumb schema," "Google rich results," "knowledge panel," "star ratings in search," or "add structured data." Use this whenever someone wants their pages to show enhanced results in Google. For broader SEO issues, see seo-audit. For AI search optimization, see ai-seo.
metadata:
  version: 2.0.2
---

# Schema Markup

You are an expert in structured data and schema markup. Your goal is to implement schema.org markup that helps search engines understand content and enables rich results in search.

## Initial Assessment

**Check for product marketing context first:**
If `.agents/product-marketing.md` exists (or `.claude/product-marketing.md`, or the legacy `product-marketing-context.md` filename, in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.

Before implementing schema, understand:

1. **Page Type** - What kind of page? What's the primary content? What rich results are possible?

2. **Current State** - Any existing schema? Errors in implementation? Which rich results already appearing?

3. **Goals** - Which rich results are you targeting? What's the business value?

---

## Core Principles

### 1. Accuracy First
- Schema must accurately represent page content
- Don't markup content that doesn't exist
- Keep updated when content changes

### 2. Use JSON-LD
- Google recommends JSON-LD format
- Easier to implement and maintain
- Place in `<head>` or end of `<body>`

### 3. Follow Google's Guidelines
- Only use markup Google supports
- Avoid spam tactics
- Review eligibility requirements

### 4. Validate Everything
- Test before deploying
- Monitor Search Console
- Fix errors promptly

---

## Common Schema Types

| Type | Use For | Required Properties |
|------|---------|-------------------|
| Organization | Company homepage/about | name, url |
| WebSite | Homepage/site identity | name, url |
| Article | Blog posts, news | headline, image, datePublished, author |
| Product | Product pages | name, image, offers |
| SoftwareApplication | SaaS/app pages | name, offers |
| FAQPage | FAQ content | mainEntity (Q&A array) |
| HowTo | Tutorials | name, step |
| BreadcrumbList | Any page with breadcrumbs | itemListElement |
| LocalBusiness | Local business pages | name, address |
| Event | Events, webinars | name, startDate, location |

**For complete JSON-LD examples**: See [references/schema-examples.md](references/schema-examples.md)

### Check Google Feature Support First

Schema.org vocabulary validity does not establish Google feature eligibility. Before implementing markup for a requested search appearance, check Google's current [supported structured data gallery](https://developers.google.com/search/docs/appearance/structured-data/search-gallery).

- **FAQPage:** Google stopped showing FAQ rich results on May 7, 2026, and removed the feature's documentation in June. The earlier government/health-site exception is no longer a route to FAQ rich results. See Google's [documentation updates](https://developers.google.com/search/updates).
- **HowTo:** Google retired HowTo rich results in September 2023. See the [retirement announcement](https://developers.google.com/search/blog/2023/08/howto-faq-changes).
- **WebSite / SearchAction:** Google retired the sitelinks search box in November 2024; `WebSite` still supports site names. See the [search box announcement](https://developers.google.com/search/blog/2024/10/sitelinks-search-box).

These types can still describe matching visible content in Schema.org. Explain that distinction, ask which consumer needs the markup, and do not recommend implementation to obtain a retired Google appearance. Do not treat missing retired-feature reports or Rich Results Test detection as a broken implementation, or remove unrelated supported markup.

---

## Quick Reference

### Organization (Company Page)
Required: name, url
Recommended: logo, sameAs (social profiles), contactPoint

### Article/BlogPosting
Required: headline, image, datePublished, author
Recommended: dateModified, publisher, description

### Product
Required: name, image, offers (price + availability)
Recommended: sku, brand, aggregateRating, review

### FAQPage
Required: mainEntity (array of Question/Answer pairs)
Optional semantic markup for visible FAQs; not a way to obtain Google FAQ rich results. Check the feature-support guidance above before offering code.

### BreadcrumbList
Required: itemListElement (array with position, name, item)

---

## Multiple Schema Types

You can combine multiple schema types on one page using `@graph`:

```json
{
  "@context": "https://schema.org",
  "@graph": [
    { "@type": "Organization", ... },
    { "@type": "WebSite", ... },
    { "@type": "BreadcrumbList", ... }
  ]
}
```

---

## Validation and Testing

### Tools
- **Google Rich Results Test**: https://search.google.com/test/rich-results — test Google's currently supported features, not every Schema.org type
- **Schema.org Validator**: https://validator.schema.org/
- **Search Console**: available enhancement reports for supported features; retired types need not have a report

### Common Errors

**Missing required properties** - Check Google's documentation for required fields

**Invalid values** - Dates must be ISO 8601, URLs fully qualified, enumerations exact

**Mismatch with page content** - Schema doesn't match visible content

---

## Implementation

### Static Sites
- Add JSON-LD directly in HTML template
- Use includes/partials for reusable schema

### Dynamic Sites (React, Next.js)
- Component that renders schema
- Server-side rendered for SEO
- Serialize data to JSON-LD

### CMS / WordPress
- Plugins (Yoast, Rank Math, Schema Pro)
- Theme modifications
- Custom fields to structured data

---

## Output Format

### Schema Implementation
```json
// Full JSON-LD code block
{
  "@context": "https://schema.org",
  "@type": "...",
  // Complete markup
}
```

### Testing Checklist
- [ ] Requested Google appearance is currently supported, or a separate semantic consumer is identified
- [ ] Validates in Schema.org Validator; supported Google features also pass Rich Results Test
- [ ] Required-field errors resolved; recommended-field warnings reviewed
- [ ] Matches page content
- [ ] All required properties included

---

## Task-Specific Questions

1. What type of page is this?
2. What rich results are you hoping to achieve?
3. What data is available to populate the schema?
4. Is there existing schema on the page?
5. What's your tech stack?

---

## Related Skills

- **seo-audit**: For overall SEO including schema review
- **ai-seo**: For AI search optimization (schema helps AI understand content)
- **programmatic-seo**: For templated schema at scale
- **site-architecture**: For breadcrumb structure and navigation schema planning
06

Get started

Starter prompts for the main use cases—copy and use them directly.

01

Draft Product markup from confirmed page facts

Draft Product markup from confirmed page facts Use for: Draft Product markup from confirmed page facts. Prepare: Rendered page content, existing structured data, entity details, and current eligibility requirements.

Show prompt and variablesHide prompt and variables
Use the installed schema Skill. Task: Draft Product markup from confirmed page facts. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

Replace these variables

[INPUT]
Rendered page content, existing structured data, entity details, and current eligibility requirements.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
02

Repair conflicting entities and breadcrumb markup

Repair conflicting entities and breadcrumb markup Use for: Repair conflicting entities and breadcrumb markup. Prepare: Rendered page content, existing structured data, entity details, and current eligibility requirements.

Show prompt and variablesHide prompt and variables
Use the installed schema Skill. Task: Repair conflicting entities and breadcrumb markup. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

Replace these variables

[INPUT]
Rendered page content, existing structured data, entity details, and current eligibility requirements.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
03

Prepare validation checks for a JSON-LD change

Prepare validation checks for a JSON-LD change Use for: Prepare validation checks for a JSON-LD change. Prepare: Rendered page content, existing structured data, entity details, and current eligibility requirements.

Show prompt and variablesHide prompt and variables
Use the installed schema Skill. Task: Prepare validation checks for a JSON-LD change. Inputs: [INPUT]. Constraints: [CONSTRAINTS]. Check missing information first. Produce a reviewable result with evidence, assumptions, and next steps. Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

Replace these variables

[INPUT]
Rendered page content, existing structured data, entity details, and current eligibility requirements.
[CONSTRAINTS]
Scope, allowed actions, output format, and review requirements.
07

Worked example: Embed product price and stock in parseable JSON-LD

A synthetic product business brief needs Product and Offer markup embedded in HTML that matches visible content. No ratings, reviews or GTINs are supplied, so none should be invented.

Steps and prompt

  1. Prepare the attached business materials, preserving amounts, units, dates and metric definitions.
  2. Prepare Product and Offer structured data for the supplied product record and embed it in a complete example product page. Ensure the visible name, price, currency and stock state agree with the JSON-LD. Return the HTML and JSON-LD, validate the JSON and inspect the rendered page. Do not add aggregate ratings or reviews we have not supplied.
  3. Submit the exact prompt below. Read the primary deliverable on the right and download all deliverables for the team handoff.

Case input files: business-inputs.zip

Use the schema-markup Skill.

Prepare Product and Offer structured data for the supplied product record and embed it in a complete example product page. Ensure the visible name, price, currency and stock state agree with the JSON-LD. Return the HTML and JSON-LD, validate the JSON and inspect the rendered page. Do not add aggregate ratings or reviews we have not supplied.

The attached business materials are:
- inputs/product.json

Deliver a complete result.md report that the operations team can read, plus any finished files needed for this task. Keep supporting calculations and evidence with the deliverables. Write the report in English; use the requested target language for customer-facing copy. The business datasets are fictional examples unless the brief explicitly names a live public website.

What the run produced

The primary file produced by this prompt is shown below in its original language.

Product and Offer markup matched to the visible example

The completed product.html and product.jsonld use only the five supplied product fields. The page shows HarborMug Blue Insulated Stainless Steel Mug, SKU HM-BLUE-001, price 24.00 USD and In stock. JSON-LD expresses the same offer with the Schema.org InStock URL.

Implemented JSON-LD

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "HarborMug Blue Insulated Stainless Steel Mug",
  "sku": "HM-BLUE-001",
  "offers": {
    "@type": "Offer",
    "price": "24.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock"
  }
}

Checks actually completed

The JSON parsed successfully. Chromium rendered the complete example page; the product name, SKU, price, currency and stock text were checked against the JSON-LD. The example has one H1 and a server-delivered JSON-LD script. No aggregate rating, customer review, image URL, GTIN, sale expiry or shipping entitlement was invented. render-validation.json contains the observed DOM and parsed data.

Before merchant publication

A product photograph was not supplied. Obtain the real image and final product URL before targeting merchant listing eligibility; do not use a placeholder image as product evidence. Google distinguishes product snippets from merchant listings and provides feature-specific requirements. See product snippets and merchant listings, inspected for this execution.

This run verifies JSON syntax and visible-data parity; it does not claim a Google Rich Results Test pass, Search Console approval or search appearance. The reserved store.example domain identifies a fictional implementation specimen. On the real store, use the approved URL, add the real image and run the appropriate external validators before release. Keep price and availability sourced from the same record as the visible page so later stock changes cannot leave stale markup.

Merchant business data is synthetic. Website observations, when present, come from the public URLs listed in the report.

08

Risks and operating notes

Known limits

Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

Evidence and review

Source and package files reviewed: GitHub e85f3cbc2e4a. Current package identifier: schema. This is a static review, not an installation or business-outcome test.

Before acting on the result

Use authorized inputs and keep secrets out of prompts. Review customer-facing claims, calculations, code changes, and any proposed external action before applying them.

Frequently asked questions

What does it do, and what is the advantage?

Draft or repair JSON-LD that matches the visible page content. The current skill is named schema and includes type examples, entity linking, and validation steps.

How do I install it and start?

Choose the method for your agent and install the complete package, not just the displayed SKILL.md. Rendered page content, existing structured data, entity details, and current eligibility requirements. Start a new agent session and explicitly ask to use schema. Try one use case below with a small sample and review the output.

Which situations is it useful for?

Draft Product markup from confirmed page facts; Repair conflicting entities and breadcrumb markup; Prepare validation checks for a JSON-LD change

What limitations should I know?

Markup cannot guarantee rich results. Do not invent prices, reviews, or eligibility; deployment and live validation are separate.

What was checked for this page?

Source and package files reviewed: GitHub e85f3cbc2e4a. Current package identifier: schema. This is a static review, not an installation or business-outcome test.

No reviews yet.

Leave a review

Rate every dimension, then share your real experience.

Task effectiveness
Setup and ease of use
Reliability and guardrails
Documentation clarity
Time to first useful result
Author / maintainer

Corey Haines

Source and package files reviewed: GitHub e85f3cbc2e4a. Current package identifier: schema. This is a static review, not an installation or business-outcome test.