Schema Markup Explained: What It Is and How to Use It

Summarize with AI

ChatGPT Perplexity Claude Google AI Mode Grok Mistral

Schema markup is structured data you add to a page’s HTML that labels your content in a machine-readable vocabulary, so search engines and AI systems can interpret exactly what a page is about rather than inferring it from text alone.

The core components at a glance:

• Item type: the category of content being described (e.g., Article, LocalBusiness, FAQPage)
• Properties: the specific attributes of that item (e.g., name, address, datePublished)
• Values: the actual data assigned to each property (e.g., “Smith & Associates Law Firm”, “Chicago, IL”)
• Formats: JSON-LD, Microdata, and RDFa are the three supported syntaxes

Google recommends JSON-LD for most implementations. It lives in a <script> tag separate from your HTML, which makes it easier to manage and update without touching page content.

Key Takeaways

Schema markup is the most direct technical lever for improving how search engines and AI systems represent your law firm in results, and JSON-LD with proper validation is the implementation path that delivers the most reliable return.

What schema markup and structured data actually mean

Structured data is a standardized format for providing information about a page and classifying its content. Schema markup is the practical implementation of that concept, using the shared vocabulary defined at Schema to describe what’s on the page.

Schema.org organizes its vocabulary in a hierarchy. Everything starts with Thing, the broadest possible type. From there, types branch into more specific categories: Organization inherits from Thing, LocalBusiness inherits from Organization, and LegalService inherits from LocalBusiness. Each level adds more specific properties. A LegalService entity can carry properties like practiceArea that a generic Organization cannot.

Items and properties are the two building blocks. An item is the entity being described. Properties are the attributes that describe it. Each property has an expected type for its value: telephone expects a text string, address expects a PostalAddress item, and geo expects a GeoCoordinates item. You can nest items inside other items to express complex relationships, such as placing a Person inside an Organization using the employee property.

One rule that catches many implementers off guard: markup must describe content that is visibly present on the page. You cannot mark up a five-star rating that a visitor cannot actually see. Google, Microsoft Bing, Yandex, and Yahoo all consume structured data, and all enforce the visible-content rule. AI answer engines increasingly use schema signals as well, making accuracy more consequential than ever.

How search engines and AI systems interpret your markup

When a crawler visits your page, it parses the structured data alongside the HTML. The parser extracts the item types, properties, and values, then checks them against known vocabularies. That parsed output feeds into two downstream processes: knowledge graph construction and rich result eligibility assessment.

The knowledge graph process is where entity clarification happens. If your page marks up a LegalService with a consistent name, address, and sameAs pointing to your Google Business Profile, the crawler can confidently associate those signals with a single real-world entity. Ambiguity drops. That clarity matters for brand queries and AI-generated answers, where the system needs to attribute information to a specific, verified source.

Rich result eligibility is separate from ranking. Adding FAQPage markup does not push your page to position one. What it does is make your page eligible to appear in the FAQ accordion feature in search results, which occupies more vertical space and can increase click-through rate. The distinction is important: schema is a feature-enabler, not a ranking lever in the traditional sense.

A nested example shows how this works in practice. A LegalService item can contain an employee property whose value is a Person item with its own name, jobTitle, and url properties. The crawler reads this as a structured relationship, not just co-occurring text on a page.

Why schema markup matters for your SEO results

Schema increases machine clarity, improves eligibility for rich SERP features, and can raise click-through rates when those features appear. Those three outcomes are distinct, and conflating them leads to unrealistic expectations.

The most direct benefit is rich result eligibility. Pages with Review markup can display star ratings in search results. Pages with FAQPage markup can show expandable questions. Product pages with Offer markup can display price and availability. Each of these features increases the visual footprint of your listing, which tends to attract more clicks even when your organic position stays the same. Ahrefs describes schema as one of the more reliable technical SEO investments for improving SERP appearance and CTR precisely because the mechanism is direct: better-formatted results get more attention.

The second benefit is entity clarity for brand queries and AI answers. When Google’s knowledge systems can confidently identify your organization as a specific entity with verified attributes, your brand panel becomes more accurate, your attorney bios surface more reliably, and AI answer engines are more likely to cite your content as a source. Microsoft’s guidance on AI search answer inclusion specifically lists structural clarity via schema as a recommended tactic.

A realistic expectation: schema rarely moves rankings directly. It improves how your existing rankings are displayed and how confidently machines attribute content to your entity.

Pro Tip: Prioritize schema types that map directly to your business goals. If you generate leads through local search, implement LocalBusiness or LegalService first. If FAQ content drives traffic, FAQPage markup is your highest-leverage starting point.

Common schema types and when to use them

Most websites need fewer than ten schema types to cover the majority of their pages. The types below handle the most common use cases, and practitioner guides recommend starting with the ones that map directly to business objectives.

• Article: Use on blog posts, news articles, and editorial content. Enables datePublished, author, and headline properties that improve content freshness signals and byline attribution.
• WebPage / WebSite: Use on your homepage and key landing pages. Supports SearchAction for sitelinks search box and name for entity disambiguation.
• LocalBusiness / LegalService: Use on your contact page, homepage, or any page representing the firm’s physical presence. Supports address, telephone, areaServed, and openingHours.
• Product: Use on e-commerce or service-offering pages. Nest with Offer for pricing and AggregateRating for review stars.
• FAQPage: Use on any page with a question-and-answer format. Each mainEntity entry maps to one question-answer pair. High-value for law firms answering common client questions.
• BreadcrumbList: Use sitewide to express page hierarchy. Helps search engines understand site structure and can display breadcrumb trails in SERPs.
• Review / AggregateRating: Use on pages that display client testimonials or aggregate ratings. Must reflect ratings that are genuinely visible on the page.
• Event: Use on pages promoting seminars, webinars, or community events. Supports startDate, location, and organizer.
• Person: Use on attorney bio pages. Supports name, jobTitle, worksFor, and url to establish individual entity signals.

For lead generation, LegalService and FAQPage deliver the most immediate return. For content visibility, Article with complete author markup strengthens E-E-A-T signals. When a product or service has reviews, always nest AggregateRating inside the parent type rather than marking it up separately. You can also review client communication best practices to understand how FAQ content maps to real client questions worth marking up.

Which format to use and where to place your markup

Use JSON-LD in most cases. Google recommends it, and Json-ld explains why: JSON-LD keeps structured data in a <script> tag that sits separately from your HTML, so you can update or inject it without modifying page templates. That separation also makes it straightforward to generate dynamically from a CMS or tag manager.

Microdata and RDFa embed attributes directly into HTML elements using itemscope, itemtype, and itemprop (Microdata) or typeof and property (RDFa). Both formats work, but they require touching the HTML itself, which increases maintenance overhead and makes template-level changes more complex. Use them when you are working with a legacy system that cannot inject a <script> block, or when inline annotation is required for a specific platform.

Placement rules are non-negotiable. Markup must describe content that is visible to the user on the same page. Never mark up content that lives on a different URL, is hidden behind a tab the user must click, or is not rendered in the page’s main content. Placing markup in the <head> is fine for JSON-LD; placing it in the <body> near the content it describes is equally valid.

Step-by-step implementation checklist

The sequence is: audit your pages, select types, generate JSON-LD, add to templates, test on staging, push to production, and monitor. Practitioner guides consistently recommend this order because validating before release prevents errors from propagating sitewide.

1. Audit your pages. List your page types (homepage, service pages, blog posts, attorney bios, contact page) and map each to the most appropriate schema type. Note which pages drive the most traffic and leads — those get priority.

2. Select your types and properties. For each page type, identify the required and recommended properties from Schema.org. Required properties are the minimum for rich result eligibility; recommended properties add depth. Check Google Search Central for the specific required fields per type.

3. Generate your JSON-LD. Write the markup manually or use a generation tool. Keep it minimal and accurate. Every value must match visible page content. Use ISO 8601 format for dates (2026-03-15), full URLs for url and sameAs fields, and properly formatted PostalAddress objects for addresses.

4. Add to page templates. Inject the <script type="application/ld+json"> block into the <head> of the relevant template. For WordPress sites, the Yoast SEO plugin handles this automatically for common types, but always validate the output after plugin updates. For sitewide rollout guidance, the step-by-step sitewide SEO guide for lawyers covers template-level injection in detail.

5. Test on staging. Run every new template through the Google Rich Results Test and validator.schema.org before pushing to production. Fix all errors; review warnings for relevance.

6. Push to production. Deploy during a low-traffic window. Confirm the markup renders correctly in the live environment by re-running the Rich Results Test on the live URL.

7. Monitor in Search Console. Open the Enhancements report in Google Search Console. Check for new errors weekly for the first 90 days. Track impressions and CTR in the Performance report, filtered by pages with new markup.

For canonicalization: always place markup on the canonical version of a page. If a page has both www and non-www versions, the markup lives on whichever URL the canonical tag points to. See the URL structure guide for law firms for how canonical decisions interact with schema placement.

JSON-LD code examples you can copy and adapt

These templates follow Google Search Central requirements and the visible-content rule. Replace every placeholder value with real, page-visible content before deploying.

Article

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Your Article Title Here",
  "author": {
    "@type": "Person",
    "name": "Author Full Name",
    "url": "https://yoursite.com/author/author-name"
  },
  "datePublished": "2026-01-15",
  "dateModified": "2026-03-10",
  "publisher": {
    "@type": "Organization",
    "name": "Your Firm or Publication Name",
    "logo": {
      "@type": "ImageObject",
      "url": "https://yoursite.com/logo.png"
    }
  },
  "image": "https://yoursite.com/images/article-image.jpg",
  "url": "https://yoursite.com/blog/your-article-slug"
}

What to replace: headline, author.name, author.url, datePublished, dateModified, publisher.name, publisher.logo.url, image, and url. The datePublished value must match the date visible on the page.

LegalService (law firm)

{
  "@context": "https://schema.org",
  "@type": "LegalService",
  "name": "Smith & Associates Law Firm",
  "url": "https://yourfirm.com",
  "telephone": "+1-312-555-0100",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Main Street, Suite 400",
    "addressLocality": "Chicago",
    "addressRegion": "IL",
    "postalCode": "60601",
    "addressCountry": "US"
  },
  "areaServed": "Chicago, IL",
  "practiceArea": "Personal Injury",
  "sameAs": [
    "https://www.google.com/maps/place/your-listing",
    "https://www.linkedin.com/company/your-firm"
  ]
}

What to replace: name, url, telephone, all address fields, areaServed, practiceArea, and sameAs URLs. The sameAs array should point to authoritative profiles: Google Business Profile, LinkedIn, Avvo, Martindale-Hubbell, or state bar directory listings.

FAQPage

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the statute of limitations for personal injury in Illinois?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "In Illinois, the statute of limitations for most personal injury claims is two years from the date of the injury."
      }
    },
    {
      "@type": "Question",
      "name": "Do I need a lawyer for a car accident claim?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "You are not legally required to hire an attorney, but having one typically improves settlement outcomes in complex or disputed claims."
      }
    }
  ]
}

What to replace: Each name (the question) and text (the answer). Every question-answer pair must appear as visible text on the page. Do not mark up questions that exist only in the JSON-LD block.

How to test and validate your schema markup

Test on staging first, then confirm on production. The three tools that cover this workflow are the Google Rich Results Test, Google Search Console Enhancements, and Validator.

• Google Rich Results Test (search.google.com/test/rich-results): Paste a URL or code snippet to see which rich result types Google detects, which required properties are present, and which are missing. Use this before every deployment. It shows you exactly what Google’s parser sees.
• validator.schema.org: A general-purpose structured-data validator that checks correctness against the Schema.org specification, independent of Google’s specific rich result requirements. Use it to catch type mismatches, missing properties, and syntax errors that the Rich Results Test might not flag.
• Google Search Console Enhancements report: Available after deployment. Shows errors and warnings across all indexed pages that carry structured data. Schedule a weekly review for the first 90 days after any major markup rollout, as Search Console’s Enhancements data reflects real crawl results rather than a single-URL test.

Common errors to watch for:

• Missing required properties: Each schema type has required fields for rich result eligibility. Review without author or Product without name will fail validation.
• Invisible content markup: Marking up a rating or address that is not rendered on the page is a policy violation and can result in manual action.
• Duplicate conflicting markup: Two LocalBusiness blocks on the same page with different name values confuse parsers. Keep one canonical block per entity per page.
• Malformed date strings: Use ISO 8601 format (YYYY-MM-DD). Dates written as “March 15, 2026” will not parse correctly.
• Type mismatches: Assigning a plain text string to a property that expects a nested object (e.g., using a string for address instead of a PostalAddress object) generates parser warnings.

Log your validation results in release notes. If a CMS plugin update changes your output, you want a baseline to compare against.

Measuring impact after you deploy schema

Track feature impressions, clicks, CTR, and downstream engagement. The primary measurement surface is Google Search Console, specifically the Performance report and the Enhancements tab.

Exact metrics to monitor:

• Rich result impressions: How often your page appears in a rich result format (FAQ accordion, review stars, etc.)
• CTR by page: Compare CTR before and after markup deployment for the specific pages you updated
• Average position for targeted queries: Schema does not move rankings, but if CTR improves, engagement signals may have secondary effects over time
• Conversion funnel changes: Track whether pages with new markup show changes in form submissions, phone call clicks, or chat initiations

90-day measurement checklist:

1. Baseline: export Search Console Performance data for target pages 30 days before deployment
2. Week 1 post-launch: confirm Enhancements report shows no new errors
3. Week 4: compare impressions and CTR for marked-up pages against the baseline
4. Week 8: check for rich result appearance in manual SERP searches for target queries
5. Day 90: run a full comparison of CTR and conversion metrics; document findings

Attribution is genuinely difficult. Schema deployment rarely happens in isolation, and seasonality, algorithm updates, and content changes all affect the same metrics. The most defensible approach is to isolate a small set of pages for initial deployment, measure those specifically, and expand based on results. Correlation is not causation, but a consistent CTR lift across multiple pages after markup deployment is a meaningful signal.

Common mistakes and how to fix them

Most schema errors fall into a small number of categories. Catching them early prevents sitewide issues.

• Incomplete required properties: Every schema type has a minimum set of fields for rich result eligibility. Fix: check the Google Search Central documentation for the specific type and add every required property before deployment.
• Marking up invisible content: Describing content the user cannot see on the page violates Google’s structured data guidelines. Fix: audit every property value against what is rendered in the browser. If the content is not visible, remove the property or make the content visible.
• Duplicate conflicting markup: Multiple schema blocks on the same page describing the same entity with different values. Fix: consolidate into a single block per entity per page. For pages that legitimately describe multiple entities (e.g., a firm page with multiple attorney bios), use separate, non-conflicting blocks.
• Bad date formats: Dates written in natural language fail to parse. Fix: use ISO 8601 (2026-03-15) for all datePublished, dateModified, and startDate fields.
• Wrong canonical page: Markup placed on a non-canonical URL is ignored. Fix: confirm the page carrying the markup is the canonical version, and that the url property in the JSON-LD matches the canonical URL.
• Paginated content: Marking up an Article on page 2 of a paginated series as if it were the full article. Fix: place article markup only on the first page or the canonical single-page version.
• Dynamically injected markup not rendering: Tag manager or JavaScript injection that fires after the crawler has already parsed the page. Fix: test with Google’s Rich Results Test using the “Fetch as Google” method to confirm the markup is present in the rendered DOM, not just the source.
• Multi-lingual sites: Using the same schema block across language variants without updating inLanguage or url. Fix: each language variant should carry its own schema block with the correct url and inLanguage values.

The visible-content rule and canonical URL accuracy are the two highest-risk items. Both can trigger manual actions if violated at scale.

Schema markup for law firms: LegalService, Person, and E-E-A-T signals

Tag your firm as LegalService and each attorney as Person with a worksFor relationship pointing back to the firm. This is the foundational structure for legal entity clarity, and guides focused on the legal sector consistently identify it as underused. The LegalService type on Schema.org inherits from LocalBusiness, which means it supports the full range of local business properties alongside legal-specific ones.

Properties that strengthen E-E-A-T for law firms:

• name: exact firm name as it appears on your Google Business Profile
• address and telephone: must match your NAP (Name, Address, Phone) citations exactly
• areaServed: the geographic markets you serve, expressed as city/state strings or AdministrativeArea objects
• practiceArea: the legal specialties the firm handles
• sameAs: links to authoritative profiles (state bar directory, Avvo, Martindale-Hubbell, LinkedIn)
• employee or member: links to Person items for each attorney

For attorney bio pages, the Person markup should include name, jobTitle, worksFor (pointing to the firm’s LegalService entity), url (the canonical bio page URL), and sameAs links to the attorney’s bar profile and professional directory listings. If the bio page displays credentials or awards that are visible on the page, hasCredential and award properties add further specificity.

LegalService vs. LocalBusiness: Use LegalService when the page represents the firm’s legal services. Use LocalBusiness only if the firm operates a non-legal business function. For most law firm pages, LegalService is the correct type. For structured data implementation on attorney and firm pages, the type hierarchy matters because it determines which properties are available and which rich result features are eligible.

Avoid marking up credentials, awards, or practice areas that are not visible on the page. AI answer engines that consume this data will surface it in responses, and inaccurate markup creates a credibility problem that is harder to fix than a missing property.

The law firm schema optimization guide covers the full property set and nesting patterns for multi-attorney firms.

Schema implementation priorities: what actually moves the needle

Start with the pages that drive leads and brand queries. That means your homepage, practice area pages, attorney bios, and any FAQ content that directly answers client questions. Those pages have the most to gain from entity clarity and rich result eligibility, and they are the ones AI answer engines are most likely to surface when someone asks a legal question.

The trade-off most firms face is effort versus expected return. A full sitewide schema audit and implementation is a meaningful technical project. But the highest-value markup, LegalService on the firm page, Person on attorney bios, and FAQPage on client-question content, can be implemented in a focused sprint and delivers most of the benefit. Blog posts and secondary content pages can follow in a second phase.

FAQPage markup deserves particular attention for law firms. When a prospective client searches “what happens after a car accident in Illinois,” a well-marked FAQ answer has a real chance of appearing in the expandable accordion feature. That kind of visibility, at the top of a results page, for a high-intent query, is worth more than a ranking improvement on a low-traffic page.

The audit-first approach is not optional. Firms that skip the audit and implement markup based on assumptions frequently end up with conflicting blocks, wrong canonical URLs, and invisible-content violations. Validate before you deploy, and schedule periodic scans because CMS updates and content changes can silently break markup that was working correctly.

Lawseo handles schema implementation for law firms

Schema markup is one component of a complete legal SEO strategy, and getting it right requires more than generating a JSON-LD block. Lawseo delivers a full schema implementation service for law firms: a technical audit of existing markup, custom JSON-LD templates for every page type your firm uses, CMS integration so markup stays current as content changes, and ongoing monitoring through Search Console Enhancements. Every campaign is reviewed personally by Todd R. Stager, who brings over 29 years of SEO experience to each client’s strategy.

Law firms that work with Lawseo also benefit from an exclusivity agreement, meaning Lawseo will not work with your direct local competitors. Schema implementation is part of a broader digital marketing program for attorneys that covers local SEO, content, link building, and AI search optimization. To get a schema audit for your firm, contact Lawseo at Lawseo.

Sources

These are the primary sources used throughout this article. Each serves a distinct purpose in your schema workflow.

• Intro to How Structured Data Markup Works | Google Search Central
• Schema
• Validator
• Json-ld

Recommended

• Structured data for law firms: boost SEO and attract clients
• How to Optimize Law Firm Schema for SEO in 2026
• What Is Technical SEO and Why It Matters