# Schema for SEO: The Types B2B Sites Need | Ten Speed Source: https://www.tenspeed.io/blog/schema-markup-seo Last UPDATED on: October 29, 2026 # Schema for SEO and AEO: Which Types B2B Sites Actually Need [![Erika Braeger](https://cdn.prod.website-files.com/65cf9d766de289167660d1f3/685ae540f827da60179cfdfc_White%20bkg1.jpeg)Erika Braeger](/authors/erika-braeger) Get a Free Custom Proposal [Work With Us](/work-with-us) TABLE OF CONTENTS [Schema for SEO and AEO: Which Types B2B Sites Actually Need](#) The ticket says "add schema markup to the site," but it doesn’t give the developer or technical marketer assigned to the project much to go on: It doesn't name which pages, which schema types, or how you'll know the work is done. For a B2B site, a lot of the markup types Schema.org lists don’t even apply, and many of them have nothing to do with how your company shows up in a search result. This piece hands you working JSON-LD for the schema types most B2B sites need, the fixes for the validation errors that turn up most often after you deploy it, and a short explanation of why the same markup that helps Google parse your pages also helps AI answer engines like ChatGPT and Perplexity represent them accurately. None of it will rank a page or earn a citation on its own. What it does is give search engines and AI systems the context they need to represent your business correctly, and that context is the groundwork every later SEO and answer engine optimization (AEO) decision builds on. ## **Key takeaways** * Most B2B sites need a short list of schema types: Organization and Article are near-universal, FAQPage and BreadcrumbList are high-value, SoftwareApplication fits SaaS product pages, and Product applies only to genuine commerce pages. * JSON-LD wins over Microdata and RDFa for B2B implementations because it lives in a self-contained script block, separate from visible layout code, making it far easier to maintain at scale. * Marking up FAQ answers or article details that don't appear as visible text on the rendered page is one of the most common causes of validation failures. * A single missing or malformed property, like a BreadcrumbList without its required minimum entries, can break structured data across every page built from that template. * The entity clarity and content structure schema markup establishes help AI systems parse and quote a page accurately, though it doesn't earn citations on its own. * Google limited FAQ rich results and removed HowTo rich results in 2023, so FAQPage markup now pays off in clean, quotable structure rather than search result dropdowns. ## **What is schema for SEO?** Schema for SEO is structured data, usually written in JSON-LD using the Schema.org vocabulary, that you add to a page's HTML so search engines and AI systems know exactly what it describes: your company, an article, a product, a FAQ. It doesn't rank pages on its own. It removes the guesswork. JSON-LD (JavaScript Object Notation for Linked Data) lives in a script block that sits apart from the visible content, which makes it easy to maintain and easy for Google, Bing, and AI systems to read. Schema.org lists hundreds of types, but most B2B sites only need a handful, matched to the page templates they actually run. ## **How schema helps SEO (and what it doesn't do)** Schema doesn't move rankings by itself. Google has said structured data isn't a ranking factor. What it changes is how accurately search engines and AI systems read your pages, and which search features those pages qualify for. * **Rich result eligibility:** Valid markup can qualify a page for enhanced listings like breadcrumb trails, product pricing, review ratings, video thumbnails, and job listings. Eligibility isn't a guarantee. Google decides when to show them. * **More click-through potential:** A listing with extra detail takes up more space and answers more of the searcher's question before the click, which draws more attention than a plain link. * **Entity clarity:** Schema tells machines which real-world thing a page is about, so your brand, products, and authors don't get confused with something else that shares the name. * **Cleaner AI parsing:** Clear entity and Q&A structure makes it easier for AI answer engines to read and quote a page accurately. It's one input among many, not a citation lever. ### **What changed in 2023** In August 2023, Google [scaled back two of the most popular rich results](https://developers.google.com/search/blog/2023/08/howto-faq-changes). HowTo rich results were removed, and FAQ rich results now show only for well-known, authoritative government and health sites. Google also said there's no need to remove existing FAQ markup. For B2B sites, FAQPage is still worth adding to pages with visible FAQs. The payoff just shifted from a dropdown in the search results to clean Q&A structure that search engines and AI systems can quote accurately. ### **Entity clarity in practice: which Ten Speed?** Type "Ten Speed" into a search bar and you could mean a 10-speed bicycle, Ten Speed Press (the cookbook publisher), or a B2B marketing agency. Our page copy says plenty about AEO and SEO, but copy alone still leaves a machine inferring which one we are. One name, three entities Which “Ten Speed”? Product A 10-speed bicycle Publisher Ten Speed Press Organization Ten Speed, the B2B AEO and SEO agency Resolved by:descriptionknowsAboutsameAs Copy alone leaves a machine guessing. Organization schema tells it which Ten Speed this site belongs to. Organization schema removes the inference. Here's a trimmed version of the Organization markup that runs sitewide on tenspeed.io: ``` { "@context": "https://schema.org", "@type": "Organization", "@id": "https://www.tenspeed.io/#organization", "name": "Ten Speed", "alternateName": ["Ten Speed Agency", "tenspeed.io"], "url": "https://www.tenspeed.io/", "description": "Ten Speed is a B2B answer engine optimization (AEO) and SEO agency that helps companies get found, cited, and recommended in AI search and Google, and turn that visibility into pipeline.", "address": { "@type": "PostalAddress", "addressLocality": "Chicago", "addressRegion": "IL", "addressCountry": "US" }, "knowsAbout": [ "Answer Engine Optimization (AEO)", "Search Engine Optimization (SEO)", "AI search visibility", "Digital PR", "B2B marketing" ], "sameAs": [ "https://www.linkedin.com/company/tenspeed", "https://www.youtube.com/@ten-speed", "https://clutch.co/profile/ten-speed", "https://www.crunchbase.com/organization/ten-speed" ] } ``` The full version also lists our founders, awards, and every podcast feed we publish. Three properties do most of the disambiguation work: * **description** states what the company does in plain language. * **knowsAbout** ties the entity to the topics it should be associated with. * **sameAs** points to profiles that already describe the company, so systems can confirm the LinkedIn page, YouTube channel, and Clutch listing all describe the same entity. The same logic applies to any B2B brand with a common-word name, an acronym shared with another company, or a product name that overlaps a generic term. ## **1\. Choose schema types for B2B pages** **Most B2B sites should prioritize Organization and Article schema first, then add FAQPage and BreadcrumbList where the page template supports them, with SoftwareApplication for SaaS product pages and Product reserved for genuine commerce pages.** That sequence differs from a generic Schema.org checklist, which lists dozens of types without weighing which ones match your actual templates. Checklist-driven teams end up marking up local business hours on a SaaS site. A template-based sequence starts with the two structures nearly every B2B page needs, sitewide company identity and editorial content, before touching anything conditional. Here's how that maps to the templates most B2B sites run on: | Page template | Schema type | What it does | | ---------------------------- | ------------------------------------------------------- | -------------------------------------------------------- | | Homepage | Organization, WebSite | Sets company identity and the site name shown in results | | Blog post or guide | BlogPosting or Article, BreadcrumbList | Exposes author and freshness, shows where the page sits | | Pricing page | FAQPage (visible FAQ only) | Structures objection-handling Q&A | | SaaS product or feature page | SoftwareApplication | Describes the product, its category, and price | | Self-serve checkout | Product, Offer | Price and availability for real transactions | | Docs or help center | TechArticle, BreadcrumbList | Maps deep, nested hierarchies | | Webinar or event | Event (upcoming), VideoObject (replay) | Dates and registration, video results for recordings | | Podcast episode | PodcastEpisode, VideoObject if embedded | Ties episodes to the series and video | | Author or team page | ProfilePage with Person | Connects authors to expertise and profiles | | Careers listing | JobPosting | Eligibility for Google's job results | | Skip for most B2B sites | Recipe, HowTo, LocalBusiness, Product on demo-led pages | Mismatched to the page or no longer supported | LocalBusiness only makes sense if clients visit a physical location. This sequencing mirrors how teams prioritize [technical SEO](https://www.tenspeed.io/blog/technical-seo) fixes on a broader roadmap: foundational work first, conditional additions second. ### **Organization schema for your company identity** **Organization schema** anchors your brand identity sitewide, making it the single most universal schema type for B2B companies and typically the one you implement once, in a global template, rather than page by page. This schema type connects the properties that tell search engines and AI systems who you are: your company name, logo URL, website URL, and links to your social profiles. Populate each of these fields with the same values you use everywhere else on the web. If your LinkedIn page lists "Acme Software" but your schema says "Acme Software, Inc." you've created a mismatch that weakens the entity signal instead of strengthening it. [Solid website architecture](https://www.tenspeed.io/blog/website-architecture-foundations-that-convert-and-rank) makes schema work easier because a clean template structure gives you one place to maintain this data instead of dozens. Consistent entity data also pays off beyond traditional search. The same identity clarity helps AI answer engines cite your company accurately instead of confusing it with a competitor. ### **Article schema for blog and resource content** **Article schema** should expose the headline, author, publish date, and modification date on every blog post and resource page, giving search engines and AI systems accurate authorship and freshness signals. Build this into your content management system (CMS) article template so it pulls **headline, author, datePublished, and dateModified** dynamically from the page's actual fields rather than hardcoding values that go stale. Those four fields do specific work: * **Headline and author:** Establish who wrote the piece and give it a named source, which counts when readers or AI systems are deciding whether to trust it. * **DatePublished and dateModified:** Tell search engines and answer engines how current the information is, which affects whether a fast-moving topic surfaces your page or a fresher one. DateModified is also where most teams get sloppy. A stale or missing dateModified value is one of the most common validation errors you'll run into, and it's easy to overlook because the page still renders fine to a human reader. Whenever you substantively refresh a post, update the visible content and the dateModified field together. The refresh applies especially when you're addressing [citation gaps](https://www.tenspeed.io/blog/seo-content-analysis-citation-gaps) in older content that AI answer engines have started skipping. ### **FAQPage schema for sales and support content** **FAQPage schema** belongs on B2B sales and support pages only when the marked-up questions and complete answers appear visibly on the rendered page. Google stopped showing FAQ rich results for most sites in 2023, so the value here is accurate, quotable structure rather than extra space in the search results. Google's structured data guidelines are explicit about this: Markup has to reflect what a visitor actually sees, which rules out a hidden or expanded-on-click version stuffed with extra keywords. The right home for this schema is an objection-handling FAQ module on pricing, comparison, or product pages, the section where you answer the questions a buyer asks right before they decide. Think "does this integrate with our stack" or "what happens if we need to cancel." Each question in your JSON-LD needs a matching question on the page, and each answer needs to be the full answer a visitor would read, rather than a truncated summary. The visible-content requirement also serves AI answer engines: Clean, matched FAQ structure makes this content easier to lift and quote accurately, a topic we cover in more detail in [how AI systems pull from B2B content](https://www.tenspeed.io/blog/b2b-content-ai-overviews). Get the visible module right first, and the schema has something real to describe. ### **BreadcrumbList schema for site navigation paths** **BreadcrumbList schema** should encode the ordered path from a higher-level page down to the page a visitor is on. Doing so gives search engines and AI systems a machine-readable version of your site hierarchy, in addition to the visual trail users see in the browser. BreadcrumbList markup helps most on pages where hierarchy gets complicated. A resource library with dozens of subcategories, a documentation site with nested product guides, or a blog with topic clusters all benefit from it because it tells crawlers how a specific page relates to the section and category above it. This works alongside a solid [internal linking](https://www.tenspeed.io/blog/internal-linking-seo) structure, since both signal how your content connects, just through different mechanisms. One works through hyperlinks, the other through structured data. Google requires [a valid BreadcrumbList to contain at least two ListItem entries](https://developers.google.com/search/docs/appearance/structured-data/breadcrumb), each with the required position and name properties, and item URLs for every entry except the final one. ### **Product schema for B2B commerce pages** **Product schema** applies only to genuine B2B commerce pages with an actual transaction, and it excludes the typical pricing or feature page. If a visitor can add an item to a cart, enter payment details, and complete a purchase on that page, Product schema fits. If the page just explains your plans and pushes visitors to "book a demo" or "talk to sales," it doesn't. Self-serve checkout flows for usage-based SaaS tools, add-on purchases inside a product dashboard, and marketplace listings are the clearest B2B examples. Mark lead-generation pricing and feature pages with schema that reflects what's actually on the page, like Organization or FAQPage. Before you add Product schema anywhere, check [Google's merchant listing structured data specification](https://developers.google.com/search/docs/appearance/structured-data/merchant-listing), which spells out the required properties, including price, availability, and offer details, for merchant and product listing rich result eligibility. Applying Product schema to a page without a real transaction sets you up for the visible-content mismatch error that trips up so many B2B implementations. ### **SoftwareApplication schema for SaaS product pages** If you sell software, **SoftwareApplication** describes the product itself: what it is, what category it falls into, what it runs on, and what it costs. It's a better fit for most SaaS product and feature pages than Product, which Google built around shopping and merchant results. Add a rating only when genuine reviews appear on the page. Markup for ratings a visitor can't see breaks the same visible-content rule that trips up FAQPage. ## **2\. Write your JSON-LD script** Every schema object starts as a script tag with the attribute type="application/ld+json," wrapping a JSON object that declares @context and @type before any other property. [Google recommends JSON-LD over microdata or Resource Description Framework in Attributes (RDFa)](https://developers.google.com/search/docs/appearance/structured-data/intro-structured-data) whenever your CMS allows it, because it's the easiest format to implement and maintain at scale. Nest each property under the correct type, keep string values in quotes, and drop any trailing commas, since a single syntax slip can invalidate the entire block. **Organization schema needs name, url, logo, and sameAs for social profiles:** **Article schema needs headline, author, datePublished, and dateModified:** ``` { "@context": "https://schema.org", "@type": "Article", "headline": "Post Title", "author": { "@type": "Person", "name": "Author Name" }, "datePublished": "2026-01-10", "dateModified": "2026-02-01" } ``` **FAQPage schema needs a mainEntity array of Question and Answer pairs matching the visible text:** ``` { "@context": "https://schema.org", "@type": "FAQPage", "mainEntity": [ { "@type": "Question", "name": "Question text", "acceptedAnswer": { "@type": "Answer", "text": "Answer text" } } ] } ``` **BreadcrumbList schema needs an itemListElement array with at least two entries, each with position and name, plus item URLs for every entry except the last:** ``` { "@context": "https://schema.org", "@type": "BreadcrumbList", "itemListElement": [ { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com" }, { "@type": "ListItem", "position": 2, "name": "Blog", "item": "https://example.com/blog" }, { "@type": "ListItem", "position": 3, "name": "Post Title" } ] } ``` **Product schema needs name, offers, and price for genuine transactions:** ``` { "@context": "https://schema.org", "@type": "Product", "name": "Product Name", "offers": { "@type": "Offer", "price": "99.00", "priceCurrency": "USD" } } ``` **SoftwareApplication schema needs name, applicationCategory, operatingSystem, and offers:** ``` { "@context": "https://schema.org", "@type": "SoftwareApplication", "name": "Product Name", "applicationCategory": "BusinessApplication", "operatingSystem": "Web", "offers": { "@type": "Offer", "price": "49.00", "priceCurrency": "USD" } } ``` If a single template needs more than one type, such as Organization and Article together, wrap them in a single @graph array instead of stacking separate script tags with duplicate @context declarations. That keeps the block easier to validate and helps you avoid the duplicate-Organization errors covered later in this piece. ## **3\. Place your JSON-LD script on pages** JSON-LD script blocks can live in either the head or body of a page's HTML, since Google's crawler parses both locations. Pick whichever fits how your CMS already renders templates. If your team manages the site through a system like WordPress or Webflow, injecting schema into the head via a custom field or plugin is usually cleaner than editing body templates directly. Generate page-specific schema, like Article, FAQPage, or BreadcrumbList, from each content template using the page's own data rather than a hardcoded block. A blog post can combine Organization, Article, and BreadcrumbList schema. Google reads one @graph block and separate script tags the same way, but a single @graph is easier to validate and keeps you from duplicating Organization, so default to it. Whichever placement you choose, keep it consistent across every page built from the same template, since mixing head and body placement across pages that share a template makes future audits harder to run. * **Before:** A marketer manually pastes a JSON-LD block into ten blog posts, each with slightly different author names or missing date fields, because no one updated the template. * **After:** The Article schema pulls straight from the CMS fields, so every post ships with consistent, accurate markup with zero manual editing. That structural fix also supports the broader work of [prioritizing SEO improvements](https://www.tenspeed.io/blog/seo-priority) that compound instead of creating rework later. Duplicate or conflicting schema across templates is one of the most common causes of validation errors, which we'll cover next. ## **4\. Test your JSON-LD before you publish** Run every schema template through both Google's Rich Results Test and the [Schema.org validator](https://validator.schema.org/) before it goes live. These tools do different jobs. The Rich Results Test checks whether your markup is eligible for Google's specific rich result features, like breadcrumbs, review snippets, or video results. The Schema.org validator checks pure syntax against the spec, catching malformed JSON or missing brackets that the Rich Results Test might not flag. 1. Start by pasting the live URL into the Rich Results Test, or paste the raw JSON-LD code directly if the page isn't published yet. 2. Review whatever errors or warnings come back. 3. Fix the flagged properties, whether that's a missing datePublished field or an invalid nested type. 4. Run the test again on the corrected code. Don't stop at one pass: Keep testing until the tool returns a clean result with no errors. **You don't need to test every single page.** Since schema usually lives in a shared page template, testing one representative page per template type covers you. Check one Article page, one product page, one FAQ page, and so on. Fix the template once, and every page built from it inherits the fix. Testing before launch only tells you the code is valid the day you check it. After Google recrawls your site, open the structured data report in Search Console and watch for new errors. Templates change, content teams add fields, and a clean test today doesn't guarantee a clean crawl next month. ## **5\. Fix common JSON-LD validation errors** **Three failures cause most JSON-LD rejections: missing required properties, marked-up content that isn't visible on the page, and malformed or duplicate nesting.** * **Missing required properties:** These show up most often in BreadcrumbList markup. If your template outputs an incomplete path, add the missing parent-category entry. * **Invisible content:** If your FAQPage schema marks up answer text that never renders on the page, or your Article schema references a description that doesn't appear anywhere in the visible copy, that markup violates [Google's structured data policies](https://developers.google.com/search/docs/appearance/structured-data/sd-policies). The fix is direct: Either add that text to the rendered page or remove it from the JSON-LD. * **Malformed and duplicate nesting:** Two Organization blocks on one page, each listing a different company name, sends conflicting identity signals. Consolidate them into a single Organization object in your global template and delete the duplicate from the page-level script. ## **Why schema differs for AI engines** Schema markup earns rich results in Google, and its entity clarity and structure help ChatGPT, Claude, Gemini, and Perplexity quote your content accurately, though it doesn't earn a citation from those systems by itself. Those systems don't read your JSON-LD to decide what to render on a search results page, and AI answers have no equivalent of a star rating snippet or a FAQ dropdown. **Schema makes your content easier to parse correctly:** * **Organization schema** gives an AI system a clean entity signal: your company name, your logo, your official site, all in one consistent place instead of scattered across page copy. * **FAQPage schema**, when the questions and answers are also visible on the page, gives models a ready-made question-and-answer pair they can quote with less risk of misattributing the source. If you're rolling schema into your existing SEO workflow, someone will ask whether that same implementation improves AI citation visibility. It helps as one input among several, though it isn't the mechanism. SEO and AEO lean on the same underlying signals, entity clarity and clear structure, even though the surfaces and citation logic differ. If you want the deeper mechanics of how AI engines select and cite sources, that's a separate discipline worth understanding on its own terms. Start with [what AEO is and how it works](https://www.tenspeed.io/blog/what-is-aeo) before you build a citation strategy around it. ## **Add schema to your SEO roadmap** Schema rewards the team that sequences types correctly. Organization and Article schema earn their place first because they establish entity clarity across every template on the site. FAQPage and BreadcrumbList come next and tighten the structure search engines and AI models already trust. Product schema stays reserved for pages where a transaction actually happens, rather than every page that mentions a feature. The same sequencing logic should govern the rest of your technical SEO backlog. If you're deciding whether to fix canonical tags or add breadcrumb markup this sprint, pick the one that moves pipeline faster. We walk through that prioritization in [how to prioritize your SEO roadmap](https://www.tenspeed.io/blog/seo-priority). > Schema rewards the team that sequences types correctly. Start this week by auditing your ten highest-traffic templates for Organization and Article markup, validate each one, and move down the list. Ten Speed's strategists run this exact sequencing exercise for clients who need schema, technical SEO, content, and AEO work mapped against pipeline goals rather than treated as separate line items. ## Work with expert strategists Want a second set of eyes on how schema fits into that broader roadmap? Talk through your schema and SEO priorities with our team. [Work with us](https://www.tenspeed.io/work-with-us) ## **Frequently asked questions** ### **Does adding schema markup directly improve search rankings?** Schema markup isn't a direct ranking factor in Google's algorithm, so adding it won't automatically boost a page's position. It helps search engines interpret your content accurately and can qualify pages for rich result formats like breadcrumbs. For B2B teams under pressure to prove ROI, treat schema as an accuracy and eligibility investment rather than a ranking shortcut. ### **How long does it typically take to implement schema markup across a full B2B website?** Schema markup implementation speed depends on how your site handles templates rather than the total number of pages you have. Organization schema usually goes into one global template and can go live within a day. Article, FAQPage, and BreadcrumbList schema need updates to each content-type template, which commonly takes a few days to two weeks depending on developer bandwidth. ### **Do you need a developer to implement schema markup, or can a marketer do it without engineering support?** A technical marketer comfortable editing HTML or CMS templates can implement basic JSON-LD blocks, like Organization or FAQPage schema, without pulling in a developer. Sitewide implementations that touch every template, like Article schema tied to dynamic publish dates, usually need developer involvement to pull the right fields automatically. Most B2B teams land on a hybrid approach: Marketers own the content decisions and QA, while a developer wires the templates to pull data dynamically. ### **What happens if schema markup gets lost during a website migration or CMS update?** Losing schema markup during a migration removes page eligibility for rich results and weakens the entity clarity search engines and AI systems relied on, though it doesn't trigger a manual penalty. Re-running the Rich Results Test on key templates immediately after a migration catches missing or malformed markup before it affects a full crawl cycle. ### **How does schema markup implementation fit into a broader SEO or AEO strategy?** Schema markup works best as one sequenced line item in a broader organic roadmap, connected to content and technical SEO priorities. At Ten Speed, we treat clean entity and content structure as the foundation both SEO and answer engine optimization depend on. That's why we sequence schema work alongside content and AEO planning, rather than treating it as an isolated technical task. ## Related Articles [ ![](https://cdn.prod.website-files.com/65cf9d766de289167660d1f3/68c90d563553b0da9d34e5e2_Blog%20BG%208.png)BLOGA Guide To Choosing the Right SEO Agency for B2B SaaS](/blog/how-to-choose-an-seo-agency) [ ![](https://cdn.prod.website-files.com/65cf9d766de289167660d1f3/68c90d563553b0da9d34e5e2_Blog%20BG%208.png)BLOGHow to Build a B2B SEO Content Strategy](/blog/b2b-seo-content-strategy) [ ![](https://cdn.prod.website-files.com/65cf9d766de289167660d1f3/69458ef38178099a5c9d8f8e_Blog%20BG%209%402x.png)BLOGWhat Is Digital PR? B2B SEO and AI Citation Value Guide](/blog/what-is-digital-pr) ![](https://cdn.prod.website-files.com/65ce14eec6c1fa0d097f736d/65d3d1ebbd780c5ecf85c1d9_Group%2084.svg)![](https://cdn.prod.website-files.com/65ce14eec6c1fa0d097f736d/65d3d1ebbd780c5ecf85c1d9_Group%2084.svg) ## Discover how we can help Book a call with us and we’ll learn all about your company and goals. If there’s a fit, we will put together a proposal for you that highlights your opportunity and includes our strategic recommendations. [Work With Us](/work-with-us) ```json { "@context": "https://schema.org", "@type": "Organization", "name": "Your Company", "url": "https://example.com", "logo": "https://example.com/logo.png", "sameAs": ["https://linkedin.com/company/example"] } ```