Structured data is the broad idea: information organized so software can read it consistently. Schema markup is structured data written with the schema.org vocabulary, and JSON-LD, Microdata and RDFa are the formats you use to write it. So, when someone asks you to "add schema," they usually mean schema.org structured data, most often written as JSON-LD.
Before you add, edit or test anything, name the layer you are working on. Decide which vocabulary describes the page, which format you will write it in, and which system you want to read it. Then check what the page already outputs, add or edit one entity, and test the result.
Valid markup can make a page eligible for features that a search engine offers. It does not guarantee a rich result, a ranking, traffic or an AI citation.
Three layers: vocabulary, format and consumer
The two terms overlap because most website structured data uses one vocabulary. Google says in its structured data introduction that structured data is a standardized format for providing information about a page and classifying its content, and that most Google Search structured data uses schema.org. In everyday SEO talk, "structured data" and "schema markup" therefore often point at the same code. Technically, one is the category and the other is a member of it.
Think of the work as three layers. The vocabulary defines the meanings: Article, Product, Organization, Event, and the properties that describe them, such as name, author, price and startDate. The format defines how those meanings are written down: JSON-LD, Microdata, RDFa, or plain HTML meta tags. The consumer is the system that reads the result, such as Google Search, Bing or a social network, and it decides what it recognizes and displays.
Each layer answers a different question. If you ask "what type is this page?", you are choosing from the vocabulary. If you ask "where does the code go?", you are choosing a format. If you ask "will this show up as anything?", you are asking about a consumer, and the answer lives in that consumer's own documentation rather than in the vocabulary or the format.

A small example makes the layers concrete. Take a JSON-LD script with "@type": "Article" and an author of type Organization. Article and Organization come from schema.org. JSON-LD is the syntax. The script as a whole is schema markup, and because schema markup is a kind of structured data, it is also structured data. Schema.org itself is not JSON-LD; the schema.org Getting Started page describes it as a vocabulary that you can use with Microdata, RDFa or JSON-LD, and the W3C specification describes JSON-LD as a JSON-based serialization for linked data.
If you want the beginner version of this definition with more examples, read what schema markup is and how it works.
What schema.org adds
Schema.org is a shared vocabulary of types and properties for describing things and their relationships on the web. A type says what something is. Properties describe it. The schema.org data model lets one thing point to another, so an article can name its author, and the author can be an organization with its own url.
Two details matter when you work with it. First, schema.org defines what a property means, not whether a particular search feature uses it. A type with no matching Google feature is still valid vocabulary, and a Google feature page may require properties that schema.org lists as optional. Second, the vocabulary is the same no matter which format you choose, so a decision about JSON-LD versus Microdata never changes what headline means.
Keep three kinds of correctness apart. JSON syntax can be valid while a property is misused. A property can be valid schema.org while a Google feature does not use it. And a feature requirement can be met while a page is still not shown with an enhancement.
Where Open Graph and Microformats fit
Open Graph and Microformats sometimes get grouped with schema markup, because they also add meaning to a page. They are separate vocabularies with different jobs. The Open Graph protocol is designed to turn web pages into rich objects in a social graph, and it usually lives in <meta> elements in the <head>.
<meta property="og:title" content="Example Bakery">
<meta property="og:description" content="Fresh bread made every morning.">
<meta property="og:image" content="https://example.com/images/bakery.jpg">Open Graph mostly controls how a page is represented when someone shares it on a social platform. It does not replace schema.org for describing an article, product, event or organization to Google Search. Keep both when both jobs matter, and make sure the title and image say the same thing in each place.
Microformats are lightweight HTML patterns that add meaning to visible content through class names. The microformats wiki lists patterns such as h-card for people and organizations, h-entry for posts, h-event for events and h-product for products. They use their own vocabularies. They can sit beside schema.org markup, but describing the same item twice with conflicting values makes the page harder to maintain and easier to get wrong.
Different consumers read different things. Bing Webmaster Tools says Bing supports schema.org in JSON-LD and Microdata, Microformats, RDFa and Open Graph, and that annotations alone do not guarantee a rich result (Bing Webmaster Tools). Google's documentation covers schema.org structured data for Google Search features, so Open Graph and Microformats are not substitutes for it there.
Structured data outside search
"Structured data" also describes database tables and analytics events with consistent attributes, and neither is website schema markup. When you search for help or brief a freelancer and a request only says "structured data," ask whether it means schema.org markup on pages; if it says "schema," ask which type and which format. One clarifying question saves a week of work on the wrong layer.
Pick a format: JSON-LD, Microdata or RDFa
Google generally recommends JSON-LD and supports Microdata and RDFa as well, unless a feature page says otherwise. Bing documents support for JSON-LD, Microdata and RDFa and does not state a preference among them. All three can express similar information, so the practical choice is the one you can implement and maintain with the least risk.
JSON-LD sits in a single script element, separate from the visible HTML. That makes it easy to add through a theme, a tag manager or a plugin, and easy to read in the page source. Microdata and RDFa weave attributes through the visible HTML, so the markup is tied to the exact elements that display each fact. That can suit a template you control completely, and it can be harder to edit later.
Whichever you pick, use one format for one entity on a page. Mixing a JSON-LD Product with Microdata describing the same product invites duplicates and mismatches. For a longer comparison of the three, read JSON-LD, Microdata and RDFa compared.
Check what your page already outputs
Many themes, plugins and platforms already write markup, so the first job is to look, not to paste. Open the live page, view the source or use the browser's developer tools, and search for application/ld+json. Each match is a JSON-LD block. Also search for itemscope and itemtype, which signal Microdata, and typeof or property attributes, which signal RDFa.

Platform documentation confirms that output can already exist. Squarespace says it generates structured data automatically for blog posts, events, local businesses, organizations, products and websites (Squarespace Help Center). Wix describes manual JSON-LD, preset markup and AI-generated blog markup, and mentions that duplicate markup is possible (Wix Help Center). HubSpot has a BlogPosting schema toggle that is on by default for newer blogs, with a caution about duplicates (HubSpot Knowledge Base). Webflow lets you add generated or manual schema in page settings (Webflow Help Center).
If the page already carries a block for the same type, edit that block instead of adding a second one. Theme and plugin settings, such as a connected graph from an SEO plugin, may be the right place to change a value. Step-by-step installation lives in how to add schema markup to a website, and WordPress specifics are in schema markup on WordPress.
Add one entity with a BlogPosting example
Once you know what exists, add or edit a single entity, and make it match what visitors can see. The example below is a complete BlogPosting block for a fictional bakery article. It is teaching code with example.com values, so it is displayed here and never belongs on your page as written.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "BlogPosting",
"@id": "https://example.com/blog/sourdough-basics/#article",
"url": "https://example.com/blog/sourdough-basics/",
"headline": "Sourdough Basics for Beginners",
"description": "A fictional beginner guide to making sourdough bread at home.",
"image": [
"https://example.com/images/sourdough-1x1.jpg",
"https://example.com/images/sourdough-4x3.jpg",
"https://example.com/images/sourdough-16x9.jpg"
],
"datePublished": "2026-05-04T09:00:00-05:00",
"dateModified": "2026-05-18T14:30:00-05:00",
"author": {
"@type": "Organization",
"name": "Example Bakery",
"url": "https://example.com/about/"
},
"publisher": {
"@type": "Organization",
"name": "Example Bakery",
"url": "https://example.com/",
"logo": {
"@type": "ImageObject",
"url": "https://example.com/images/example-bakery-logo.png"
}
},
"mainEntityOfPage": {
"@type": "WebPage",
"@id": "https://example.com/blog/sourdough-basics/"
},
"articleSection": "Baking Guides",
"inLanguage": "en-US"
}
</script>Replace every value with information that appears on your page. The headline should match the visible headline, datePublished and dateModified should be the real dates with the right timezone, author should name the real author as a person or organization, and image should list images that belong to the article. Do not add ratings, reviews, prices, addresses or authors that the page does not show.
To produce a block for your own article without writing the braces by hand, use the Article schema generator, then compare the output with what your platform already prints. If you need more complete examples for other types, JSON-LD schema examples covers them, and types of schema markup helps you choose the right type.
Which properties Google's Article documentation lists
Google's Article structured data documentation covers Article, NewsArticle and BlogPosting, and it lists no required properties for them. It does recommend properties that apply to article pages, including author, headline, image, datePublished and dateModified. Inside an author object, name is needed when you include the author, and a url that points to a page identifying the author is recommended.
The remaining properties in the example, such as @id, url, description, publisher, mainEntityOfPage, articleSection and inLanguage, are schema.org-compatible optional properties. They are good practice when they are accurate, and they help you keep a connected graph across a site, but they are not part of Google's recommended list for this feature.
Keep the labels straight. "Required," "recommended" and "optional" describe a specific consumer's feature documentation, not the general schema.org type definition. A recommended property does not guarantee any enhancement, and leaving one out does not make the markup invalid.
Validate, and keep the facts visible
Validate before you publish and again after any template change. A syntax check tells you the JSON parses. Vocabulary checks tell you whether types and properties exist. A feature test, such as Google's Rich Results Test for supported types, shows whether a specific Google feature's requirements are met. You can run the first two with the Schema Nova validator and look at live pages with the Schema Nova checker.
Google's general structured data guidelines ask that markup reflect content visitors can see, stay accurate and be relevant to the page. Hidden facts or details that do not match the page break that expectation. The same guidelines say that valid markup does not guarantee a rich result, and Bing says the same about annotations on its side.
After publishing, keep the markup current. When a price, date, author or title changes on the page, change it in the markup in the same edit. If you use Google Search Console, its structured data reports can show issues for the supported types it tracks.
For a long list of checks, see the Google documentation for the exact feature you target. The documentation for one feature does not describe another, and the page you are marking up decides which one applies.
What Google still shows
Support for features changes, so treat any list of rich results as dated. Google says it stopped showing FAQ rich results in May 2026 and removed the FAQ feature documentation in June 2026. FAQPage is still a valid schema.org type, and FAQ content still helps readers when it matches the visible page, but you should not add it to get a Google rich result.
Google's August 2023 announcement removed How-to rich results from Search on desktop and mobile. Its October 2024 post removed the sitelinks search box beginning November 21, 2024, and kept support for site-name-related WebSite structured data. Its June 2025 post phased out displays including Course Info, ClaimReview, Estimated Salary, Learning Video, Special Announcement and Vehicle Listing.
Those changes affect Google Search displays. They do not change the schema.org vocabulary, and other systems that read schema.org may use it differently. Check Google's documentation updates page for the feature you are targeting before you spend time on a type.
The practical order stays the same: look at what the page already outputs, pick the type that matches the visible content, write it in the format you can maintain, validate it, and keep it accurate. If you want the SEO side of this, whether schema markup helps SEO covers expectations in detail.
Questions people ask
Are schema markup and structured data the same thing?
They overlap, but structured data is the broader category. Schema markup is structured data that uses the schema.org vocabulary, and people often say one when they mean the other because Google Search mainly uses schema.org for website structured data.
Is JSON-LD the same as schema markup?
No. JSON-LD is a format for writing data, and schema markup is what you get when you write schema.org vocabulary in it. You can write the same schema markup in Microdata or RDFa instead.
Can Open Graph replace schema markup?
No. Open Graph describes how a page appears when it is shared on social platforms, while schema.org describes the page's content for systems such as Google Search. Many pages carry both for their separate jobs.
Does every page need schema markup?
Add markup when it accurately describes the page and fits a supported feature or a relevant use. Skip unrelated or hidden facts, because markup that does not match the visible page can cause problems.
Is FAQ markup still valid?
FAQPage remains a valid schema.org type. Google says it stopped showing FAQ rich results in May 2026, so add FAQ markup only when it accurately reflects visible questions and answers, not to get a Google display.
