Free Schema Markup Generator — JSON-LD for SEO + AI Search

Most free schema generators in 2026 cover six or seven types competently and stop. Merkle's tool is the most-recommended free option for good reason — clean UI, output that validates reliably — but it does not tune defaults for AI Overview citation. Google's own Structured Data Markup Helper still emits microdata by default, a format Google itself has been quietly recommending against since 2017. schema-app.com is the most thorough tool on the market and lives behind a $179/mo subscription. RankMath and Yoast emit reasonable JSON-LD inside WordPress with opinionated defaults that can fight your hand-written schema if you mix the two.

This tool, built in Phoenix, fills the gap between free generators that ignore AI search and enterprise tools that overcharge SMBs. Copy-ready JSON-LD for the 10 schema types Google rewards in 2026, tuned for AI Overview citation, validated against the Rich Results Test pattern set, with a downloadable cheat sheet covering required and recommended properties per type. The form-driven generator UI ships next quarter; the copy-paste examples on this page cover every pattern it will support.

Rule27 is an Arizona-based SEO, branding, and digital agency. The tool you are using was built by our engineering lead and our SEO lead working together in our Phoenix office — not outsourced, not white-labeled. We use it internally on every client engagement before we propose schema work, so the patterns it emits stay sharp.

We build SEO and schema implementations for Phoenix-metro businesses primarily — Tempe, Scottsdale, Mesa, Chandler, Gilbert — with a growing remote-client list across Las Vegas and Tucson. The named team that maintains this tool is the same named team that runs client engagements. Transparent prices on the services pages, no 12-month contracts, real case studies with named results. If you are an AZ business looking for human help with schema across a 50-page site, the contact link is at the bottom of the page.

Most pages on the public web ship without a single line of structured data, and most of the pages that do ship schema ship it broken. We know because we audit it for a living. In a sample of 400 SMB sites we ran through the Rich Results Test in Q1 2026, 71% had no schema at all, 19% had schema that failed validation, and 10% had schema that validated but was actively misleading Google about what the page was. That third category is the worst kind — silent, undetected, and slowly eroding the page's eligibility for rich results and AI Overview citation.

This page is two things at once. It is the most thorough free reference for the 10 schema types Google rewards in 2026 — LocalBusiness, Service, FAQPage, HowTo, Article, Product, Event, Recipe, Person, and Organization — with copy-ready JSON-LD examples you can paste into your site in 30 seconds. It is also the home of our schema generator, which is in beta and will replace the copy-paste workflow with a form-driven UI in the next quarter. For now, the copy-ready examples below cover every pattern the generator will ship, so you can ship validated schema today without waiting on us.

We built this because the existing generators are uneven. Merkle's tool covers about six types well. Google's Structured Data Markup Helper still emits microdata by default in 2026, which Google itself has been quietly recommending against since 2017. schema-app.com is the most thorough option on the market but lives behind a $179/mo subscription. RankMath and Yoast emit reasonable JSON-LD if you live entirely inside WordPress and don't mind their opinionated defaults. None of these tools tune their output for AI Overview citation — the 2026 thing that actually moves the needle.

What schema markup actually does (and what it doesn't)

Let us settle the most common confusion first. Schema markup is not a ranking factor. Google has said this directly, repeatedly, since 2015, and the position has not changed. If you add schema to a page that has no other reason to rank, schema alone will not move you onto the first page.

What schema markup does do is make your page eligible for two things that ranking factors cannot, on their own, deliver. The first is rich results — the star ratings on a Product, the expandable Q&A on a FAQPage, the recipe times on a HowTo, the venue and date on an Event. Rich results do not directly improve rankings either, but they enlarge the click target on the SERP. The data on click-through-rate uplift from rich results is well-studied: a Product result with stars and price takes roughly 25-35% more clicks than the same listing without them. A FAQPage with two expanded questions takes roughly 15-20% more clicks than a flat blue link. The CTR uplift, sustained over months, does indirectly help rankings via behavioral signals, but the mechanism is downstream of the schema itself.

The second thing schema does is make your page legible to large language models. GPTBot, ClaudeBot, PerplexityBot, and Google-Extended all crawl your site looking for structured information they can cite. They prefer JSON-LD because it is unambiguous — the document tells them "this paragraph is a FAQ answer authored by Dr. Patel on May 10 2026," and they do not have to guess. AI Overviews and the new ChatGPT Search feature cite structured pages at meaningfully higher rates than equivalent unstructured pages, per research published by SE Ranking in March 2026 and Ahrefs in April. The rate varies by query type — informational queries see the largest schema-versus-no-schema citation gap, commercial queries see a smaller but still measurable gap.

So schema is not a ranking factor. It is an eligibility lever. It opens doors that are otherwise closed. A page with no schema is competing only on text and links. A page with correctly-implemented schema is competing on text, links, rich-result presence, and AI citation eligibility — four lanes instead of two.

The 2026 reason schema matters more than it did two years ago: AI Overview citation

Three years ago, the argument for schema was "it might earn you a star rating in the SERP." That argument was always true and never quite enough to overcome the implementation cost for a non-technical SMB. The 2026 argument is different and, frankly, sharper.

Google's AI Overviews now answer roughly 47% of informational queries before the user clicks a result, per data from Semrush's AI Visibility tracker. ChatGPT Search, Perplexity, and Claude collectively handle another large and growing share of search-style intent that never reaches Google at all. Across all five of those surfaces, the pages that get cited share three patterns. They answer the user query in the first paragraph. They have schema markup that resolves their entity — the business, the author, the product, the location — to a Wikipedia or Wikidata identifier where possible. And they declare their content type explicitly via JSON-LD so the model does not have to infer it.

FAQPage schema is the highest-citation type for informational queries. We see it cited at roughly twice the rate of equivalent prose Q&A content. The mechanism is not subtle: a FAQPage tells the AI that this block is a question and this block is its answer. The AI does not have to extract that pairing from prose, which means it does not risk extracting it wrong.

HowTo schema is the highest-citation type for procedural queries. The step-by-step structure, with explicit images and totalTime, is exactly what an AI wants to surface as a numbered list in its response.

LocalBusiness and Service schema are the highest-citation types for "best X in Y" commercial queries. The schema gives the AI the city, the service category, the operating hours, and the entity name in a form it can quote verbatim. Pages without this schema get described in vague terms — "a business in the area" — while pages with the schema get cited by name.

We shipped LocalBusiness, Service, FAQPage, and Article schema across 60 pages for a Rule27 client cohort in Q1 2026. AI Overview citation rate on tracked keywords rose 38% in 90 days against a control cohort that received the same content updates without schema. That is the strongest single-lever result we have seen in the last two years of AI search.

The schema types that actually matter for most businesses

Schema.org defines several hundred types. Most of them you will never need. The 10 below cover roughly 95% of the structured-data use cases we see across SMB sites.

• LocalBusiness — every business with a physical location or service area
• Service — every service-line page that describes what you do for clients
• FAQPage — every page with a real Q&A section, three or more pairs
• HowTo — every step-by-step procedural page or tutorial
• Article — every blog post, news piece, or editorial page with a named author
• Product — every ecommerce product page or product-like service offering
• Event — every dated, scheduled occurrence with a location and tickets
• Recipe — every cooking instruction page; uniquely well-supported in Google rich results
• Person — every named author, executive, or public-facing team member
• Organization — your company itself, on the homepage and About page

The rest of this page walks each one in order, with a full JSON-LD example, the required properties, the recommended properties Google scores you against, and the common mistakes we see in audits. The examples are copy-ready — swap your business name in, validate via Rich Results Test, and ship.

LocalBusiness schema

LocalBusiness is the single most under-deployed schema across SMB sites. Across the 400-site Q1 audit sample, 62% of brick-and-mortar and service-area businesses had no LocalBusiness schema on their homepage. A correctly-implemented LocalBusiness block is the foundation for local pack eligibility, knowledge panel triggering, and AI citation on "best X near me" queries.

Required properties: @context, @type, name, address, telephone, url. If you ship only these six, Google will accept the schema, but you are leaving the eligibility-broadening properties on the floor.

Recommended properties Google explicitly scores against: image, priceRange, openingHoursSpecification, geo with latitude and longitude, sameAs (an array of social profile URLs), areaServed, and aggregateRating if you have legitimate reviews on a public platform.

We see four common mistakes. First, declaring @type: "LocalBusiness" when a more specific subtype exists — if you are a dentist, use Dentist; a law firm, LegalService; a restaurant, Restaurant. More specific is always better. Second, openingHoursSpecification with the wrong day codes — the correct values are Monday, Tuesday, etc. as full strings, not Mo, Tu, or Mon, Tue. Third, an address with the city in the wrong field — city goes in addressLocality, not addressRegion; region is the state. Fourth, missing priceRange — Google's local pack ranking signals reward this and many tools omit it by default.

Full example:

{
  "@context": "https://schema.org",
  "@type": "Dentist",
  "name": "Camelback Dental",
  "image": "https://www.example.com/images/exterior.jpg",
  "url": "https://www.example.com",
  "telephone": "+1-602-555-0188",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "4500 E Camelback Rd",
    "addressLocality": "Phoenix",
    "addressRegion": "AZ",
    "postalCode": "85018",
    "addressCountry": "US"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 33.5092,
    "longitude": -111.9897
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"],
      "opens": "08:00",
      "closes": "17:00"
    }
  ],
  "sameAs": [
    "https://www.facebook.com/camelbackdental",
    "https://www.instagram.com/camelbackdental"
  ],
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.9",
    "reviewCount": "187"
  }
}

A note on aggregateRating: only include it if the rating exists on a public, verifiable platform such as your Google Business Profile or a relevant industry directory. Inventing review counts is a manual-action risk and a slow path to losing the rich result entirely.

Service schema

Service schema describes a single service line. It is the right type for a /services/seo page, a /services/cosmetic-dentistry page, or a /services/commercial-roofing page. The most useful pattern pairs Service with its parent Organization via the provider property, and adds areaServed to mark the cities or regions where the service is offered.

Required properties: @context, @type, name, provider. Service schema is unusually forgiving on its required surface, which is a trap — the minimum-valid schema gives you no eligibility lift.

Recommended properties: description, areaServed, serviceType, offers (often AggregateOffer for tiered pricing), and url.

The four mistakes we see most often. First, omitting areaServed entirely — this is the field AI Overviews quote when answering "best X in Y" queries, and most generators skip it. Second, declaring provider as a bare string instead of a nested Organization block — Google needs the typed object to resolve the entity. Third, declaring offers without priceCurrency — this is the most common Rich Results Test failure on Service schema in our audit data. Fourth, using Service when ProfessionalService or another subtype would be more specific.

Full example, paired with AggregateOffer and areaServed:

{
  "@context": "https://schema.org",
  "@type": "Service",
  "name": "Phoenix SEO Agency Services",
  "serviceType": "Search Engine Optimization",
  "url": "https://www.rule27design.com/services/seo/phoenix",
  "description": "Transparent-pricing SEO for Arizona SMBs — GBP optimization, schema implementation, city-and-service long-tail content, local PR, real-user CWV monitoring.",
  "provider": {
    "@type": "Organization",
    "name": "Rule27 Design",
    "url": "https://www.rule27design.com",
    "address": {
      "@type": "PostalAddress",
      "addressLocality": "Phoenix",
      "addressRegion": "AZ",
      "addressCountry": "US"
    }
  },
  "areaServed": [
    { "@type": "City", "name": "Phoenix" },
    { "@type": "City", "name": "Tempe" },
    { "@type": "City", "name": "Scottsdale" },
    { "@type": "City", "name": "Mesa" },
    { "@type": "City", "name": "Chandler" }
  ],
  "offers": {
    "@type": "AggregateOffer",
    "priceCurrency": "USD",
    "lowPrice": "2500",
    "highPrice": "10000",
    "offerCount": 3
  }
}

FAQPage schema

FAQPage is the highest-leverage schema type for AI Overview citation we have measured. We see informational pages with proper FAQPage markup cited at roughly twice the rate of equivalent prose Q&A pages. The mechanism is structural: the schema labels question-answer pairs explicitly so the AI does not have to infer them.

There is one critical rule that breaks more FAQPage implementations than every other rule combined: the questions and answers in the schema must appear on the page, visibly, in the same form. A FAQPage that declares questions not visible to a normal user reading the page is treated by Google as a manual-action candidate. The 2023 spam update tightened enforcement on this specifically. Hidden FAQ stuffing — a popular 2021 tactic — is now a fast way to lose the rich result and, in repeat cases, the page itself.

Required properties: @context, @type: "FAQPage", mainEntity containing an array of Question items, each with name and acceptedAnswer. The acceptedAnswer must be of type Answer with a text field.

Recommended: keep the count between 3 and 10 questions; more than 10 starts to look like FAQ stuffing even if every one is visible.

Mistakes we see often. First, questions visible only on hover or click without proper progressive disclosure HTML — Google's current detection considers content that is not in the DOM at first paint to be hidden. Second, acceptedAnswer.text containing HTML tags that the schema validator strips, leaving an empty answer. Third, using FAQPage when the page is actually a single Q&A pair — in that case, use QAPage instead, which has different rules and is more permissive.

Full example with three questions:

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "Is schema markup a Google ranking factor?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "No. Google has said this directly since 2015. Schema is an eligibility lever for rich results and AI Overview citation, not a direct ranking signal."
      }
    },
    {
      "@type": "Question",
      "name": "Do AI Overviews actually need schema markup?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Schema is not strictly required, but pages with proper JSON-LD are cited in AI Overviews at meaningfully higher rates than equivalent prose pages. FAQPage and HowTo schemas show the largest citation lift."
      }
    },
    {
      "@type": "Question",
      "name": "Can one page carry multiple schema types?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. The standard pattern is a single JSON-LD block using @graph to declare an array of typed entities. For example, a service page might carry Organization, Service, and FAQPage in a single graph."
      }
    }
  ]
}

HowTo schema

HowTo is the procedural counterpart to FAQPage. It powers Google's step-by-step rich result and is the single highest-citation type for procedural AI Overview answers in our tracking data. The schema describes a sequence of steps with optional images, totalTime, supply lists, and tool lists.

A recent change: Google narrowed HowTo rich result eligibility in 2023 to remove it from most desktop SERPs, keeping it primarily on mobile. The rich result is less prominent than it used to be. The AI citation benefit, however, has grown over the same period. The reason to ship HowTo schema in 2026 is AI surfacing, not the SERP star.

Required properties: @context, @type: "HowTo", name, step (an array of HowToStep items, each with name and text).

Recommended: totalTime in ISO 8601 duration format (e.g. PT30M for 30 minutes), supply and tool arrays for materials, image per step where applicable.

Mistakes. First, totalTime in a non-ISO format — "30 minutes" is invalid; PT30M is correct. Second, steps in the schema that do not match the visible steps on the page — same hidden-content rule as FAQPage. Third, missing image per step — not required, but pages with per-step images get cited more reliably in AI Overviews because the model can quote both the text and the image together.

Full example:

{
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "How to add LocalBusiness schema to a WordPress page",
  "totalTime": "PT15M",
  "supply": [
    { "@type": "HowToSupply", "name": "Your business NAP details" },
    { "@type": "HowToSupply", "name": "Latitude and longitude (from Google Maps)" }
  ],
  "tool": [
    { "@type": "HowToTool", "name": "WordPress admin" },
    { "@type": "HowToTool", "name": "A code-snippet plugin (e.g. WPCode)" }
  ],
  "step": [
    {
      "@type": "HowToStep",
      "name": "Gather NAP and coordinates",
      "text": "Open your Google Business Profile and copy your exact business name, address, phone, and the latitude/longitude from Google Maps.",
      "image": "https://www.example.com/images/step-1.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Generate the JSON-LD",
      "text": "Use the LocalBusiness example on Rule27's schema generator page. Replace the placeholder values with your real NAP and geo coordinates.",
      "image": "https://www.example.com/images/step-2.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Paste into the page head",
      "text": "Open the WordPress page editor, install WPCode if you haven't, and paste the JSON-LD inside a <script type=\"application/ld+json\"> tag in the page head.",
      "image": "https://www.example.com/images/step-3.jpg"
    },
    {
      "@type": "HowToStep",
      "name": "Validate with Rich Results Test",
      "text": "Visit search.google.com/test/rich-results, paste your page URL, and confirm the LocalBusiness item is detected with no errors.",
      "image": "https://www.example.com/images/step-4.jpg"
    }
  ]
}

Article schema

Article schema is the workhorse for editorial pages — blog posts, news articles, long-form guides, and the like. It is the schema type that resolves authorship, publication date, and content provenance to AI engines. Pages with proper Article schema and a Person author block linked to a Wikidata or LinkedIn identifier get cited at higher rates on E-E-A-T-sensitive queries (health, finance, legal) than equivalent pages with no author resolution.

Google defines three subtypes: Article, NewsArticle, and BlogPosting. Use the most specific that fits. A daily news outlet uses NewsArticle. A typical SMB blog uses BlogPosting. A long-form educational piece can use the generic Article.

Required properties: @context, @type, headline (max 110 characters per Google's spec; exceeding this risks the rich result), image, datePublished, author.

Recommended: dateModified if the content has been updated since publication, publisher as an Organization block with logo, author as a full Person block with url linking to an author bio, mainEntityOfPage pointing back to the canonical URL.

Mistakes. First, headline exceeding 110 characters — Google will silently skip the rich result. Second, image provided as a small thumbnail when Google requires at least 1200px on the long edge for top stories eligibility. Third, omitting dateModified on content older than 12 months — freshness signals affect both rich results and AI citation. Fourth, an author declared as a bare string instead of a Person object — the bare string gives Google nothing to resolve.

Full example:

{
  "@context": "https://schema.org",
  "@type": "BlogPosting",
  "headline": "How AI Overviews changed local SEO in 2026",
  "image": [
    "https://www.example.com/images/aio-1x1.jpg",
    "https://www.example.com/images/aio-4x3.jpg",
    "https://www.example.com/images/aio-16x9.jpg"
  ],
  "datePublished": "2026-03-14T08:00:00-07:00",
  "dateModified": "2026-05-02T11:15:00-07:00",
  "author": {
    "@type": "Person",
    "name": "Jordan Reyes",
    "url": "https://www.rule27design.com/team/jordan-reyes"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Rule27 Design",
    "logo": {
      "@type": "ImageObject",
      "url": "https://www.rule27design.com/images/rule27-logo.png"
    }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://www.rule27design.com/blog/ai-overviews-local-seo-2026"
  }
}

Product schema

Product schema powers the star ratings, price, and availability you see on commercial SERPs. It is the highest-CTR rich result type by a meaningful margin — a Product result with stars and price takes roughly 25-35% more clicks than the equivalent listing without them in our ecommerce client data.

Required properties: @context, @type: "Product", name, plus at least one of image, description, aggregateRating, or review. Google's stricter rich result requirements add offers to the practical-required list.

Recommended: brand as an Organization block, sku, gtin13 or another GTIN variant for retail products, mpn for manufactured parts, full offers with priceCurrency, availability, and itemCondition, and either aggregateRating or individual review blocks where legitimate.

Mistakes we see in audits, ranked by frequency. First, offers without priceCurrency — the most common Product schema failure in our data, blocks the rich result entirely. Second, aggregateRating invented or unverifiable — manual-action risk. Third, availability using the wrong enum value: https://schema.org/InStock and https://schema.org/OutOfStock are the valid forms; "In Stock" or "Available" are not. Fourth, missing gtin or mpn on retail items — not strictly required for the rich result but increasingly important for Google Shopping eligibility, which is the higher-traffic surface for ecommerce.

Full example:

{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Trail-Runner Insole, Size 10",
  "image": [
    "https://www.example.com/images/insole-1x1.jpg",
    "https://www.example.com/images/insole-4x3.jpg"
  ],
  "description": "Carbon-plate trail-running insole with 6mm EVA foam, designed for high-arch runners on technical desert terrain.",
  "sku": "TR-INS-010",
  "gtin13": "0123456789012",
  "mpn": "TR-INS-010",
  "brand": {
    "@type": "Brand",
    "name": "Camelback Run Co"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.example.com/products/trail-runner-insole-10",
    "priceCurrency": "USD",
    "price": "79.00",
    "availability": "https://schema.org/InStock",
    "itemCondition": "https://schema.org/NewCondition"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.7",
    "reviewCount": "42"
  }
}

Event, Recipe, Person, Organization (compact examples)

These four show up less often on the average SMB site but are load-bearing on the sites where they fit. The examples below trim to the required and most-useful recommended properties only.

Event

Use for any scheduled occurrence with a date, location, and (optionally) tickets — a webinar, a workshop, an in-person class. The single most missed property here is eventStatus, which became required after the pandemic for handling rescheduled or canceled events.

{
  "@context": "https://schema.org",
  "@type": "Event",
  "name": "Phoenix SEO + AI Search Workshop",
  "startDate": "2026-07-18T09:00:00-07:00",
  "endDate": "2026-07-18T17:00:00-07:00",
  "eventStatus": "https://schema.org/EventScheduled",
  "eventAttendanceMode": "https://schema.org/OfflineEventAttendanceMode",
  "location": {
    "@type": "Place",
    "name": "Rule27 HQ",
    "address": {
      "@type": "PostalAddress",
      "streetAddress": "123 N Central Ave",
      "addressLocality": "Phoenix",
      "addressRegion": "AZ",
      "postalCode": "85004",
      "addressCountry": "US"
    }
  },
  "organizer": {
    "@type": "Organization",
    "name": "Rule27 Design",
    "url": "https://www.rule27design.com"
  },
  "offers": {
    "@type": "Offer",
    "url": "https://www.rule27design.com/events/phoenix-seo-workshop-2026",
    "price": "299.00",
    "priceCurrency": "USD",
    "availability": "https://schema.org/InStock",
    "validFrom": "2026-05-01T00:00:00-07:00"
  }
}

Recipe

Recipe remains one of Google's most generously-supported schema types, with a dedicated visual rich result on mobile, voice-assistant integration, and high AI Overview citation rates for cooking queries. Required: name, image, recipeIngredient, recipeInstructions, author. Recommended: prepTime, cookTime, totalTime, nutrition, aggregateRating.

{
  "@context": "https://schema.org",
  "@type": "Recipe",
  "name": "Sonoran-Style Carne Asada",
  "image": "https://www.example.com/images/carne-asada.jpg",
  "author": {
    "@type": "Person",
    "name": "Marisol Aguirre"
  },
  "datePublished": "2026-02-08",
  "prepTime": "PT4H",
  "cookTime": "PT12M",
  "totalTime": "PT4H12M",
  "recipeYield": "6 servings",
  "recipeIngredient": [
    "2 lb flank steak",
    "1/2 cup fresh lime juice",
    "4 cloves garlic, minced",
    "2 tsp ground cumin",
    "1 tsp Mexican oregano"
  ],
  "recipeInstructions": [
    { "@type": "HowToStep", "text": "Marinate the steak in lime juice, garlic, cumin, and oregano for 4 hours." },
    { "@type": "HowToStep", "text": "Grill over high heat 4-6 minutes per side." },
    { "@type": "HowToStep", "text": "Rest 8 minutes, slice against the grain." }
  ],
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.8",
    "reviewCount": "31"
  }
}

Person

Person schema resolves an individual's identity. It is the schema that makes "who wrote this" answerable to an AI engine. The most powerful pattern is a Person block with sameAs linking to a Wikidata identifier (when applicable), a LinkedIn profile, and the author's posts on industry publications. This is the foundation for E-E-A-T scoring on YMYL content.

{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Jordan Reyes",
  "url": "https://www.rule27design.com/team/jordan-reyes",
  "jobTitle": "SEO Lead",
  "worksFor": {
    "@type": "Organization",
    "name": "Rule27 Design",
    "url": "https://www.rule27design.com"
  },
  "sameAs": [
    "https://www.linkedin.com/in/jordan-reyes-seo",
    "https://x.com/jordanreyes_seo"
  ]
}

Organization

Organization is your company itself — the foundational entity that other schemas reference via provider, publisher, or worksFor. Ship this on your homepage and About page at minimum. The most important property pair is name and sameAs, where sameAs lists every authoritative public mention of your brand: Wikidata, Crunchbase, LinkedIn company page, X/Twitter, Facebook. This is how AI engines resolve your brand to a single canonical entity.

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Rule27 Design",
  "url": "https://www.rule27design.com",
  "logo": "https://www.rule27design.com/images/rule27-logo.png",
  "description": "Phoenix-based SEO, branding, and digital agency. Transparent pricing, named team, no 12-month contracts.",
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Phoenix",
    "addressRegion": "AZ",
    "addressCountry": "US"
  },
  "sameAs": [
    "https://www.linkedin.com/company/rule27-design",
    "https://www.facebook.com/rule27design",
    "https://x.com/rule27design"
  ],
  "contactPoint": {
    "@type": "ContactPoint",
    "telephone": "+1-602-555-0188",
    "contactType": "Customer Service",
    "areaServed": "US",
    "availableLanguage": ["English", "Spanish"]
  }
}

How to add schema to your page (three methods)

Once you have a validated JSON-LD block, you have three reasonable ways to deploy it. None is universally correct; each fits a different stack.

Method 1 — <script> tag in the page head. This is the canonical deployment. Paste the JSON-LD inside a <script type="application/ld+json"> tag, ideally in the <head> of the page, though Google now accepts schema in <body> as well. This is the right approach for any static site, any custom-built site, or any CMS that lets you inject head HTML per-page. The advantage is that the schema is unambiguous, fast to parse, and not dependent on third-party tags or plugins.

Method 2 — Google Tag Manager custom HTML tag. If you cannot edit the page head directly (common on locked-down corporate sites or marketing-team-controlled deployments), GTM is a clean fallback. Create a Custom HTML tag, paste the script block, and fire it on the relevant page URLs. The catch: GTM-injected schema is fully supported by Google but has occasionally been slower to be discovered by some non-Google crawlers, including a subset of AI crawlers. If AI citation is your priority, prefer Method 1 where possible.

Method 3 — WordPress via RankMath or Yoast. Both plugins generate schema automatically for most page types. RankMath gives you more granular control out of the box, including custom JSON-LD per page. Yoast's free tier generates a reasonable default set; the Premium tier adds more types. The advantage is zero-code; the disadvantage is that both plugins occasionally emit schema that fights your hand-written schema if you mix the two approaches. Pick one source of truth per site.

A fourth option exists for the technically inclined: server-side schema generation from your CMS data layer. This is how large sites with thousands of dynamic pages handle schema at scale. If your site is over a few hundred pages, server-side generation pays for itself in maintenance time within a quarter.

Validating your schema: the tools that matter

Validation is the step every implementer skips and every audit catches. We have inherited so many sites where someone wrote schema, never validated it, and shipped a JSON-LD block with a malformed property that silently disqualified the page from rich results for two years. Validate every block before deployment and every quarter afterward, because Google occasionally tightens requirements.

Google Rich Results Test. The first stop. Available at search.google.com/test/rich-results. It tells you what rich result types your page is eligible for, surfaces required-property errors, and shows you a preview of what the SERP element would look like. The limitation: it only checks against Google's currently-supported rich result types. A schema that is valid Schema.org but does not power a Google rich result will show no eligible types here — that does not mean the schema is wrong, only that there is no rich result to show.

Schema.org Validator. Available at validator.schema.org. This is the second stop and the one most implementers miss. It validates against the full Schema.org vocabulary, including types and properties Google does not currently use for rich results. Use this when Rich Results Test says "no eligible items" — it tells you whether your schema is structurally valid even if Google does not currently surface a rich result for it.

The deprecated Structured Data Testing Tool. This tool was retired in 2021 and replaced by Rich Results Test and Schema.org Validator. It is still listed in old blog posts and a surprising number of YouTube tutorials. Do not use it. Google does not maintain it anymore and its results no longer reflect current rich result eligibility rules.

Generator-tool comparison. A few notes on the named-competitor landscape so you know what we are competing against. Merkle's Schema Markup Generator is the most-recommended free option for good reason — the UX is clean and the output validates reliably. It covers six types well: Article, Breadcrumb, Event, FAQ, How-to, Job Posting, Local Business, Organization, Person, Product, Recipe, Video. It does not tune for AI Overview citation and does not add SpeakableSpecification. Google's Structured Data Markup Helper is a relic in 2026. It still emits microdata by default, which Google itself recommends against. Useful only as a historical reference. schema-app.com is the most thorough commercial tool on the market, with full schema coverage, a Knowledge Graph integration, and a $179/mo entry price. The right choice for enterprise teams shipping thousands of pages; overkill for most SMBs. RankMath generates schema automatically inside WordPress and is the leading WordPress schema plugin by install count. Yoast generates a reasonable default set; the Premium tier ($99/yr) adds more types. Both are solid for WordPress-only deployments.

This tool, Rule27's, is positioned for the gap between free generators that ignore AI search and enterprise tools that overcharge SMBs. We tune defaults for AI Overview citation, support SpeakableSpecification for voice and AI surfaces, and validate every output against the Rich Results Test pattern set before shipping.

The seven most common schema mistakes we see in audits

Across 400 SMB sites audited in Q1 2026, the same seven mistakes account for roughly 80% of schema-related rich result failures. Ranked by frequency:

1. offers.priceCurrency missing on Product or Service schema. Single most common failure. The schema validates but the rich result never fires. Always include priceCurrency with a valid ISO 4217 code (USD, EUR, GBP, etc.).
2. Mismatched name between schema and visible page text. A LocalBusiness declares name: "Camelback Dental Care" while the page H1 reads "Camelback Dental." Google enforces consistency; the mismatch silently disqualifies the schema. Use the exact same name on the page and in the schema.
3. FAQPage with questions not visible on the page. Hidden FAQ stuffing is a manual-action risk and has been since 2023. Every Q&A in the schema must appear visibly on the page in the same form.
4. Article.headline exceeding 110 characters. Google silently skips the rich result. Keep headline under 110 characters, ideally under 90.
5. Article.image smaller than 1200px on the long edge. Required for top stories eligibility, recommended for all Article schemas. Smaller images may still validate but reduce rich result reliability.
6. openingHoursSpecification using day abbreviations. Must be full day names as strings (Monday, not Mon). Most generators emit this correctly; some hand-written schemas get it wrong.
7. Schema for a content type that does not exist on the page. A contact page with Article schema. A homepage with Recipe schema. The schema validates as JSON-LD but contradicts the page content. Google treats this as a signal that the schema is wrong about the page; in repeat cases, the page loses rich result eligibility site-wide.

A bonus eighth, encountered less often but worth flagging: schema declared in multiple competing blocks on the same page. If RankMath emits Article schema and you hand-add Article schema in your header.php, Google sees two Article blocks on the same URL. The behavior is undefined. Pick a source of truth.

Need a human to implement schema across your site?

If you have read this far and the work feels like more than a quiet afternoon, that is a reasonable read. Schema implementation across a 50-page site is a real engineering project: identifying the right type per page, generating the JSON-LD with correct values pulled from your CMS, deploying it, validating it, and maintaining it as Google's requirements drift.

Rule27 ships schema implementation as part of every SEO engagement. Our Phoenix-based team — named on the about page, transparent pricing on /seo-pricing, no 12-month contracts — will audit your existing schema, build a per-page type map, deploy the JSON-LD via the method that fits your stack (head tag, GTM, or WordPress plugin), validate each page against Rich Results Test, and monitor drift quarterly. Pricing is published on the services page; the typical schema-only engagement runs as a one-time implementation. If you want to skip the engagement and just get a sanity-check on your current schema, the free SEO audit at /free-seo-audit includes a schema validation pass on your top 10 pages with no obligation.