Schema markup is code that describes what a page is about, using the shared Schema.org vocabulary. Most site owners write it as JSON-LD, a block of structured text placed inside a <script type="application/ld+json"> tag. The markup should describe details that visitors can already see on the page, such as a business name, an address and opening hours.

Three terms tend to arrive together. Schema.org is the vocabulary of types and properties, JSON-LD is one format for writing that vocabulary down, and structured data is the broader idea of giving page content a machine-readable structure. The example business here is a fictional bakery.

If you want a starting draft, the LocalBusiness schema generator builds this kind of block from the details you enter. Before you add anything to a live site, look at what your theme, site builder or app already outputs, because a second description of the same business can conflict with the first.

Key takeaways

  1. What schema markup isSchema markup is code, usually JSON-LD, that describes what a page is about using the Schema.org vocabulary. It should match details visitors can already see.
  2. Look before you pasteCheck what your theme, site builder or app already outputs before adding anything, because a second description of the same business can conflict with the first.
  3. Use the specific typePick the most specific applicable type, such as Bakery instead of LocalBusiness, and enter only facts that appear on the page.
  4. Required by whomFor Google's Local Business feature, name and address are required, while url, telephone and openingHoursSpecification are recommended when they apply.
  5. No promise of displayCorrect markup does not guarantee a rich result, and a passing test only means the markup meets the requirements that test covers.
  6. Test and updateTest with the Rich Results Test and the Schema Markup Validator, then update the JSON-LD in the same edit whenever visible details change.

Schema.org, JSON-LD and structured data: how the terms fit

People use "schema", "schema markup", "structured data" and "JSON-LD" almost interchangeably, so it helps to place each one. Structured data is machine-readable information that gives page content a defined structure and meaning. Google describes how it works with that information in its introduction to structured data markup (documentation updated December 2025).

Schema.org is a shared vocabulary of types and properties. A type names a kind of thing, such as Organization or LocalBusiness, and a property is a detail about it, such as name, address or telephone. A single thing you describe is called an entity: this bakery, that product, this author.

JSON-LD, Microdata and RDFa are formats, three ways of writing the vocabulary down. JSON-LD is a JSON-based format for linked data, defined in a W3C Recommendation. Microdata embeds attributes inside the visible HTML, and RDFa is an HTML extension for linked data. Google says it recommends JSON-LD when your setup allows it because it is generally easier to implement and maintain. Bing's documentation says Bing supports Schema.org markup in JSON-LD, Microdata and RDFa. JSON-LD vs Microdata vs RDFa compares the three in more detail.

Put together, Schema.org supplies the words, a format such as JSON-LD writes them down, and the result is structured data. "Schema markup" is the everyday name for Schema.org structured data, especially when it is written as JSON-LD. The finer points of the wording are covered in Schema Markup vs Structured Data.

Illustration of glowing shape tiles, a bracket-shaped container and a page card linked by thin blue lines
Figure 1. A shared vocabulary, a format for writing it down and the page it describes work together as structured data.

A first JSON-LD example for a bakery

The smallest useful block for a fictional bakery on example.com looks like this. The script tag wraps the markup, and the JSON between the braces is the description itself.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Example Bakery",
  "url": "https://example.com/",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Example Street",
    "addressLocality": "Example City",
    "addressRegion": "IL",
    "postalCode": "60601",
    "addressCountry": "US"
  }
}
</script>

Read it line by line. @context names the vocabulary, here https://schema.org, so a parser knows what the words mean. @type says what kind of thing is being described, and this one is a LocalBusiness. name and url give the business name and its website. address holds a nested object of type PostalAddress with the street, city, region, postal code and country, and each nested object carries its own @type so a parser knows how to read the fields inside it.

Every value above is made up. Replace the name, URL and address with the details on your own page, and keep each value identical to what a visitor reads there. If the page shows a different business name or street number, the markup should show the same one.

Add hours, a phone number and a more specific type

A fuller version swaps LocalBusiness for Bakery, a more specific subtype, and adds a stable identifier, an image, a telephone number, a price range and opening hours. Google recommends using the most specific applicable LocalBusiness subtype in its Local Business structured data documentation.

html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Bakery",
  "@id": "https://example.com/#bakery",
  "name": "Example Bakery",
  "url": "https://example.com/",
  "image": "https://example.com/images/example-bakery.jpg",
  "telephone": "+1-312-555-0147",
  "priceRange": "$$",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "123 Example Street",
    "addressLocality": "Example City",
    "addressRegion": "IL",
    "postalCode": "60601",
    "addressCountry": "US"
  },
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": [
        "Monday",
        "Tuesday",
        "Wednesday",
        "Thursday",
        "Friday"
      ],
      "opens": "07:00",
      "closes": "17:00"
    },
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": [
        "Saturday",
        "Sunday"
      ],
      "opens": "08:00",
      "closes": "15:00"
    }
  ]
}
</script>

Several values need your own details before this goes live. Set telephone to the real number with its country code, since the one above is made up. Point image at a photo on your own site that represents the business, and keep priceRange short and accurate, within the length limit Google states. Update both openingHoursSpecification entries so the days and times match the hours shown on the page; the example uses a 24-hour clock, with weekdays from 07:00 to 17:00 and weekends from 08:00 to 15:00.

@id is optional. It gives the entity a stable identifier, a URL plus a fragment name you choose, so other markup on your site can refer to the same business without describing it twice. The visible page should show the same name, address, phone number and hours that the markup carries.

The word "required" always needs a "by whom". Schema.org itself makes very few properties mandatory. A Google feature page, on the other hand, lists the properties a page needs to be eligible for that feature, and separates them from recommended ones. For LocalBusiness, Google's Local Business documentation lists name and address as required. It lists url, telephone, image, openingHoursSpecification, priceRange and geo among the recommended properties when they apply.

Types without a matching Google feature work differently. Google's Organization structured data documentation lists no required properties for Organization and recommends adding applicable details such as name, address, URL, logo and contact details. A Schema.org type that has no Google feature is not invalid; it simply has no Google requirements to meet.

Review properties are conditional. review and aggregateRating belong only where Google's review snippet requirements allow them, and the reviews must be visible on the page. Never add ratings the page does not show.

It also helps to keep four meanings of "correct" apart. The JSON can be valid syntax. The types and properties can be valid Schema.org vocabulary. The markup can meet the requirements of a Google feature that still exists. And the page can be indexed and actually shown with an enhancement. Each one is a separate question, and passing one does not settle the next.

LocalBusiness properties at a glance

Hover over or tap a row to highlight it. On small screens the table scrolls sideways.

PropertyStatus in Google's Local Business documentationWhat to do
nameRequiredMatch the business name shown on the page.
addressRequiredUse the physical business address.
urlRecommended when applicableUse the canonical page URL.
telephoneRecommended when applicableInclude the country and area code.
openingHoursSpecificationRecommended when applicableKeep hours current and matching the page.
aggregateRatingConditionalUse only when ratings are legitimately collected and follow Google's review requirements.

Make the markup readable for Google and Bing

Google says it uses structured data to understand page content and to gather information about the entities described in the markup (structured data introduction, updated December 2025). It may also use markup to decide whether a page is eligible for a rich result, an enhanced display such as product information, breadcrumbs or local business details. Eligibility means the page meets the documented requirements for a feature, not that the feature will appear. Google's search gallery of supported structured data lists the supported features.

Bing's Marking Up Your Site with Structured Data page covers Schema.org markup in JSON-LD, Microdata and RDFa, so the same JSON-LD block serves both engines. The Markup card in Bing Webmaster Tools' URL Inspection tool shows which markup Bing found on a page. For AI search, keep pages crawlable and the markup accurate; the guide on whether AI systems use schema markup covers each system.

Where search features end and promises begin

Correct markup does not guarantee a rich result. Google's general structured data guidelines say so, and Wix's help center makes the same point about its own markup tools. A passing Rich Results Test does not guarantee display either, and Google decides whether and how to show eligible markup.

Structured data is also not a ranking guarantee, and it cannot create facts the page does not contain. Fake reviews, hidden content, misleading claims and irrelevant markup can make a page ineligible for a feature. For the longer answer on search performance, read Does Schema Markup Help SEO?

Support for individual features also changes. Google announced that HowTo rich results no longer appear in Search from September 2023 (Changes to HowTo and FAQ rich results). It removed the sitelinks search box from November 21, 2024 (Farewell, sitelinks search box). In June 2025 it announced that selected structured data features were being phased out, and said the change does not affect rankings (Simplifying the search results page).

FAQ rich results stopped showing in Google Search in May 2026, and the FAQ feature documentation was removed in June 2026. FAQPage remains a valid Schema.org type, so existing FAQ markup is not invalid, but it is not a route to a Google display. Before building for any feature, open the matching Google feature page and the search gallery to see what is current.

Schema types small sites use

Start with the type that best describes the page's main subject, then add more only when the page genuinely describes related things. The types below cover most small sites.

  • Organization: a company, nonprofit, school or club, usually on the home page or About page.
  • LocalBusiness: a physical business or branch, with subtypes such as Bakery.
  • Article or BlogPosting: editorial content and blog posts.
  • BreadcrumbList: a page's position in the site hierarchy.
  • Product with a nested Offer: a product and its price and availability.
  • Event: an event with dates, location and attendance details.
  • Recipe: ingredients, preparation time and nutrition.
  • Review or AggregateRating: only in contexts where reviews are eligible.
  • WebSite: the site as a whole.
  • Person: an author or profile page.
  • Service: a service offered by a business or organization.

Connected types are normal. A bakery's location page can describe the Bakery itself, and a product page can describe a Product whose Offer nests inside it. Not every type in this list has a Google feature, so check the search gallery when a rich result is the goal. Types of Schema Markup covers type selection in more depth, and JSON-LD schema examples shows more complete blocks.

Where the markup lives and how to see it

Google supports JSON-LD in either the <head> or the <body> of an HTML page. JSON-LD can also be inserted by JavaScript or a content management system. Webflow's custom code documentation describes adding script tags to the head or before the closing body tag, which is where hand-placed JSON-LD ends up on that platform.

To see what a page already carries, follow these steps.

  1. Open the page in a browser.
  2. Use View Source or Inspect.
  3. Search for application/ld+json.
  4. Copy each JSON-LD block into a validator.
  5. Compare the facts in the markup with the visible page.

View Source shows the HTML the server sent, and the Elements panel shows the rendered document. Some sites add JSON-LD after the page loads, so look in both places before deciding a page has none. A small business owner can finish the comparison in a few minutes at the counter: open the location page, read the block, and confirm that the name, hours and phone number agree with what customers see.

A bakery owner points at a laptop screen that shows a web page next to a block of code, with racks of rolls behind her
Figure 2. Comparing the markup with the visible page confirms that the name, hours and phone number agree.

Check what your platform already outputs

Many platforms write structured data for you, which is why inspecting the published page comes before pasting anything in. Squarespace says it adds structured data automatically for blog posts, events, local businesses, organizations, products and websites (Squarespace Help Center). Wix accepts manual JSON-LD alongside its preset markup, and its help article on structured data markup mentions a five-markup limit, so read it for the current details.

Shopify exposes structured data for product information through its structured_data Liquid filter. On WordPress, theme and plugin output varies, and code that builds JSON-LD in PHP can use wp_json_encode() to encode the data safely. The guide to schema markup on WordPress covers that route. Hand-built sites can follow the Next.js documentation's approach of rendering JSON-LD in a native script tag.

Interfaces and automatic output differ by plan, theme, template, app and plugin. Look at the published page first. If a block for the same business already exists, update it rather than add a second one. How to Add Schema Markup to Any Website walks through placing markup on each type of site.

Test the markup and keep it current

Google's Rich Results Test shows whether the markup meets the requirements of the Google features it supports. The Schema Markup Validator checks the code against the Schema.org vocabulary only, with no Google feature requirements. You can also run pasted JSON-LD through the Schema Nova schema validator.

A passing test means the markup meets the requirements that test covers. It does not mean Google must show a rich result, and it says nothing about rankings. After publishing, watch Search Console for reports on the features you target, and see what Bing Webmaster Tools reports for the same pages.

Markup goes stale the moment the page changes. When the bakery moves its Saturday closing time or changes its phone number, update the JSON-LD in the same edit as the visible text. Treat the code as part of the page, not as a separate job to finish once and forget.

Six steps from page to tested markup

A safe order for adding schema markup to one page.

  1. 1. Identify the entityDecide what the page mainly describes, such as a business, product or article.
  2. 2. Choose the typePick the most specific applicable Schema.org type, such as Bakery.
  3. 3. Use visible factsEnter details that are accurate and visible to visitors on the page.
  4. 4. Write the JSON-LDWrite it by hand or with a generator, then place it in the head or body.
  5. 5. Test itUse the Rich Results Test for Google features and the Schema Markup Validator for vocabulary.
  6. 6. Publish and maintainMonitor Search Console and update the markup when visible content changes.

Questions people ask

Can I add schema markup without coding?

Yes, in several ways. A generator such as the LocalBusiness schema generator builds the JSON-LD from details you enter, and Squarespace says it adds structured data automatically for several content types. You still paste generated code into a place your platform allows, and you should compare the result with the page.

Do I need schema markup on every page?

Markup follows what a page is about, so a page needs it when a type fits its main subject. Start with pages where a documented Google feature or an accurate description of your business applies, such as a location page for a LocalBusiness or a home page for an Organization. Pages without a fitting type can go without.

What schema does a local business need?

Use the most specific applicable LocalBusiness subtype, such as Bakery. For Google's Local Business feature, name and address are required, and url, telephone, image, openingHoursSpecification and priceRange are recommended when they apply. Fill in only what appears on the page.

Does schema markup improve rankings?

Structured data is not a ranking guarantee. Google's June 2025 announcement says that phasing out some structured data features does not affect rankings. The benefits it does offer are a clearer machine-readable description of the page and eligibility for enhanced displays where Google supports them.

What happens if schema markup is wrong?

Markup that describes hidden content, makes misleading claims or adds fake reviews can make a page ineligible for a feature. Syntax and vocabulary mistakes show up in the Schema Markup Validator, and missing required properties show up in the Rich Results Test. Correct the code, retest it, and publish the update.

Quick check: vocabulary, format and purpose

Choose an answer to see feedback. Nothing is scored or saved.

Question 1 of 3

Which item is a vocabulary?

Question 2 of 3

What should markup describe?

Question 3 of 3

What does a passing test mean?

Schema markup terms

Select a term to see its definition.

Schema markup. Structured data that uses the Schema.org vocabulary.