7 Schema Markup Examples With Code
Explore schema markup examples with practical code, clear explanations, and tips to describe your content accurately.
Schema markup examples are ready-to-adapt snippets of structured data that help describe web pages, products, businesses, articles, and other content in a machine-readable format. Most websites use JSON-LD, which lets you add this information without changing the visible text on the page. The right example depends on what your page actually contains and which properties apply to it.
Imagine two websites selling the same product. One provides a product name, price, availability, and customer reviews in ordinary text. The other also organizes those details into a format that software can interpret consistently. That second website gives machines a clearer picture of what the page represents.
This is where schema markup becomes useful. Instead of leaving important details open to interpretation, you explicitly label them using a shared vocabulary maintained by Schema.org.
In this guide, you’ll find practical schema markup examples for common website types, explanations of when to use each one, and guidance on implementing and testing your code. You’ll also learn which popular markup types deserve a second look before you add them to a website.
What Is Schema Markup, and How Does It Work?
Schema markup is structured information added to a webpage using an agreed vocabulary. It helps software distinguish between things such as a business, a person, an article, a product, and a recipe rather than treating every word as undifferentiated text.
Three concepts are worth understanding before working with code:
- Schema.org: The vocabulary defining types of things and their properties.
- JSON-LD: A format for expressing structured data, commonly placed in a script element in a page’s HTML.
- Rich results: Enhanced search result presentations that may be available when a page meets the requirements for a supported feature.
Think of schema markup as a product label. A bottle might contain liquid, but its label tells you whether it is olive oil or vinegar. Similarly, structured data labels information so software can interpret its meaning more precisely.
Google recommends JSON-LD for structured data implementation, although it also supports Microdata and RDFa for eligible features.
7 Practical Schema Markup Examples
These schema markup examples cover common website scenarios. Each code snippet illustrates a useful starting point, but you must replace the sample information with accurate details about your own page.
1. Article Schema Markup Example
Article markup describes editorial content, including blog posts, news stories, and other articles. It can identify the headline, author, publication date, and relevant images.
For example, a gardening website publishing an article about growing tomatoes could use the following JSON-LD:
{
“@context”: “https://schema.org”,
“@type”: “BlogPosting”,
“headline”: “How to Grow Tomatoes at Home”,
“description”: “A practical guide to growing healthy tomatoes.”,
“image”: “https://example.com/images/tomatoes.jpg”,
“datePublished”: “2026-09-15”,
“dateModified”: “2026-10-10”,
“author”: {
“@type”: “Person”,
“name”: “Jane Smith”,
“url”: “https://example.com/authors/jane-smith”
},
“publisher”: {
“@type”: “Organization”,
“name”: “Green Garden Journal”
}
}
The BlogPosting type is a more specific option within the broader article vocabulary. Its properties communicate what the article is about, who wrote it, and when it was published or updated.
Practical tip: Keep the headline, dates, author information, and image consistent with the visible article. Accurate metadata is more useful than adding properties simply because they are available.
2. Product Schema Markup Example
Product markup describes a specific item offered for sale or reviewed on a website. Depending on the page and applicable requirements, it can communicate a product’s name, brand, price, availability, and genuine customer ratings.
Consider an online store selling a reusable water bottle:
{
“@context”: “https://schema.org”,
“@type”: “Product”,
“name”: “Stainless Steel Water Bottle”,
“image”: “https://example.com/images/water-bottle.jpg”,
“description”: “A reusable 750 ml stainless steel bottle.”,
“sku”: “WB-750”,
“brand”: {
“@type”: “Brand”,
“name”: “Trail Supply”
},
“offers”: {
“@type”: “Offer”,
“url”: “https://example.com/products/water-bottle”,
“priceCurrency”: “USD”,
“price”: 24.99,
“availability”: “https://schema.org/InStock”
}
}
This example identifies the product and provides an offer with its price, currency, and availability. The values are illustrative; a live store should use its actual inventory and pricing.
Notice that the example does not include a rating. That is intentional: a product should not receive fabricated reviews or ratings just to qualify for an enhanced display.
When to use it: Product detail pages are the natural fit. A general category page listing dozens of products may need a different structure, depending on its purpose.
3. Local Business Schema Markup Example
Local business markup describes a real business and relevant details such as its name, address, telephone number, and opening hours.
Imagine a neighborhood bakery that wants to describe its physical location clearly:
{
“@context”: “https://schema.org”,
“@type”: “Bakery”,
“name”: “Sunrise Bakery”,
“url”: “https://example.com”,
“telephone”: “+1-202-555-0145”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “123 Market Street”,
“addressLocality”: “Springfield”,
“addressRegion”: “IL”,
“postalCode”: “62701”,
“addressCountry”: “US”
},
“openingHoursSpecification”: [
{
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [
“Monday”,
“Tuesday”,
“Wednesday”,
“Thursday”,
“Friday”
],
“opens”: “07:00”,
“closes”: “17:00”
}
]
}
The Bakery type is more specific than the general LocalBusiness type. This example communicates the business’s identity and location alongside its weekday hours.
Use your real business details, and make sure the hours reflect the actual schedule. If the business closes early on holidays or operates different weekend hours, your website should communicate those exceptions clearly.
When to use it: Restaurants, salons, repair shops, medical practices, and other eligible local businesses can use an appropriate business type. Choose the most specific applicable type rather than assigning an arbitrary category.
4. Organization Schema Markup Example
Organization markup describes a company, nonprofit, institution, or another organization. It can help establish a consistent identity across a website and connect that identity with its official properties.
For example:
{
“@context”: “https://schema.org”,
“@type”: “Organization”,
“name”: “Northstar Digital”,
“url”: “https://example.com”,
“logo”: “https://example.com/images/logo.png”,
“description”: “A digital publishing company.”,
“sameAs”: [
“https://www.linkedin.com/company/example”,
“https://www.instagram.com/example”
]
}
Here, sameAs identifies external profiles that genuinely represent the organization. Replace the example profiles with your company’s official accounts.
This markup is particularly useful for organizations whose names may be confused with those of other businesses. It helps describe which entity the website represents.
A useful distinction: Organization markup describes the company; LocalBusiness markup describes a business operating in a local context. A company with physical premises may use both concepts when the page and implementation appropriately represent them.
5. Breadcrumb Schema Markup Example
Breadcrumbs describe where a page sits within a website’s hierarchy. A visitor might see a navigation path such as Home → Clothing → Jackets → Rain Jackets.
The corresponding structured data could look like this:
{
“@context”: “https://schema.org”,
“@type”: “BreadcrumbList”,
“itemListElement”: [
{
“@type”: “ListItem”,
“position”: 1,
“name”: “Home”,
“item”: “https://example.com/”
},
{
“@type”: “ListItem”,
“position”: 2,
“name”: “Clothing”,
“item”: “https://example.com/clothing/”
},
{
“@type”: “ListItem”,
“position”: 3,
“name”: “Jackets”,
“item”: “https://example.com/clothing/jackets/”
},
{
“@type”: “ListItem”,
“position”: 4,
“name”: “Rain Jackets”,
“item”: “https://example.com/clothing/jackets/rain/”
}
]
}
Each ListItem has a position and a name. The URLs should correspond to the actual navigation hierarchy, and the final item represents the current page.
Breadcrumb markup is particularly helpful on websites with multiple levels of categories, such as ecommerce stores, publishers, and educational resource libraries.
Important: Breadcrumb structured data describes navigation; it does not create a visible breadcrumb trail automatically. Your website still needs to provide the appropriate navigation interface.
6. Event Schema Markup Example
Event markup describes a scheduled occurrence, such as a conference, concert, workshop, or public event. It can identify the event’s name, start date, venue, and ticket information.
Consider a photography workshop taking place at a physical venue:
{
“@context”: “https://schema.org”,
“@type”: “Event”,
“name”: “Beginner Photography Workshop”,
“startDate”: “2026-11-14T10:00:00-05:00”,
“endDate”: “2026-11-14T13:00:00-05:00”,
“eventStatus”: “https://schema.org/EventScheduled”,
“eventAttendanceMode”: “https://schema.org/OfflineEventAttendanceMode”,
“location”: {
“@type”: “Place”,
“name”: “Downtown Arts Center”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “50 Main Street”,
“addressLocality”: “Springfield”,
“addressRegion”: “IL”,
“addressCountry”: “US”
}
},
“offers”: {
“@type”: “Offer”,
“url”: “https://example.com/events/photography-workshop”,
“price”: 35,
“priceCurrency”: “USD”,
“availability”: “https://schema.org/InStock”
}
}
The date and timezone in this example are illustrative. Use the real event schedule, venue, ticket price, and availability.
An event’s structured data should describe one specific event rather than a general service or a page advertising multiple unrelated activities. If the event is postponed or canceled, update the relevant information instead of leaving outdated details in place.
7. Recipe Schema Markup Example
Recipe markup describes a dish and its preparation details. It can identify ingredients, cooking times, instructions, images, and other information relevant to someone preparing the recipe.
Here is a simplified example for homemade pancakes:
{
“@context”: “https://schema.org”,
“@type”: “Recipe”,
“name”: “Easy Homemade Pancakes”,
“image”: “https://example.com/images/pancakes.jpg”,
“author”: {
“@type”: “Person”,
“name”: “Emily Carter”
},
“datePublished”: “2026-08-20”,
“description”: “Fluffy pancakes made with everyday ingredients.”,
“prepTime”: “PT10M”,
“cookTime”: “PT15M”,
“totalTime”: “PT25M”,
“recipeYield”: “4 servings”,
“recipeIngredient”: [
“1 cup flour”,
“1 cup milk”,
“1 egg”,
“2 teaspoons baking powder”
],
“recipeInstructions”: [
{
“@type”: “HowToStep”,
“text”: “Whisk the flour, milk, egg, and baking powder together.”
},
{
“@type”: “HowToStep”,
“text”: “Cook portions of batter on a lightly greased skillet until golden.”
}
]
}
The ISO 8601 duration PT25M represents 25 minutes. This is a useful detail to get right because recipe durations are not simply ordinary text strings.
Use recipe markup when the page contains an actual recipe with the corresponding information. A restaurant menu featuring pancakes is not automatically a recipe page.
Which Schema Markup Type Should You Choose?
The best choice depends on the primary purpose of the page, not simply the industry your website belongs to.
| Schema type | Best use | Information described |
| Article or BlogPosting | Blog posts and editorial pages | Headline, author, dates |
| Product | Individual product pages | Product details, offers, eligible reviews |
| LocalBusiness | Local business pages | Business identity, address, hours |
| Organization | Company or institution pages | Name, logo, official profiles |
| BreadcrumbList | Pages within a site hierarchy | Navigation path |
| Event | Individual event pages | Dates, venue, tickets |
| Recipe | Recipe pages | Ingredients, instructions, cooking time |
One page can describe multiple related things. For example, a recipe article may include Recipe and BreadcrumbList markup, while an online store’s product page may describe a Product and its Offer.
The key is to make the relationships clear and ensure every type accurately describes the content.
How to Add Schema Markup to Your Website
Adding structured data is straightforward when you approach it systematically. You do not need to be an experienced developer to understand the process, although complex websites may require technical assistance.
Step 1: Choose the correct schema type
Start by asking what the page actually represents.
Is it an editorial article, a product detail page, a business profile, or an event listing? Select the most specific applicable type in the Schema.org vocabulary, then check whether your intended platform supports any special presentation associated with it.
Step 2: Write the JSON-LD
Create a JSON-LD object using the relevant properties. For a simple article, this could include headline, author, datePublished, and image.
Add other properties when they apply. Avoid copying fields from an example without understanding whether they describe your page accurately.
Step 3: Add the code to the page
JSON-LD is commonly added to the HTML inside a script element, often in the document’s head or body.
A basic implementation looks like this:
<script type=”application/ld+json”>
{
“@context”: “https://schema.org”,
“@type”: “Article”,
“headline”: “Your Actual Article Title”
}
</script>
This is a minimal illustration of the format, not a complete recommendation for every supported search feature. Add the relevant properties and follow the specific requirements for your chosen type.
Step 4: Validate the markup
Use two complementary tools:
- Google Rich Results Test: Checks structured data relevant to supported enhanced search appearances.
- Schema Markup Validator: Checks Schema.org structured data more generally.
Passing one test does not necessarily mean the markup is eligible for every special presentation. Each tool checks different aspects of the implementation.
Step 5: Check the live page
After publishing, inspect the actual page rather than relying exclusively on the code editor. Confirm that the markup is present, the page is accessible, and the information matches what visitors can see.
Google may need time to recrawl the page. Even valid structured data does not guarantee that an enhanced result will appear.
Common Schema Markup Mistakes to Avoid
Many implementation problems come from treating structured data as a box-ticking exercise instead of an accurate description of a page.
Adding invisible or misleading information. If your markup claims that a product costs $24.99, that price should reflect the offer represented on the page. Never invent ratings, reviews, prices, or other details.
Using the wrong type. A general business type may work, but a more specific applicable type can describe the entity more precisely. A bakery, for example, can use Bakery rather than relying only on Thing.
Copying sample data unchanged. Placeholder URLs, fictional company names, and outdated prices are fine in demonstrations but unsuitable for production.
Confusing valid markup with eligibility. Code can be valid according to Schema.org without qualifying for a particular enhanced search feature. Platform-specific requirements matter.
Ignoring changes to supported features. Structured data guidance evolves. Check current official documentation before implementing a type solely because an older tutorial recommends it.
Adding unnecessary complexity. More properties do not automatically make a page better. A smaller set of accurate, relevant information is preferable to an extensive block containing errors or misleading details.
Frequently Asked Questions
What is the most common schema markup format?
JSON-LD is a widely used format for structured data, and Google recommends it for eligible search features. It allows structured information to be added separately from the visible page markup.
Does schema markup improve search rankings directly?
Google does not guarantee ranking improvements from adding structured data. Correct markup can make a page eligible for certain enhanced appearances and help systems understand its content, but eligibility does not guarantee display or higher rankings.
Can I use multiple schema types on one page?
Yes. A page can contain multiple related types when they accurately describe its content. For example, a recipe page may include Recipe and BreadcrumbList structured data.
Do I need coding skills to add schema markup?
Not necessarily. Some website platforms and extensions generate structured data automatically. However, you should still inspect the output to ensure it uses the correct types, accurate information, and appropriate properties.
How often should I check my schema markup?
Check it after implementation, significant website changes, and updates to relevant platform requirements. For frequently updated product listings, also verify that prices and availability remain accurate.
Key Takeaways
- Schema markup describes page content using a shared vocabulary, commonly expressed through JSON-LD.
- Choose the schema type that best matches the page’s actual purpose.
- Use the examples as starting points, replacing all sample information with verified details.
- Match structured data to the content visitors can see.
- Validate with both the Rich Results Test and Schema Markup Validator when appropriate.
- Remember that valid markup does not guarantee an enhanced search appearance.
- Review official documentation regularly because supported features and requirements can change.
