🧩 Structured Data Type Finder

Last updated: February 18, 2026

🧩 Structured Data Type Finder

Describe your page below. We'll recommend the right Schema.org type and show you exactly which properties Google uses.

Or click a quick example:

Recipe page with ingredients Local business restaurant listing Product page for sale with price FAQ page with questions and answers News article or blog post Job posting or vacancy Event with date and location Video tutorial or how-to video Person or author profile page Course or online learning page

How to Pick the Right Schema.org Type Before You Write a Single Line of JSON-LD

Structured data is one of those SEO tactics that sounds simple in theory — add some JSON-LD, tell Google what your page is about, win rich results. But in practice, the first question trips up even experienced developers: which Schema.org type do I actually use?

Schema.org lists over 800 types. Google only actively uses about 25 of them for rich results. Picking the wrong one doesn't just waste your time — it means Google silently ignores your markup while your competitor's recipe page shows up with star ratings and cook times taking up three times the SERP real estate yours does.

Why Getting the Type Right Matters More Than Getting the Properties Right

Q: Does it really matter which Schema.org type I pick, as long as I fill in the properties?

A: Yes — enormously. Google's structured data parser is type-first. Before it evaluates a single property, it checks whether the @type is one it supports for rich results. If you use Thing, CreativeWork, or some obscure subtype Google doesn't render, none of your carefully filled properties will produce any SERP enhancement — not a star rating, not a price, not a FAQ dropdown.

The practical consequence: a recipe page marked up as CreativeWork instead of Recipe will have zero visual difference in search results. The same page marked up as Recipe with aggregateRating can show a 4.7-star badge, calorie count, and cook time — all before the user clicks. Click-through rates on recipe rich results are routinely 20–35% higher than plain blue links in the same position.

The Most Commonly Confused Schema Type Pairs

Q: I keep seeing both Article and BlogPosting. Which one should I use for my blog?

A: Both work, but they carry different signals. Article is the parent type and is most appropriate for structured editorial content — news reports, analysis pieces, feature writing. BlogPosting is a subtype of Article and signals informal, personal, or opinion-driven writing. Google treats both similarly for rich results, but NewsArticle (another Article subtype) is specifically required for Top Stories carousel eligibility.

For most blogs, BlogPosting is technically more accurate. For news sites, use NewsArticle`. For everything else that's editorial and formal, use `Article`. The properties required by Google are identical across all three: headline, image, datePublished, and author.

Q: My page has both a How-To guide and a recipe. Which type wins?

A: Use Recipe if the end result is food. Recipe is a direct subtype of HowTo, so it inherits all HowTo's properties while adding food-specific ones like recipeIngredient, cookTime, and nutrition. If the process produces something non-edible (a woodworking project, a hair style, a knitted sweater), then HowTo is correct. You can only have one primary type per page for rich result eligibility — Google doesn't stack Recipe and HowTo simultaneously.

The Properties Google Actually Validates (vs. Ones It Just Ignores)

Q: I added every property listed on Schema.org. Why is my rich result test still showing warnings?

A: Because Google's requirements are not the same as Schema.org's full specification. Schema.org defines the vocabulary; Google defines which subset it validates and renders. For example, Schema.org has dozens of properties for Product, but Google's Rich Results Test only checks for: name, image, description, sku/gtin/mpn (at least one identifier), brand, and the nested Offer object containing price, priceCurrency, and availability.

The Offer's availability field is the most commonly missed required property. It must use a specific Schema.org enumeration value: https://schema.org/InStock, https://schema.org/OutOfStock, or https://schema.org/PreOrder. Using plain text like "In Stock" fails validation silently in many parsers but causes the rich result to be suppressed.

Local Business: The Type Where Specificity Actually Pays Off

Q: My client runs a sushi restaurant. Should I use LocalBusiness or Organization or Restaurant?

A: Use Restaurant. Always use the most specific subtype available. Google's structured data documentation explicitly says this, but the reason matters practically: type specificity affects which knowledge features can be triggered. A generic LocalBusiness can show basic NAP (Name, Address, Phone) data. A Restaurant can additionally surface menu links, cuisine type, price range, and reservation actions through Google's restaurant-specific features.

The same logic applies across the board. Use Dentist not MedicalBusiness. Use Hotel not LodgingBusiness. Use AutoDealer not Store. Specificity is not just about semantic accuracy — it unlocks feature-specific rich result templates Google only applies to named subtypes.

Events and the Attendance Mode Property Almost Everyone Forgets

Q: I marked up a webinar as an Event and the Rich Results Test passes, but it's not appearing in search. What's wrong?

A: Online events have a specific additional requirement that wasn't part of the original Event specification. You must set eventAttendanceMode to https://schema.org/OnlineEventAttendanceMode and set location to a VirtualLocation object containing the event URL. If you set location to a physical address (or omit it) for an online-only event, Google's validator may pass it but the indexing pipeline will often suppress the rich result because the location data contradicts the event format.

Hybrid events require MixedEventAttendanceMode and need both a physical Place and a VirtualLocation nested inside location as an array. This is one of the more complex implementations in the Event specification and the documentation example doesn't always make the array structure obvious.

The FAQPage Trap: When Google Stops Showing Your FAQ Rich Results

Q: My FAQ rich results disappeared after a Google update. What happened?

A: In 2023, Google significantly reduced FAQPage rich result display, limiting it to authoritative government and health sites in most cases. The type still validates and is still technically supported, but practical eligibility now requires high domain authority. More importantly, Google revised its spam policies to clarify that adding FAQPage markup to pages where the FAQ content is not genuinely useful (stuffed purely for SERP real estate) constitutes a violation.

If you're implementing FAQ markup today, the strategy should be: use it where the questions are genuinely what users search for, keep answers comprehensive (150–500 words each), and treat the markup as a semantic signal rather than a guaranteed visual enhancement. The value is increasingly in the structured signal to Google's language models rather than the collapsed dropdown in search results.

One Type Most Sites Are Missing: BreadcrumbList

Q: I've implemented Recipe and Product markup. What else should I add?

A: BreadcrumbList is the most underrated Schema.org type in terms of implementation-to-reward ratio. It replaces the raw URL in your search snippet with a human-readable navigation path (Home > Recipes > Indian > Butter Chicken). It requires just three properties per breadcrumb item: @type set to ListItem, position as an integer, and name as the display label.

Breadcrumbs show up in a remarkably high percentage of eligible SERPs because they're one of the safest rich result types — very few spam concerns, no eligibility restrictions, works on virtually any page type. Every site with more than one level of navigation hierarchy should have this implemented. It pairs with every other Schema type and adds visual differentiation in the SERP without requiring any of the complex nested objects that Product or Recipe demand.

FAQ

What is the difference between Schema.org types and Google's supported types?
Schema.org defines over 800 types as an open vocabulary standard. Google only uses a subset of roughly 25 types to generate rich results in search — things like Recipe, Product, Event, Article, FAQPage, and JobPosting. The remaining Schema.org types are still useful as semantic signals to Google's language models, but they won't produce visual enhancements like star ratings, price snippets, or expandable dropdowns in search results. Always cross-reference your chosen type with Google's own structured data documentation at developers.google.com/search/docs/appearance/structured-data.
Can I use multiple Schema.org types on a single page?
Yes, and in many cases you should. A product page might have Product markup, BreadcrumbList markup, and a nested Organization for the brand. An article page would typically include Article plus Person for the author plus BreadcrumbList for navigation. Google processes multiple JSON-LD blocks on the same page independently. What you cannot do is claim two conflicting primary types for the same content entity — for example, marking the same content block as both Recipe and HowTo simultaneously. Use multiple types for different entities on the page, not multiple types for the same entity.
My rich result test passes but Google Search Console shows no rich results impressions. Why?
Passing the Rich Results Test means your markup is syntactically valid — not that Google has chosen to display it. Several factors can prevent display even with valid markup: domain authority too low for competitive rich result types (FAQPage), policy violations detected by quality algorithms, the page not being indexed at all, content mismatch between markup and visible page content (Google cross-checks both), or the rich result type simply not triggering for the specific search queries your page ranks for. Check Search Console's 'Enhancements' section for specific error messages and monitor for at least 4–6 weeks after implementation before drawing conclusions.
Should I use JSON-LD, Microdata, or RDFa for structured data?
JSON-LD is Google's explicitly recommended format and should be your default choice. It sits in a separate script tag in the page head or body, making it easy to maintain, update, and validate without touching visible HTML. Microdata and RDFa embed attributes directly into your HTML elements, which makes them harder to maintain and easier to break during template changes. The only scenario where Microdata or RDFa might be preferred is if your CMS system already generates them automatically and switching would require significant development work. All three formats are parsed equivalently by Google's crawler.
How often does Google update which Schema.org properties it validates?
Google updates its structured data documentation and validation rules several times per year, typically aligning with broad core updates or product changes to Google Search features. The most reliable source of current requirements is developers.google.com/search/docs/appearance/structured-data — this is the authoritative reference, not Schema.org itself. Significant changes in recent years include: adding eventAttendanceMode for events (2020), restricting FAQPage display (2023), adding new Product properties for Google Shopping (2022–2024), and expanding Course markup for educational content. Subscribe to the Google Search Central blog to catch announcements when requirements change.
What happens if I mark up content that isn't visible on the page?
This violates Google's structured data quality guidelines and can result in a manual action penalty. Google cross-validates structured data properties against the visible page content. If your Recipe markup claims 5-star ratings but no reviews appear on the page, or your Product markup lists a price that isn't shown to users, Google's systems flag this as misleading markup. The penalty can suppress rich results for the specific page, the entire domain, or in severe cases result in a manual spam action. Always ensure every claim in your structured data is verifiable by a user visiting the page normally.