What Is Structured Data in SEO?
Structured data is any information that is organised in a standardised, machine-readable format. In the SEO world, it specifically refers to code that describes entities (people, products, events, organisations), their attributes (name, price, date, location), and the relationships between them.
Here is a simple way to think about it. Imagine you hand someone a box with no label. They have to open it, look inside, and guess what it is. Now imagine you stick a clear label on that box: “Contains 12 red apples, harvested June 2026, from Al Ain farm.” The person instantly knows what is inside without any guessing.
That is exactly what structured data does for search engines. Google processes billions of web pages every day. Plain text requires the search engine to interpret meaning—which it sometimes gets wrong. Structured data removes that guesswork entirely by presenting information in a pre-organised format that search engine crawlers can parse without ambiguity.
Google explicitly states: “Google uses structured data that it finds on the web to understand the content of the page, as well as to gather information about the web and the world in general, such as information about the people, books, or companies that are included in the markup.”
When Google understands your content better, it can:
- Show your pages in more relevant search queries
- Display rich results (visual enhancements in search listings)
- Add your information to its Knowledge Graph
- Surface your content in AI Overviews and voice search results
💡 Key Point: Structured data does not just describe what is visible on a page. It can also describe abstract entities associated with your website—your organisation, industry, expertise, or the relationships between people and brands connected to your site. Google confirms it uses this information “to gather information about the web and the world in general.”
What Is Schema Markup?
Schema markup is the specific vocabulary (or taxonomy) from Schema.org that you implement in code on your website to describe content in a way search engines can read. If structured data is the concept, schema markup is the practical tool you use to make it happen.
It works on a hierarchical system. At the very top sits a root type called “Thing.” Everything in Schema.org inherits from Thing. From there, primary types branch out:
- Organisation (companies, schools, non-profits)
- Person (individuals—alive, dead, or fictional)
- Product (physical or digital items for sale)
- Event (scheduled activities at a specific time and place)
- CreativeWork (articles, books, movies, recipes)
- Place (physical locations)
- Action (activities performed by entities)
Each type has properties—these are the specific details that describe it. For example, a Product has properties like name, price, availability, and brand. An Event has properties like startDate, location, and performer.
You write schema markup in one of three formats—JSON-LD, Microdata, or RDFa—and embed it in your website’s HTML code. Google then reads this code when it crawls your page and uses it to understand exactly what entities exist on that page and what attributes they have.
The full hierarchy of Schema.org types is publicly available and maintained collaboratively as an open standard.
💡 Key Point: Schema markup essentially performs what data scientists call Named Entity Recognition (NER) for search engines. Instead of forcing Google to guess what entities exist on your page, you explicitly label them—removing interpretation errors and helping your content match more relevant queries.
Structured Data vs Schema Markup: What Is the Difference?
These terms get used interchangeably in SEO conversations, and in most practical situations that is perfectly fine. But technically, they are different layers of the same system. Understanding the distinction helps you communicate clearly with developers and avoid confusion.
| Term | What It Is | Simple Analogy |
| Structured Data | Any organised, machine-readable information | A filled-out form |
| Schema.org | The vocabulary and taxonomy of agreed-upon terms | The language the form is written in |
| Schema Markup | The actual code implementing Schema.org on your page | The act of filling out the form |
| JSON-LD | The coding format used to write the markup | The pen you use to write |
| Rich Results | The visual output Google shows in SERPs | The reward for completing the form correctly |
The confusion between schema markup and rich snippets is especially common. Rich snippets (now called rich results) are the output—they are what Google displays. Schema markup is the input—the code you add. Having schema on your page does not guarantee rich results, but without schema, most rich results are impossible.
Another common mix-up: plain text versus structured data. Plain text (unstructured data) is content without standardised formatting—Google has to interpret these using natural language understanding. Structured data is pre-organised in a format machines can read instantly, like JSON-LD code with clear type declarations and property-value pairs.
How Schema Markup Works: The Technical Foundation
Schema markup is a core component of technical SEO—the behind-the-scenes optimisation that ensures your website is crawlable, indexable, and correctly understood by search engines.
The Schema.org Hierarchy
Schema.org follows a parent-child structure. Think of it like a family tree. “Thing” sits at the top. Below it, major categories branch out. Below those, increasingly specific types appear.
For example:
text
Thing → Organisation → LocalBusiness → Restaurant
Thing → CreativeWork → Article → NewsArticle
Thing → Event → MusicEvent
Thing → Product
This hierarchy matters because properties are inherited downward. A Restaurant inherits all properties of LocalBusiness, which inherits all properties of Organisation, which inherits all properties of Thing. This means a Restaurant schema can include name, url, and description (from Thing), plus address and telephone (from Organisation), plus openingHoursSpecification and priceRange (from LocalBusiness), plus menu and servesCuisine (from Restaurant).
Google’s guidelines emphasise: “Try to use the most specific applicable type and property names defined by schema.org for your markup.”
How Search Engines Process Structured Data
When Googlebot crawls a page, here is what happens with your schema:
- Discovery — The crawler finds the <script type=”application/ld+json”> block in your HTML
- Parsing — It reads the @context (Schema.org) and @type (what entity this is) declarations
- Extraction — It pulls out all property-value pairs as structured triples (subject → predicate → object)
- Knowledge Graph Integration — This information may be added to Google’s Knowledge Graph—a massive database mapping relationships between entities worldwide
- Rich Result Evaluation — Google checks if your schema meets the requirements for rich results based on content quality, site authority, and user experience
- Display Decision — If everything qualifies, Google may show rich results for your page in relevant searches
The critical thing to understand: schema markup tells Google what entities exist. Google still decides whether to reward you with rich results. As Google confirms: “Google doesn’t guarantee rich results, even with proper markup.”
Google also notes that structured data can help even when it does not produce visible changes: “You’re always welcome to use structured data to provide better machine-readable context for your pages, which may not always result in visible changes, but can still help our systems to show your pages for relevant queries.”
Schema Markup Formats: JSON-LD vs Microdata vs RDFa
There are three formats for writing schema markup. All three can express Schema.org vocabulary, but they work very differently.
| Feature | JSON-LD | Microdata | RDFa |
| First introduced | 2014 | 2009 | 2004 |
| Where it goes | Separate <script> block | Inline within HTML elements | Inline within HTML elements |
| Placement | <head> or <body> | Scattered throughout HTML | Scattered throughout HTML |
| Google’s preference | ✅ Recommended | Supported | Supported |
| Human readability | High | Low | Low |
| Maintenance difficulty | Easy (isolated from HTML) | Hard (tied to templates) | Hard (tied to templates) |
| CMS compatibility | Excellent | Limited | Limited |
Why JSON-LD Is the Standard
Google explicitly states: “In general, we recommend using a format that’s easiest for you to implement and maintain (in most cases, that’s JSON-LD); all 3 formats are equally fine for Google, as long as the markup is valid and properly implemented per the feature’s documentation.”
JSON-LD sits inside a <script type=”application/ld+json”> tag, completely separated from your visible HTML content. You can drop it in the <head> or <body> without touching a single line of your existing page code.
This makes it:
- Easy to add (paste a code block)
- Easy to read (clean, indented structure)
- Easy to maintain (update one block instead of hunting through scattered HTML attributes)
- Easy for CMS plugins to manage automatically
The only notable exception: Google recommends Microdata for DiscussionForumPosting schema to avoid duplicating large blocks of text in both the visible content and the schema code.
JSON-LD Basic Syntax
Here is the fundamental structure every JSON-LD schema follows:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Organisation”,
“name”: “Your Business Name”,
“url”: “https://www.example.com”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”,
“width”: “600”,
“height”: “200”
},
“sameAs”: [
“https://www.linkedin.com/company/example”,
“https://twitter.com/example”
]
}
Breaking down what each part does:
- @context — Declares the vocabulary (always “https://schema.org“)
- @type — Declares what kind of entity this is (Organisation, Product, Event, etc.)
- Properties — Key-value pairs that describe the entity (name, url, logo, etc.)
- Nested entities — Objects within objects (the ImageObject inside Organisation above)
Why Schema Markup Matters for SEO
Improved Content Indexing and Relevance
Schema provides explicit context about your content. Without it, Google must rely on natural language processing to figure out what your page is about—and sometimes it gets it wrong.
For example, a page about “Apple” could be about the technology company, the fruit, or even a record label. Organisation schema with the correct sameAs links pointing to Apple Inc.’s official profiles instantly tells Google which “Apple” you mean. This is called entity disambiguation, and it is one of schema’s most powerful but underappreciated benefits.
Rich Results Eligibility
Rich results are visual enhancements in search listings. They range from small additions (star ratings next to a review) to large content modules (recipe carousels, job listing boxes, event details).
These enhancements make your listing stand out, which increases your click-through rate (CTR). Google’s own documentation confirms that “case studies show increased click-through rates, visits, and user engagement on pages with structured data.”
In competitive search results—especially here in the UAE where many businesses compete for the same queries—rich results can be the difference between getting noticed and being invisible. Even small businesses can gain a significant visibility advantage over larger competitors simply by implementing structured data correctly.
Knowledge Graph and Entity Recognition
Google’s Knowledge Graph is a massive database of facts about entities and their relationships. When you add Organisation schema with properties like name, logo, sameAs (linking to your official social profiles), and contactPoint, you are feeding information directly into this database.
This is how knowledge panels appear for brands in search results. It is also how Google connects your content to broader topics and can surface your site in entity-related features like People Also Ask and AI Overviews.
Voice Search and Smart Devices
Voice assistants need clear, structured facts to deliver quick answers. When someone asks their smart speaker “What time does [your restaurant] close?” the answer likely comes from structured data—either from your schema markup or from Google Business Profile data.
Is Schema Markup a Ranking Factor?
No. Schema markup is not a confirmed direct ranking factor. Google has been clear about this.
However, it provides significant indirect benefits:
- Better rich results → higher CTR → positive behavioural signals
- More accurate relevance matching → appearing in more appropriate queries
- Knowledge Graph inclusion → stronger entity recognition → better brand visibility
- Rich results in zero-click searches → visibility even when users do not click
The honest answer is this: schema alone will not push a low-quality page to position one. But for quality content that already deserves to rank, schema can provide the competitive edge that gets it noticed.
Types of Schema Markup That Matter for SEO
Not all Schema.org types are equally useful. The ones that matter most are those Google actively supports for rich results and entity understanding. Google’s Search Gallery documents all structured data features it currently supports, “including examples of how they appear in search results.”
Here are the most important ones, organised by use case.
Article, NewsArticle and BlogPosting Schema
Use case: Blog posts, news articles, educational content, resource centre pages
Key properties:
- headline (the article title)
- author (Person or Organisation with name and url)
- datePublished (when first published, in ISO 8601 format)
- dateModified (last meaningful update)
- image (featured image URL—minimum 1200px wide for best display)
- publisher (Organisation with logo)
Rich result: Top Stories carousel, enhanced article listings with date and author
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Article”,
“headline”: “Schema Markup & Structured Data: The Complete Guide”,
“author”: {
“@type”: “Person”,
“name”: “Author Name”,
“url”: “https://www.example.com/author/name”
},
“datePublished”: “2026-06-11”,
“dateModified”: “2026-06-11”,
“image”: “https://www.example.com/images/schema-guide.jpg”,
“publisher”: {
“@type”: “Organisation”,
“name”: “Your Site Name”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”
}
}
}
Multiple authors should be defined as individual Person entities. If your content sits behind a paywall, Google requires special schema properties to indicate subscription content (isAccessibleForFree set to false with hasPart containing the paywalled section).
Product and ProductGroup Schema
Use case: E-commerce product pages, individual product listings
Key properties:
- name (full product name)
- description
- image
- brand
- offers (with price, priceCurrency, availability, itemCondition)
- aggregateRating
- review
- shippingDetails
- hasMerchantReturnPolicy
Rich result: Product snippets with price and availability, merchant listings, Google Shopping integration
Google’s guidelines state: “The more recommended properties that you provide, the higher quality the result is to users. For example: users prefer job postings with explicitly stated salaries than those without; users prefer recipes with actual user reviews and genuine star ratings.”
This principle applies equally to Product schema. The more complete your product data, the better your rich results appear to searchers. For online stores looking to maximise their structured data alongside broader search strategies, an e-commerce SEO approach integrates Product schema with full-funnel optimisation.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Product”,
“name”: “Premium Arabic Coffee Set”,
“description”: “Handcrafted brass dallah set with 6 cups”,
“image”: “https://www.example.com/images/coffee-set.jpg”,
“brand”: {
“@type”: “Brand”,
“name”: “Arabian Crafts”
},
“offers”: {
“@type”: “Offer”,
“price”: “450”,
“priceCurrency”: “AED”,
“availability”: “https://schema.org/InStock”,
“itemCondition”: “https://schema.org/NewCondition”
},
“aggregateRating”: {
“@type”: “AggregateRating”,
“ratingValue”: “4.7”,
“reviewCount”: “89”
}
}
LocalBusiness Schema
Use case: Businesses with physical locations—shops, restaurants, clinics, offices
Key properties:
- name
- address (PostalAddress with streetAddress, addressLocality, addressRegion, postalCode, addressCountry)
- telephone
- openingHoursSpecification
- geo (latitude and longitude)
- priceRange
- areaServed
- sameAs (social profiles)
Rich result: Local Pack, Knowledge Panel for businesses
Use the most specific subtype available. If you operate a restaurant in Business Bay, use “Restaurant” instead of “LocalBusiness.” If you run a dental clinic in Abu Dhabi, use “Dentist” instead of “MedicalBusiness.” More specific types have additional relevant properties and signal greater precision to Google.
For businesses targeting customers in specific emirates or neighbourhoods, combining LocalBusiness schema with a well-optimised Google Business Profile creates the strongest possible local SEO foundation.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Restaurant”,
“name”: “Al Makan Restaurant”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “Sheikh Zayed Road, Tower 3”,
“addressLocality”: “Dubai”,
“addressRegion”: “Dubai”,
“postalCode”: “00000”,
“addressCountry”: “AE”
},
“telephone”: “+971-4-123-4567”,
“openingHoursSpecification”: {
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”],
“opens”: “11:00”,
“closes”: “23:00”
},
“geo”: {
“@type”: “GeoCoordinates”,
“latitude”: “25.2048”,
“longitude”: “55.2708”
},
“priceRange”: “AED 50-150”,
“servesCuisine”: “Lebanese”
}
Organisation Schema
Use case: Your homepage or about page—establishes your brand as a distinct entity
Key properties:
- name
- legalName (if different from trading name)
- url
- logo (ImageObject with url, width, height)
- contactPoint (telephone and/or email)
- sameAs (array of official social media profile URLs)
- foundingDate
- address (PostalAddress)
- description
- areaServed
Rich result: Knowledge Panel, brand entity recognition
Google says adding organisation structured data to your homepage can “help Google better understand your organization’s administrative details and disambiguate your organization in search results.”
The sameAs property is especially powerful. It links your website to your verified profiles on LinkedIn, X (Twitter), Facebook, Instagram, and other platforms. This helps Google build a complete picture of your brand as an entity and can influence what appears in your knowledge panel.
FAQPage Schema
Use case: FAQ sections with question/answer pairs
Key properties: mainEntity → Question → acceptedAnswer → Answer
Important update: Google now only shows FAQ rich results for well-known authoritative government and health websites. However, FAQ schema still helps with AI comprehension and entity clarity even without the visible rich result.
Event Schema
Use case: Concerts, conferences, webinars, exhibitions, sports matches
Key properties:
- name (the event name, not the venue)
- startDate (ISO 8601 format)
- endDate
- location (Place with address)
- eventStatus (EventScheduled, EventPostponed, EventCancelled, EventRescheduled)
- performer or organiser
- offers (ticket pricing)
Rich result: Event carousel, event details module with date, venue, and pricing
For postponed or cancelled events, keep the original startDate unchanged and use the eventStatus property. If rescheduled, update the status, set the new startDate, and add a previousStartDate property. This helps Google link the updated event to the original listing.
BreadcrumbList Schema
Use case: Every page on your website that has a navigation hierarchy
Key properties:
- itemListElement (array of ListItem entities)
- Each ListItem needs: position, name, and item (URL)
Rich result: Breadcrumb trail shown in search listings instead of the raw URL
Breadcrumbs should represent the most natural way a user would navigate to the page—not necessarily the URL structure.
Review and AggregateRating Schema
Use case: Review pages, product reviews, business reviews from third parties
Key properties:
- author (the reviewer)
- ratingValue
- bestRating and worstRating
- reviewCount (total reviews)
- ratingCount (total ratings)
- itemReviewed (the entity being reviewed)
Rich result: Star ratings displayed in search listings
Critical rule: Google’s guidelines warn that “reviews or ratings not by actual users” may be “considered spammy.” Organisations cannot review themselves. Only genuine third-party reviews from real users qualify.
VideoObject Schema
Use case: Pages with embedded videos
Key properties:
- name (unique video title)
- description
- thumbnailUrl
- uploadDate
- duration (ISO 8601 duration format)
- contentUrl (direct link to video file)
- embedUrl
Rich result: Video carousel, video snippets in search, key moments
Related types include Clip (for highlighted segments within a video) and BroadcastEvent (for live streaming events).
JobPosting Schema
Use case: Individual job listing pages
Key properties:
- title (the job title, not page title)
- description (full job description)
- datePosted
- hiringOrganization
- jobLocation (Place with address) OR jobLocationType (“TELECOMMUTE”)
- baseSalary (salary range with currency)
- employmentType (FULL_TIME, PART_TIME, CONTRACT, etc.)
- validThrough (expiry date)
- applicantLocationRequirements
Rich result: Google Jobs module at the top of job-related searches
Only add JobPosting schema to pages listing individual jobs—not pages with multiple listings.
Recipe Schema
Use case: Food and cooking content
Key properties:
- name, image, author
- prepTime, cookTime, totalTime
- recipeYield (servings)
- recipeIngredient (array of ingredients)
- recipeInstructions (array of HowToStep entities with name and text)
- nutrition (NutritionInformation)
Rich result: Recipe carousel with images, ratings, cook time, and calorie information
Person and ProfilePage Schema
Use case: Author pages, team member pages, contributor bios
Key properties for Person:
- name, url, sameAs, jobTitle, worksFor, image, alumniOf
Key properties for ProfilePage:
- mainEntity (pointing to the Person)
- dateCreated, dateModified
Why this matters for E-E-A-T: Author/Person schema connects content to named individuals, strengthening authorship attribution and the E-E-A-T signals that influence both traditional and AI-powered rankings.
Service Schema
Use case: Service-based businesses—consultants, agencies, contractors, freelancers
Key properties:
- name
- description
- provider (Organisation or Person)
- serviceType
- areaServed
- hasOfferCatalog (for multiple service tiers)
While Service schema does not currently trigger a specific rich result, it significantly helps Google understand what services you offer and match your pages to relevant “near me” and service-related searches. For UAE service businesses—from IT consultancies in Dubai Internet City to cleaning services in Abu Dhabi—this is an underused opportunity.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Service”,
“name”: “SEO Consulting Services”,
“description”: “Full-service search engine optimisation for businesses in the UAE”,
“provider”: {
“@type”: “Organisation”,
“name”: “Your Agency Name”,
“url”: “https://www.example.com”
},
“serviceType”: “Search Engine Optimisation”,
“areaServed”: {
“@type”: “Country”,
“name”: “United Arab Emirates”
}
}
WebSite and Sitelinks Searchbox Schema
Use case: Your homepage
Key properties:
- name (your website name)
- url
- potentialAction (SearchAction with a target URL pattern)
Rich result: Sitelinks Searchbox—a search box that appears in branded search results
This is one of the most commonly missed schema types despite being basic and highly beneficial for branded searches.
Quick Reference Table
| Schema Type | Best For | Rich Result | Priority |
| Article / BlogPosting | Content sites, blogs | Top Stories, enhanced listings | High |
| Product | E-commerce | Product snippets, Shopping | High |
| LocalBusiness | Physical locations | Local Pack, Knowledge Panel | High |
| Organisation | Brand identity | Knowledge Panel | High |
| Event | Events, concerts, webinars | Event carousel | Medium |
| BreadcrumbList | All pages with hierarchy | Breadcrumb trail in SERPs | High |
| Review / AggregateRating | Review content | Star ratings | Medium |
| VideoObject | Video content | Video carousel | Medium |
| JobPosting | Job listings | Google Jobs | Medium |
| Recipe | Food content | Recipe carousel | Medium |
| Person / ProfilePage | Author/team pages | Author attribution | Medium |
| Service | Service businesses | Entity recognition | Medium |
| WebSite | Homepage | Sitelinks Searchbox | Medium |
| FAQPage | Q&A content | FAQ dropdowns (limited) | Low |
💡 Tip: Google’s Search Gallery lists all structured data features currently supported, including “articles, books, breadcrumbs, carousels, course details, datasets, discussion forums, educational Q&As, employer ratings, salary estimates, events, fact checks, FAQs, image metadata, job postings, videos, local businesses, math solvers, movies, organizations, practice problems, products, profile pages, Q&As, recipes, reviews, software apps, speakable content, subscriptions, vacation rentals, and vehicle listings.”
How to Add Schema Markup to Your Website
Step 1: Identify Which Pages Need Schema
Before writing any code, audit your content and decide what schema types each page needs:
- Homepage → Organisation + WebSite + BreadcrumbList
- Blog posts → Article or BlogPosting + BreadcrumbList + Author (Person)
- Product pages → Product + BreadcrumbList + Review/AggregateRating
- Service pages → Service + BreadcrumbList
- Location pages → LocalBusiness + BreadcrumbList
- Event pages → Event + BreadcrumbList
- Team/About page → Organisation + Person/ProfilePage
- Video pages → VideoObject + BreadcrumbList
Prioritise pages that already rank well. Google’s own documentation suggests: “Take some pages on your site that are not using any structured data, and have several months of data in Search Console… Add structured data or other features to your pages. Confirm that your markup is valid… Record the performance for a few months.”
Step 2: Generate Your Schema Markup
Method 1: Schema Generators (Best for Beginners)
Schema generators let you select a type, fill in fields, and get ready-to-use JSON-LD code:
- Dentsu Schema Markup Generator — clean interface, supports most common types
- Google’s Structured Data Markup Helper — lets you tag elements directly on your page
Method 2: AI Assistants
ChatGPT, Google Gemini, or Claude can generate accurate JSON-LD when you give them specific details. Use a prompt like:
“Generate JSON-LD schema markup for [type] with these properties: [list each property and its value].”
Always validate AI-generated schema before implementing. AI assistants occasionally make syntax errors or use deprecated properties.
Method 3: Write Manually
Using Schema.org documentation as your reference, you can write JSON-LD line by line. This gives you complete control over complex nested schemas but takes longer and carries higher risk of syntax errors (a missing comma can break the entire block).
Step 3: Add Schema to Your Website
Option A: WordPress Plugins (No Code Required)
If you use WordPress, these plugins handle schema for you:
- Yoast SEO — automatically adds Article, Organisation, Person, and BreadcrumbList schema. The paid version offers advanced schema editing.
- Rank Math — includes a built-in visual schema editor supporting 20+ types. Very popular in the UAE WordPress community.
- Schema Pro — a dedicated schema plugin with automation rules for adding schema to specific post types or categories.
- WPCode or Code Snippets — for injecting custom JSON-LD into your site’s <head> without editing theme files.
Most modern content management systems can add basic schema right out of the box. Generally speaking, if you use a popular CMS like Wix or Webflow, it is just a matter of tweaking the schema settings to your preferences.
Option B: Manual HTML Insertion
For static websites or when plugins are not available:
- Access your website files through your hosting file manager or an FTP tool
- Open the HTML file for your target page
- Paste your JSON-LD code (including the <script type=”application/ld+json”> wrapper) inside the <head> section
- Save the file
Option C: Google Tag Manager (GTM)
If you prefer managing scripts from a centralised dashboard:
- In GTM, create a new Custom HTML tag
- Paste your complete JSON-LD code (with script tags) into the tag
- Set the trigger (specific page, all pages, or page group)
- Publish the container
Google confirms it can read schema deployed through GTM and even dynamically added via JavaScript.
Option D: Platform-Specific Methods
- Shopify — Edit theme.liquid file or use apps like “JSON-LD for SEO.” For Shopify store owners looking to maximise search visibility, Product schema implementation through liquid templates offers the most control.
- Webflow — Use Custom Code embed element in pages or site-wide header settings
- Wix — Use the built-in Structured Data settings under SEO Dashboard, or Wix Velo for custom schema
- Squarespace — Use the Code Injection feature under Settings > Advanced
Where to Place JSON-LD in HTML
- Best location: Inside the <head> tag — crawlers parse this section first, giving them immediate access to your structured data
- Also valid: Inside <body> or before the closing </body> tag — Google will still read it
- Dynamic pages (SPAs): Ensure schema is present in the rendered DOM after JavaScript execution
Google’s guidelines confirm: “Put the structured data on the page that it describes, unless specified otherwise by the documentation.”
💡 Tip: If you use Google Tag Manager to deploy schema, remember that AI crawlers—GPTBot (OpenAI), ClaudeBot (Anthropic), and PerplexityBot—typically do not execute JavaScript. For AI search visibility, add your schema as a static <script type=”application/ld+json”> block directly in your HTML source code, not solely through client-side JavaScript or GTM.
How to Test and Validate Schema Markup
Schema code can break from a single misplaced comma or missing bracket. Always validate before and after implementation.
Google Rich Results Test
What it does: Tests whether your page qualifies for Google-specific rich results
How to use it:
- Go to the Rich Results Test tool
- Choose “Code” tab to test raw JSON-LD, or “URL” tab to test a live page
- Click “Test Code” or “Test URL”
- Review results: green = valid, yellow = warnings, red = errors
The left panel shows your code; the right panel shows detected items and any issues with exact line numbers. Fix errors and re-test until everything passes.
Google confirms: “You can test compliance with technical guidelines using the Rich Results Test and the URL Inspection tool, which catch most technical errors.”
Schema Markup Validator
What it does: Validates ALL structured data against the complete Schema.org specification—not just Google-supported types
How to use it:
- Go to validator.schema.org
- Paste code or enter a live URL
- Run the test
- Review errors and warnings
Best for: Comprehensive schema validation regardless of which search engine you are targeting.
Google Search Console (Enhancements Reports)
For ongoing monitoring at scale:
- Log into Google Search Console
- Navigate to the Enhancements section in the left sidebar
- You will see reports for each schema type detected across your site
- Each report shows valid items, items with warnings, and items with errors
- Click into any report for page-level details
Use the URL Inspection Tool for checking individual pages. Google’s documentation recommends: “Confirm that your markup is valid, and that Google has found your structured data using the URL Inspection tool on your page.”
For a full list of recommended validation and auditing platforms beyond Google’s own tools, see our roundup of the best SEO tools.
Common Schema Errors and How to Fix Them
| Error | What Causes It | How to Fix |
| Missing required field | A mandatory property was not included | Add the required property with a valid value |
| Invalid value type | Wrong data format (text where a date is expected) | Use the correct format (ISO 8601 for dates, URLs for url properties) |
| Syntax error | Missing comma, bracket, or quotation mark | Run code through a JSON validator to find the exact position |
| Schema-content mismatch | Schema data does not match what is visible on the page | Update schema to reflect actual, visible page content |
| Deprecated type or property | Using an outdated element no longer supported | Replace with the current equivalent from Schema.org |
| Missing @context declaration | No Schema.org reference at the start | Add “@context”: “https://schema.org” |
| Duplicate schema | Same entity marked up multiple times on one page | Remove duplicates; use @id to reference a single entity |
💡 Tip: Always validate your schema TWICE. First, test the raw code in isolation (paste into the testing tool). Second, test the live URL after deployment. Schema that works perfectly in isolation can break when embedded in a page due to conflicts with existing scripts, CMS modifications, or plugin interference.
Schema Markup Best Practices
Follow these rules to ensure your structured data is effective, compliant, and sustainable. These are drawn directly from Google’s official guidelines:
- Use JSON-LD format — It is Google’s recommended format, easiest to implement, and cleanest to maintain
- Choose the most specific type available — Use “Restaurant” not “LocalBusiness,” use “NewsArticle” not “Article,” when the more specific type applies
- Only mark up content that is visible on the page — Google states: “Your structured data must be a true representation of the page content.” Hidden or misleading markup violates spam policies and can trigger a manual action
- Include all required AND recommended properties — “Items that are missing required properties are not eligible for rich results.” Recommended properties improve your rich result quality and competitiveness
- Keep schema updated — Google’s policy states: “Provide up-to-date information. We won’t show a rich result for time-sensitive content that is no longer relevant.” When prices change, events get rescheduled, or job listings expire, update the corresponding schema immediately
- Use @id for entity consistency — Assign a stable @id value (typically a URL fragment like “@id”: “https://yoursite.com/#organisation”) so the same entity can be referenced across multiple schema blocks without duplication
- Connect schemas using @graph — When a single page has multiple schema types (Article + BreadcrumbList + Organisation + Person), use @graph to define them in one clean JSON-LD block with @id cross-references
- Never self-review — Your organisation cannot use Review schema about itself. Google warns that reviews not by actual users are considered spammy
- Mark all items in a list, or none — Google states: “If you mark up one item in a list you must mark up all items; marking up just one category entity from all listed on the page is against our guidelines.”
- Ensure images are crawlable — “All image URLs specified in structured data must be crawlable and indexable. Otherwise, Google Search can’t find and display them on the search results page.”
- Do not block Googlebot access — “Don’t block your structured data pages to Googlebot using robots.txt, noindex, or any other access control methods.”
- Validate before and after deployment — Test raw code first, then test the live URL to catch any implementation conflicts
- Monitor regularly in Google Search Console — Check Enhancements reports at least monthly for new errors or warnings
- Do not over-markup — Only add schema types that genuinely describe your content. Adding irrelevant schema is considered misleading
Schema Markup for AI Search and Modern SEO
The relationship between schema markup and AI search is one of the most discussed topics in SEO right now. Here is what the evidence actually shows. For a deeper understanding of how to optimise specifically for AI-powered search experiences, see our guide on generative engine optimisation.
How Google Uses Structured Data in AI Overviews
Google’s AI Overviews (the AI-generated summaries that appear at the top of some search results) draw heavily from the Knowledge Graph. Since structured data feeds entity information into the Knowledge Graph, schema plays an indirect but meaningful role in AI search visibility.
Google’s documentation clarifies that no special or new schema is required for AI features. Standard, accurate structured data implementation is sufficient. The key principle remains the same: make sure your structured data accurately represents your page content.
Can ChatGPT, Claude, and Other LLMs Read Schema?
Large language models are certainly capable of reading structured data—it is machine-readable by design. However, most LLMs do not actively crawl websites the way Google does. They rely on curated training data with periodic updates.
Research by SEO professionals has demonstrated that AI models may process schema as plain text within HTML rather than interpreting it as semantic metadata with special meaning. The structured format itself may not matter to these systems—the information is simply read as part of the overall page content.
The notable exception is Google Gemini. Evidence suggests that Gemini uses structured data as part of its “grounding” process—the mechanism by which Gemini queries Google’s search index to verify its responses.
The Indirect Pathway: Schema → Knowledge Graph → AI
This is the most reliable and proven pathway for schema to influence AI:
- You implement comprehensive schema on your website
- Google crawls your site and extracts structured data
- Entity information feeds into Google’s Knowledge Graph
- The Knowledge Graph provides grounding data for Gemini and AI Overviews
- When someone asks a question related to your entity, the AI can surface accurate information about you
This is why Organisation schema, Person schema, and sameAs links are so valuable for AI visibility. They establish your brand as a clearly defined entity in Google’s knowledge base.
Practical Recommendations for AI Search Visibility
- Implement schema as static HTML — Use <script type=”application/ld+json”> directly in your source code. AI crawlers (GPTBot, ClaudeBot, PerplexityBot) typically cannot execute JavaScript, so schema deployed only via GTM or client-side JS may be invisible to them.
- Complete your Organisation schema — Include comprehensive sameAs arrays linking to all your verified profiles across the web.
- Use Person/Author schema — Connect your content to named individuals with real credentials. This strengthens E-E-A-T signals that both Google and AI systems evaluate.
- Make Product schema complete — AI shopping agents (including ChatGPT’s shopping features and Google’s AI-powered product discovery) evaluate structured product data to recommend products. Incomplete Product schema means incomplete visibility to these systems.
- Keep schema consistent with visible content — AI systems cross-reference claims. If your schema says one thing and your page content says another, trust signals break down.
- Monitor Bing Webmaster Tools — Several AI platforms, including Perplexity and ChatGPT Search, use Bing’s index as a data source. Strong performance in Bing may influence your visibility in these AI-powered search products.
If your business is looking for hands-on support with AI search visibility, explore our AI SEO services.
💡 Key Point: Schema markup’s greatest AI value is indirect. It strengthens your entity signals in Google’s Knowledge Graph, which then serves as the factual foundation that AI systems—especially Gemini and AI Overviews—use to verify and generate responses about your brand, products, and content.
Advanced Schema Techniques
Using @graph for Connected Schemas
When a single page needs multiple schema types—which is the norm for most pages—you can define them all in one JSON-LD block using @graph. This creates a clean, interconnected structure where entities reference each other through @id values.
JSON
{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “Organisation”,
“@id”: “https://www.example.com/#organisation”,
“name”: “Your Company”,
“url”: “https://www.example.com”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”
}
},
{
“@type”: “WebSite”,
“@id”: “https://www.example.com/#website”,
“url”: “https://www.example.com”,
“name”: “Your Company”,
“publisher”: {“@id”: “https://www.example.com/#organisation”}
},
{
“@type”: “Article”,
“@id”: “https://www.example.com/blog/post/#article”,
“headline”: “Your Article Title”,
“author”: {“@id”: “https://www.example.com/#author”},
“publisher”: {“@id”: “https://www.example.com/#organisation”},
“datePublished”: “2026-06-11”
},
{
“@type”: “Person”,
“@id”: “https://www.example.com/#author”,
“name”: “Author Name”,
“url”: “https://www.example.com/team/author-name”
}
]
}
Notice how each entity has an @id, and other entities reference it using {“@id”: “…”} instead of repeating all the information. This eliminates duplication and creates a clear semantic map of your page.
Entity Disambiguation with @id and sameAs
@id gives each entity a unique identifier so it can be referenced consistently across your entire website’s schema. Best practice is to use URL fragments:
- “@id”: “https://yoursite.com/#organisation” for your company
- “@id”: “https://yoursite.com/#website” for your website entity
- “@id”: “https://yoursite.com/team/name/#person” for team members
sameAs links your entity to authoritative external sources. This helps Google perform entity linking—connecting your entity to the correct entry in its Knowledge Graph:
JSON
“sameAs”: [
“https://www.linkedin.com/company/yourcompany”,
“https://www.instagram.com/yourcompany”,
“https://en.wikipedia.org/wiki/Your_Company”
]
Together, @id and sameAs help search engines resolve ambiguity and build a complete picture of who you are.
Nesting Schemas for Depth
Schema types can be nested inside each other to create rich, detailed descriptions:
- Review nested inside Product (a product review with the product it reviews)
- Person (author) nested inside Article (the article they wrote)
- PostalAddress nested inside Organisation (where the company is located)
- Offer nested inside Product (the price and availability of the product)
- HowToStep nested inside Recipe (each cooking step)
- ListItem nested inside BreadcrumbList (each breadcrumb link)
The general rule: if a property’s expected value is another entity type, you should nest a full entity there rather than using a plain text string.
Google confirms you can “include multiple structured data objects on a page, as long as they describe user-visible page content.”
Schema for Multilingual Websites
If your website serves content in multiple languages (common for UAE businesses publishing in both English and Arabic), use the inLanguage property:
JSON
{
“@type”: “Article”,
“headline”: “Your Article Title”,
“inLanguage”: “en-AE”
}
Each language version of a page should have its own schema with the appropriate language tag. Combine this with hreflang tags for complete international SEO coverage.
Monitoring Schema Markup Performance
Google Search Console Enhancements
The Enhancements section in GSC is your primary monitoring dashboard:
- What you see: Each detected schema type gets its own report (Articles, Products, Breadcrumbs, etc.)
- Status categories: Valid, Valid with warnings, Errors
- Historical view: Track valid/error counts over time to spot new issues quickly
- Page-level detail: Click into any item to see which specific pages have problems
Set up email notifications in GSC to get alerted when new errors appear.
Measuring the Impact of Schema
Google recommends a clear before-and-after methodology: “Take some pages on your site that are not using any structured data, and have several months of data in Search Console… Add structured data… Record the performance for a few months in the Performance report, and filter by URL to compare performance of your page.”
To understand whether your schema implementation is working:
- In GSC Performance Report — Filter by “Search appearance” to see impressions and clicks specifically for rich results
- Track CTR changes — Compare click-through rates before and after schema implementation on specific pages. Understanding which SEO KPIs to track ensures you measure the right outcomes.
- Monitor rich result ownership — Use position tracking tools to see which SERP features your pages appear in
- Check Bing Webmaster Tools — Bing provides performance metrics for AI chat references to your website, which is increasingly valuable
When Rich Results Do Not Appear
Valid schema does not guarantee rich results. Google decides based on:
- Page and site quality
- Authority and trust signals
- Query type and user intent
- User context (location, device, search history)
- Google’s assessment of whether the rich result improves the search experience
Google’s structured data policies are clear: implementing structured data “enables a feature to be present” but “does not guarantee that it will be present.”
If your schema is valid but no rich results appear:
- Focus on content quality and depth
- Build site authority through quality backlinks
- Ensure a strong E-E-A-T foundation (expertise signals, author credentials, trustworthiness indicators)
- Be patient—rich results may take weeks to appear after implementation
Unlike render-blocking JavaScript or large media files, JSON-LD schema has zero impact on your Core Web Vitals—it is a lightweight script block that does not affect page loading speed or layout stability.
Frequently Asked Questions About Schema Markup
What is schema markup in simple terms?
Schema markup is code you add to your website that tells search engines exactly what your content is about. It uses a standard vocabulary from Schema.org to label things like products, events, businesses, articles, and people so that Google can understand your pages without guessing. Google describes it as “a standardized format for providing information about a page and classifying the page content.”
Is schema markup a ranking factor?
No. Google has confirmed that structured data is not a direct ranking factor. However, it provides significant indirect benefits: better rich results increase click-through rates, more accurate entity understanding improves relevance matching, and Knowledge Graph inclusion strengthens your brand’s visibility across Google products including AI Overviews.
What does schema markup do for SEO?
Schema markup helps SEO in four main ways. First, it helps Google understand your content more accurately so it shows for more relevant searches. Second, it makes your pages eligible for rich results (star ratings, prices, FAQ dropdowns, event dates) with “increased click-through rates, visits, and user engagement.” Third, it feeds your entity information into Google’s Knowledge Graph. Fourth, it prepares your content for voice search and AI-powered search features.
What is the difference between schema markup and structured data?
Structured data is the broad concept—any information organised in a machine-readable format. Schema markup is the specific implementation of the Schema.org vocabulary on a website using formats like JSON-LD. Think of structured data as the category and schema markup as the specific tool within that category.
Which format should I use for schema markup?
JSON-LD. Google’s documentation states: “In general, we recommend using a format that’s easiest for you to implement and maintain (in most cases, that’s JSON-LD).” It is the easiest to implement (a separate script block that does not interfere with your HTML), the simplest to read and maintain, and compatible with all major CMS platforms and plugins.
Does schema markup help with AI search?
Indirectly, yes. Schema feeds entity information into Google’s Knowledge Graph, which AI systems like Gemini use for grounding and verification. While ChatGPT and Claude do not directly parse schema as semantic metadata during generation, Google’s AI Overviews draw from Knowledge Graph data—which is partially built from your structured data. For maximum AI visibility, implement schema as static HTML (not via JavaScript or GTM alone) since most AI crawlers cannot execute JS.
How important is schema markup for local SEO?
Very important. LocalBusiness schema powers your presence in the Local Pack and local Knowledge Panels. Include complete details: business name, address (PostalAddress), telephone, opening hours, geo coordinates, price range, area served, and sameAs links to your Google Business Profile and social accounts. For UAE businesses with multiple locations, each location should have its own LocalBusiness schema on its dedicated page.
Can I use multiple schema types on one page?
Yes. Google confirms: “You can include multiple structured data objects on a page, as long as they describe user-visible page content.” A blog post typically has Article + BreadcrumbList + Organisation (publisher) + Person (author). Use @graph to define all entities in a single JSON-LD block with @id cross-references.
What is JSON-LD?
JSON-LD stands for JavaScript Object Notation for Linked Data. It is an open web standard for encoding structured information in JSON format. In SEO, it is the coding format used to write schema markup inside a <script type=”application/ld+json”> tag on your web pages. Google recommends it because it is clean, readable, and completely separated from your visible HTML.
How often should I update schema markup?
Update schema whenever the content it describes changes. If product prices change, update the Offer schema. If events get rescheduled, update Event schema with the new dates and appropriate eventStatus. If articles receive substantial edits, update the dateModified property. Google’s policy states they “won’t show a rich result for time-sensitive content that is no longer relevant.”
What happens if my schema has errors?
Schema with errors may not qualify for rich results, and in serious cases (misleading or spammy markup), Google can take action that removes your pages from rich result eligibility. Minor syntax errors (missing commas, incorrect value formats) simply prevent the schema from being read correctly. Always validate before deployment using the Rich Results Test and Schema Markup Validator.
Do I need schema markup on every page?
Not necessarily the same types on every page. Organisation and WebSite schema belong on your homepage. BreadcrumbList belongs on most pages. Article or BlogPosting schema belongs on content pages. Product schema belongs on product pages. The principle is: add schema that accurately describes the content and entities on each specific page. Google’s structured data policies state to “put the structured data on the page that it describes.”
Schema Markup & Structured Data: The Complete Guide (With Code Examples)
Schema markup is a type of structured data code you add to your website so search engines like Google can better understand what your content is about. It uses a shared vocabulary from Schema.org to describe things on your pages—products, events, businesses, articles, people—in a format that machines can read instantly.
Think of it this way: your website speaks to humans through words and images. Schema markup is how your website speaks to search engines. As Google’s documentation explains: “Structured data is a standardized format for providing information about a page and classifying the page content.”
When Google clearly understands your content, it can show your pages for the right searches and display eye-catching rich results like star ratings, prices, FAQ dropdowns, and event dates directly in the search results.
Schema.org was created in 2011 through a collaboration between Google, Bing, Yahoo, and Yandex to give website owners a universal language for describing web content. Today, it contains hundreds of distinct types and properties for marking up virtually anything on your site.
This guide covers everything from the basics of what structured data means in SEO to advanced techniques like connecting schemas with @graph and optimising for AI search engines. Whether you run a local shop in Dubai, manage an e-commerce store, or publish a blog, you will find clear, actionable steps here.
What Is Structured Data in SEO?
Structured data is any information that is organised in a standardised, machine-readable format. In the SEO world, it specifically refers to code that describes entities (people, products, events, organisations), their attributes (name, price, date, location), and the relationships between them.
Here is a simple way to think about it. Imagine you hand someone a box with no label. They have to open it, look inside, and guess what it is. Now imagine you stick a clear label on that box: “Contains 12 red apples, harvested June 2026, from Al Ain farm.” The person instantly knows what is inside without any guessing.
That is exactly what structured data does for search engines. Google processes billions of web pages every day. Plain text requires the search engine to interpret meaning—which it sometimes gets wrong. Structured data removes that guesswork entirely by presenting information in a pre-organised format that search engine crawlers can parse without ambiguity.
Google explicitly states: “Google uses structured data that it finds on the web to understand the content of the page, as well as to gather information about the web and the world in general, such as information about the people, books, or companies that are included in the markup.”
When Google understands your content better, it can:
- Show your pages in more relevant search queries
- Display rich results (visual enhancements in search listings)
- Add your information to its Knowledge Graph
- Surface your content in AI Overviews and voice search results
💡 Key Point: Structured data does not just describe what is visible on a page. It can also describe abstract entities associated with your website—your organisation, industry, expertise, or the relationships between people and brands connected to your site. Google confirms it uses this information “to gather information about the web and the world in general.”
What Is Schema Markup?
Schema markup is the specific vocabulary (or taxonomy) from Schema.org that you implement in code on your website to describe content in a way search engines can read. If structured data is the concept, schema markup is the practical tool you use to make it happen.
It works on a hierarchical system. At the very top sits a root type called “Thing.” Everything in Schema.org inherits from Thing. From there, primary types branch out:
- Organisation (companies, schools, non-profits)
- Person (individuals—alive, dead, or fictional)
- Product (physical or digital items for sale)
- Event (scheduled activities at a specific time and place)
- CreativeWork (articles, books, movies, recipes)
- Place (physical locations)
- Action (activities performed by entities)
Each type has properties—these are the specific details that describe it. For example, a Product has properties like name, price, availability, and brand. An Event has properties like startDate, location, and performer.
You write schema markup in one of three formats—JSON-LD, Microdata, or RDFa—and embed it in your website’s HTML code. Google then reads this code when it crawls your page and uses it to understand exactly what entities exist on that page and what attributes they have.
The full hierarchy of Schema.org types is publicly available and maintained collaboratively as an open standard.
💡 Key Point: Schema markup essentially performs what data scientists call Named Entity Recognition (NER) for search engines. Instead of forcing Google to guess what entities exist on your page, you explicitly label them—removing interpretation errors and helping your content match more relevant queries.
Structured Data vs Schema Markup: What Is the Difference?
These terms get used interchangeably in SEO conversations, and in most practical situations that is perfectly fine. But technically, they are different layers of the same system. Understanding the distinction helps you communicate clearly with developers and avoid confusion.
| Term | What It Is | Simple Analogy |
| Structured Data | Any organised, machine-readable information | A filled-out form |
| Schema.org | The vocabulary and taxonomy of agreed-upon terms | The language the form is written in |
| Schema Markup | The actual code implementing Schema.org on your page | The act of filling out the form |
| JSON-LD | The coding format used to write the markup | The pen you use to write |
| Rich Results | The visual output Google shows in SERPs | The reward for completing the form correctly |
The confusion between schema markup and rich snippets is especially common. Rich snippets (now called rich results) are the output—they are what Google displays. Schema markup is the input—the code you add. Having schema on your page does not guarantee rich results, but without schema, most rich results are impossible.
Another common mix-up: plain text versus structured data. Plain text (unstructured data) is content without standardised formatting—Google has to interpret these using natural language understanding. Structured data is pre-organised in a format machines can read instantly, like JSON-LD code with clear type declarations and property-value pairs.
How Schema Markup Works: The Technical Foundation
Schema markup is a core component of technical SEO—the behind-the-scenes optimisation that ensures your website is crawlable, indexable, and correctly understood by search engines.
The Schema.org Hierarchy
Schema.org follows a parent-child structure. Think of it like a family tree. “Thing” sits at the top. Below it, major categories branch out. Below those, increasingly specific types appear.
For example:
text
Thing → Organisation → LocalBusiness → Restaurant
Thing → CreativeWork → Article → NewsArticle
Thing → Event → MusicEvent
Thing → Product
This hierarchy matters because properties are inherited downward. A Restaurant inherits all properties of LocalBusiness, which inherits all properties of Organisation, which inherits all properties of Thing. This means a Restaurant schema can include name, url, and description (from Thing), plus address and telephone (from Organisation), plus openingHoursSpecification and priceRange (from LocalBusiness), plus menu and servesCuisine (from Restaurant).
Google’s guidelines emphasise: “Try to use the most specific applicable type and property names defined by schema.org for your markup.”
How Search Engines Process Structured Data
When Googlebot crawls a page, here is what happens with your schema:
- Discovery — The crawler finds the <script type=”application/ld+json”> block in your HTML
- Parsing — It reads the @context (Schema.org) and @type (what entity this is) declarations
- Extraction — It pulls out all property-value pairs as structured triples (subject → predicate → object)
- Knowledge Graph Integration — This information may be added to Google’s Knowledge Graph—a massive database mapping relationships between entities worldwide
- Rich Result Evaluation — Google checks if your schema meets the requirements for rich results based on content quality, site authority, and user experience
- Display Decision — If everything qualifies, Google may show rich results for your page in relevant searches
The critical thing to understand: schema markup tells Google what entities exist. Google still decides whether to reward you with rich results. As Google confirms: “Google doesn’t guarantee rich results, even with proper markup.”
Google also notes that structured data can help even when it does not produce visible changes: “You’re always welcome to use structured data to provide better machine-readable context for your pages, which may not always result in visible changes, but can still help our systems to show your pages for relevant queries.”
Schema Markup Formats: JSON-LD vs Microdata vs RDFa
There are three formats for writing schema markup. All three can express Schema.org vocabulary, but they work very differently.
| Feature | JSON-LD | Microdata | RDFa |
| First introduced | 2014 | 2009 | 2004 |
| Where it goes | Separate <script> block | Inline within HTML elements | Inline within HTML elements |
| Placement | <head> or <body> | Scattered throughout HTML | Scattered throughout HTML |
| Google’s preference | ✅ Recommended | Supported | Supported |
| Human readability | High | Low | Low |
| Maintenance difficulty | Easy (isolated from HTML) | Hard (tied to templates) | Hard (tied to templates) |
| CMS compatibility | Excellent | Limited | Limited |
Why JSON-LD Is the Standard
Google explicitly states: “In general, we recommend using a format that’s easiest for you to implement and maintain (in most cases, that’s JSON-LD); all 3 formats are equally fine for Google, as long as the markup is valid and properly implemented per the feature’s documentation.”
JSON-LD sits inside a <script type=”application/ld+json”> tag, completely separated from your visible HTML content. You can drop it in the <head> or <body> without touching a single line of your existing page code.
This makes it:
- Easy to add (paste a code block)
- Easy to read (clean, indented structure)
- Easy to maintain (update one block instead of hunting through scattered HTML attributes)
- Easy for CMS plugins to manage automatically
The only notable exception: Google recommends Microdata for DiscussionForumPosting schema to avoid duplicating large blocks of text in both the visible content and the schema code.
JSON-LD Basic Syntax
Here is the fundamental structure every JSON-LD schema follows:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Organisation”,
“name”: “Your Business Name”,
“url”: “https://www.example.com”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”,
“width”: “600”,
“height”: “200”
},
“sameAs”: [
“https://www.linkedin.com/company/example”,
“https://twitter.com/example”
]
}
Breaking down what each part does:
- @context — Declares the vocabulary (always “https://schema.org“)
- @type — Declares what kind of entity this is (Organisation, Product, Event, etc.)
- Properties — Key-value pairs that describe the entity (name, url, logo, etc.)
- Nested entities — Objects within objects (the ImageObject inside Organisation above)
Why Schema Markup Matters for SEO
Improved Content Indexing and Relevance
Schema provides explicit context about your content. Without it, Google must rely on natural language processing to figure out what your page is about—and sometimes it gets it wrong.
For example, a page about “Apple” could be about the technology company, the fruit, or even a record label. Organisation schema with the correct sameAs links pointing to Apple Inc.’s official profiles instantly tells Google which “Apple” you mean. This is called entity disambiguation, and it is one of schema’s most powerful but underappreciated benefits.
Rich Results Eligibility
Rich results are visual enhancements in search listings. They range from small additions (star ratings next to a review) to large content modules (recipe carousels, job listing boxes, event details).
These enhancements make your listing stand out, which increases your click-through rate (CTR). Google’s own documentation confirms that “case studies show increased click-through rates, visits, and user engagement on pages with structured data.”
In competitive search results—especially here in the UAE where many businesses compete for the same queries—rich results can be the difference between getting noticed and being invisible. Even small businesses can gain a significant visibility advantage over larger competitors simply by implementing structured data correctly.
Knowledge Graph and Entity Recognition
Google’s Knowledge Graph is a massive database of facts about entities and their relationships. When you add Organisation schema with properties like name, logo, sameAs (linking to your official social profiles), and contactPoint, you are feeding information directly into this database.
This is how knowledge panels appear for brands in search results. It is also how Google connects your content to broader topics and can surface your site in entity-related features like People Also Ask and AI Overviews.
Voice Search and Smart Devices
Voice assistants need clear, structured facts to deliver quick answers. When someone asks their smart speaker “What time does [your restaurant] close?” the answer likely comes from structured data—either from your schema markup or from Google Business Profile data.
Is Schema Markup a Ranking Factor?
No. Schema markup is not a confirmed direct ranking factor. Google has been clear about this.
However, it provides significant indirect benefits:
- Better rich results → higher CTR → positive behavioural signals
- More accurate relevance matching → appearing in more appropriate queries
- Knowledge Graph inclusion → stronger entity recognition → better brand visibility
- Rich results in zero-click searches → visibility even when users do not click
The honest answer is this: schema alone will not push a low-quality page to position one. But for quality content that already deserves to rank, schema can provide the competitive edge that gets it noticed.
Types of Schema Markup That Matter for SEO
Not all Schema.org types are equally useful. The ones that matter most are those Google actively supports for rich results and entity understanding. Google’s Search Gallery documents all structured data features it currently supports, “including examples of how they appear in search results.”
Here are the most important ones, organised by use case.
Article, NewsArticle and BlogPosting Schema
Use case: Blog posts, news articles, educational content, resource centre pages
Key properties:
- headline (the article title)
- author (Person or Organisation with name and url)
- datePublished (when first published, in ISO 8601 format)
- dateModified (last meaningful update)
- image (featured image URL—minimum 1200px wide for best display)
- publisher (Organisation with logo)
Rich result: Top Stories carousel, enhanced article listings with date and author
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Article”,
“headline”: “Schema Markup & Structured Data: The Complete Guide”,
“author”: {
“@type”: “Person”,
“name”: “Author Name”,
“url”: “https://www.example.com/author/name”
},
“datePublished”: “2026-06-11”,
“dateModified”: “2026-06-11”,
“image”: “https://www.example.com/images/schema-guide.jpg”,
“publisher”: {
“@type”: “Organisation”,
“name”: “Your Site Name”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”
}
}
}
Multiple authors should be defined as individual Person entities. If your content sits behind a paywall, Google requires special schema properties to indicate subscription content (isAccessibleForFree set to false with hasPart containing the paywalled section).
Product and ProductGroup Schema
Use case: E-commerce product pages, individual product listings
Key properties:
- name (full product name)
- description
- image
- brand
- offers (with price, priceCurrency, availability, itemCondition)
- aggregateRating
- review
- shippingDetails
- hasMerchantReturnPolicy
Rich result: Product snippets with price and availability, merchant listings, Google Shopping integration
Google’s guidelines state: “The more recommended properties that you provide, the higher quality the result is to users. For example: users prefer job postings with explicitly stated salaries than those without; users prefer recipes with actual user reviews and genuine star ratings.”
This principle applies equally to Product schema. The more complete your product data, the better your rich results appear to searchers. For online stores looking to maximise their structured data alongside broader search strategies, an e-commerce SEO approach integrates Product schema with full-funnel optimisation.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Product”,
“name”: “Premium Arabic Coffee Set”,
“description”: “Handcrafted brass dallah set with 6 cups”,
“image”: “https://www.example.com/images/coffee-set.jpg”,
“brand”: {
“@type”: “Brand”,
“name”: “Arabian Crafts”
},
“offers”: {
“@type”: “Offer”,
“price”: “450”,
“priceCurrency”: “AED”,
“availability”: “https://schema.org/InStock”,
“itemCondition”: “https://schema.org/NewCondition”
},
“aggregateRating”: {
“@type”: “AggregateRating”,
“ratingValue”: “4.7”,
“reviewCount”: “89”
}
}
LocalBusiness Schema
Use case: Businesses with physical locations—shops, restaurants, clinics, offices
Key properties:
- name
- address (PostalAddress with streetAddress, addressLocality, addressRegion, postalCode, addressCountry)
- telephone
- openingHoursSpecification
- geo (latitude and longitude)
- priceRange
- areaServed
- sameAs (social profiles)
Rich result: Local Pack, Knowledge Panel for businesses
Use the most specific subtype available. If you operate a restaurant in Business Bay, use “Restaurant” instead of “LocalBusiness.” If you run a dental clinic in Abu Dhabi, use “Dentist” instead of “MedicalBusiness.” More specific types have additional relevant properties and signal greater precision to Google.
For businesses targeting customers in specific emirates or neighbourhoods, combining LocalBusiness schema with a well-optimised Google Business Profile creates the strongest possible local SEO foundation.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Restaurant”,
“name”: “Al Makan Restaurant”,
“address”: {
“@type”: “PostalAddress”,
“streetAddress”: “Sheikh Zayed Road, Tower 3”,
“addressLocality”: “Dubai”,
“addressRegion”: “Dubai”,
“postalCode”: “00000”,
“addressCountry”: “AE”
},
“telephone”: “+971-4-123-4567”,
“openingHoursSpecification”: {
“@type”: “OpeningHoursSpecification”,
“dayOfWeek”: [“Monday”, “Tuesday”, “Wednesday”, “Thursday”, “Friday”, “Saturday”, “Sunday”],
“opens”: “11:00”,
“closes”: “23:00”
},
“geo”: {
“@type”: “GeoCoordinates”,
“latitude”: “25.2048”,
“longitude”: “55.2708”
},
“priceRange”: “AED 50-150”,
“servesCuisine”: “Lebanese”
}
Organisation Schema
Use case: Your homepage or about page—establishes your brand as a distinct entity
Key properties:
- name
- legalName (if different from trading name)
- url
- logo (ImageObject with url, width, height)
- contactPoint (telephone and/or email)
- sameAs (array of official social media profile URLs)
- foundingDate
- address (PostalAddress)
- description
- areaServed
Rich result: Knowledge Panel, brand entity recognition
Google says adding organisation structured data to your homepage can “help Google better understand your organization’s administrative details and disambiguate your organization in search results.”
The sameAs property is especially powerful. It links your website to your verified profiles on LinkedIn, X (Twitter), Facebook, Instagram, and other platforms. This helps Google build a complete picture of your brand as an entity and can influence what appears in your knowledge panel.
FAQPage Schema
Use case: FAQ sections with question/answer pairs
Key properties: mainEntity → Question → acceptedAnswer → Answer
Important update: Google now only shows FAQ rich results for well-known authoritative government and health websites. However, FAQ schema still helps with AI comprehension and entity clarity even without the visible rich result.
Event Schema
Use case: Concerts, conferences, webinars, exhibitions, sports matches
Key properties:
- name (the event name, not the venue)
- startDate (ISO 8601 format)
- endDate
- location (Place with address)
- eventStatus (EventScheduled, EventPostponed, EventCancelled, EventRescheduled)
- performer or organiser
- offers (ticket pricing)
Rich result: Event carousel, event details module with date, venue, and pricing
For postponed or cancelled events, keep the original startDate unchanged and use the eventStatus property. If rescheduled, update the status, set the new startDate, and add a previousStartDate property. This helps Google link the updated event to the original listing.
BreadcrumbList Schema
Use case: Every page on your website that has a navigation hierarchy
Key properties:
- itemListElement (array of ListItem entities)
- Each ListItem needs: position, name, and item (URL)
Rich result: Breadcrumb trail shown in search listings instead of the raw URL
Breadcrumbs should represent the most natural way a user would navigate to the page—not necessarily the URL structure.
Review and AggregateRating Schema
Use case: Review pages, product reviews, business reviews from third parties
Key properties:
- author (the reviewer)
- ratingValue
- bestRating and worstRating
- reviewCount (total reviews)
- ratingCount (total ratings)
- itemReviewed (the entity being reviewed)
Rich result: Star ratings displayed in search listings
Critical rule: Google’s guidelines warn that “reviews or ratings not by actual users” may be “considered spammy.” Organisations cannot review themselves. Only genuine third-party reviews from real users qualify.
VideoObject Schema
Use case: Pages with embedded videos
Key properties:
- name (unique video title)
- description
- thumbnailUrl
- uploadDate
- duration (ISO 8601 duration format)
- contentUrl (direct link to video file)
- embedUrl
Rich result: Video carousel, video snippets in search, key moments
Related types include Clip (for highlighted segments within a video) and BroadcastEvent (for live streaming events).
JobPosting Schema
Use case: Individual job listing pages
Key properties:
- title (the job title, not page title)
- description (full job description)
- datePosted
- hiringOrganization
- jobLocation (Place with address) OR jobLocationType (“TELECOMMUTE”)
- baseSalary (salary range with currency)
- employmentType (FULL_TIME, PART_TIME, CONTRACT, etc.)
- validThrough (expiry date)
- applicantLocationRequirements
Rich result: Google Jobs module at the top of job-related searches
Only add JobPosting schema to pages listing individual jobs—not pages with multiple listings.
Recipe Schema
Use case: Food and cooking content
Key properties:
- name, image, author
- prepTime, cookTime, totalTime
- recipeYield (servings)
- recipeIngredient (array of ingredients)
- recipeInstructions (array of HowToStep entities with name and text)
- nutrition (NutritionInformation)
Rich result: Recipe carousel with images, ratings, cook time, and calorie information
Person and ProfilePage Schema
Use case: Author pages, team member pages, contributor bios
Key properties for Person:
- name, url, sameAs, jobTitle, worksFor, image, alumniOf
Key properties for ProfilePage:
- mainEntity (pointing to the Person)
- dateCreated, dateModified
Why this matters for E-E-A-T: Author/Person schema connects content to named individuals, strengthening authorship attribution and the E-E-A-T signals that influence both traditional and AI-powered rankings.
Service Schema
Use case: Service-based businesses—consultants, agencies, contractors, freelancers
Key properties:
- name
- description
- provider (Organisation or Person)
- serviceType
- areaServed
- hasOfferCatalog (for multiple service tiers)
While Service schema does not currently trigger a specific rich result, it significantly helps Google understand what services you offer and match your pages to relevant “near me” and service-related searches. For UAE service businesses—from IT consultancies in Dubai Internet City to cleaning services in Abu Dhabi—this is an underused opportunity.
Code Example:
JSON
{
“@context”: “https://schema.org”,
“@type”: “Service”,
“name”: “SEO Consulting Services”,
“description”: “Full-service search engine optimisation for businesses in the UAE”,
“provider”: {
“@type”: “Organisation”,
“name”: “Your Agency Name”,
“url”: “https://www.example.com”
},
“serviceType”: “Search Engine Optimisation”,
“areaServed”: {
“@type”: “Country”,
“name”: “United Arab Emirates”
}
}
WebSite and Sitelinks Searchbox Schema
Use case: Your homepage
Key properties:
- name (your website name)
- url
- potentialAction (SearchAction with a target URL pattern)
Rich result: Sitelinks Searchbox—a search box that appears in branded search results
This is one of the most commonly missed schema types despite being basic and highly beneficial for branded searches.
Quick Reference Table
| Schema Type | Best For | Rich Result | Priority |
| Article / BlogPosting | Content sites, blogs | Top Stories, enhanced listings | High |
| Product | E-commerce | Product snippets, Shopping | High |
| LocalBusiness | Physical locations | Local Pack, Knowledge Panel | High |
| Organisation | Brand identity | Knowledge Panel | High |
| Event | Events, concerts, webinars | Event carousel | Medium |
| BreadcrumbList | All pages with hierarchy | Breadcrumb trail in SERPs | High |
| Review / AggregateRating | Review content | Star ratings | Medium |
| VideoObject | Video content | Video carousel | Medium |
| JobPosting | Job listings | Google Jobs | Medium |
| Recipe | Food content | Recipe carousel | Medium |
| Person / ProfilePage | Author/team pages | Author attribution | Medium |
| Service | Service businesses | Entity recognition | Medium |
| WebSite | Homepage | Sitelinks Searchbox | Medium |
| FAQPage | Q&A content | FAQ dropdowns (limited) | Low |
💡 Tip: Google’s Search Gallery lists all structured data features currently supported, including “articles, books, breadcrumbs, carousels, course details, datasets, discussion forums, educational Q&As, employer ratings, salary estimates, events, fact checks, FAQs, image metadata, job postings, videos, local businesses, math solvers, movies, organizations, practice problems, products, profile pages, Q&As, recipes, reviews, software apps, speakable content, subscriptions, vacation rentals, and vehicle listings.”
How to Add Schema Markup to Your Website
Step 1: Identify Which Pages Need Schema
Before writing any code, audit your content and decide what schema types each page needs:
- Homepage → Organisation + WebSite + BreadcrumbList
- Blog posts → Article or BlogPosting + BreadcrumbList + Author (Person)
- Product pages → Product + BreadcrumbList + Review/AggregateRating
- Service pages → Service + BreadcrumbList
- Location pages → LocalBusiness + BreadcrumbList
- Event pages → Event + BreadcrumbList
- Team/About page → Organisation + Person/ProfilePage
- Video pages → VideoObject + BreadcrumbList
Prioritise pages that already rank well. Google’s own documentation suggests: “Take some pages on your site that are not using any structured data, and have several months of data in Search Console… Add structured data or other features to your pages. Confirm that your markup is valid… Record the performance for a few months.”
Step 2: Generate Your Schema Markup
Method 1: Schema Generators (Best for Beginners)
Schema generators let you select a type, fill in fields, and get ready-to-use JSON-LD code:
- Dentsu Schema Markup Generator — clean interface, supports most common types
- Google’s Structured Data Markup Helper — lets you tag elements directly on your page
Method 2: AI Assistants
ChatGPT, Google Gemini, or Claude can generate accurate JSON-LD when you give them specific details. Use a prompt like:
“Generate JSON-LD schema markup for [type] with these properties: [list each property and its value].”
Always validate AI-generated schema before implementing. AI assistants occasionally make syntax errors or use deprecated properties.
Method 3: Write Manually
Using Schema.org documentation as your reference, you can write JSON-LD line by line. This gives you complete control over complex nested schemas but takes longer and carries higher risk of syntax errors (a missing comma can break the entire block).
Step 3: Add Schema to Your Website
Option A: WordPress Plugins (No Code Required)
If you use WordPress, these plugins handle schema for you:
- Yoast SEO — automatically adds Article, Organisation, Person, and BreadcrumbList schema. The paid version offers advanced schema editing.
- Rank Math — includes a built-in visual schema editor supporting 20+ types. Very popular in the UAE WordPress community.
- Schema Pro — a dedicated schema plugin with automation rules for adding schema to specific post types or categories.
- WPCode or Code Snippets — for injecting custom JSON-LD into your site’s <head> without editing theme files.
Most modern content management systems can add basic schema right out of the box. Generally speaking, if you use a popular CMS like Wix or Webflow, it is just a matter of tweaking the schema settings to your preferences.
Option B: Manual HTML Insertion
For static websites or when plugins are not available:
- Access your website files through your hosting file manager or an FTP tool
- Open the HTML file for your target page
- Paste your JSON-LD code (including the <script type=”application/ld+json”> wrapper) inside the <head> section
- Save the file
Option C: Google Tag Manager (GTM)
If you prefer managing scripts from a centralised dashboard:
- In GTM, create a new Custom HTML tag
- Paste your complete JSON-LD code (with script tags) into the tag
- Set the trigger (specific page, all pages, or page group)
- Publish the container
Google confirms it can read schema deployed through GTM and even dynamically added via JavaScript.
Option D: Platform-Specific Methods
- Shopify — Edit theme.liquid file or use apps like “JSON-LD for SEO.” For Shopify store owners looking to maximise search visibility, Product schema implementation through liquid templates offers the most control.
- Webflow — Use Custom Code embed element in pages or site-wide header settings
- Wix — Use the built-in Structured Data settings under SEO Dashboard, or Wix Velo for custom schema
- Squarespace — Use the Code Injection feature under Settings > Advanced
Where to Place JSON-LD in HTML
- Best location: Inside the <head> tag — crawlers parse this section first, giving them immediate access to your structured data
- Also valid: Inside <body> or before the closing </body> tag — Google will still read it
- Dynamic pages (SPAs): Ensure schema is present in the rendered DOM after JavaScript execution
Google’s guidelines confirm: “Put the structured data on the page that it describes, unless specified otherwise by the documentation.”
💡 Tip: If you use Google Tag Manager to deploy schema, remember that AI crawlers—GPTBot (OpenAI), ClaudeBot (Anthropic), and PerplexityBot—typically do not execute JavaScript. For AI search visibility, add your schema as a static <script type=”application/ld+json”> block directly in your HTML source code, not solely through client-side JavaScript or GTM.
How to Test and Validate Schema Markup
Schema code can break from a single misplaced comma or missing bracket. Always validate before and after implementation.
Google Rich Results Test
What it does: Tests whether your page qualifies for Google-specific rich results
How to use it:
- Go to the Rich Results Test tool
- Choose “Code” tab to test raw JSON-LD, or “URL” tab to test a live page
- Click “Test Code” or “Test URL”
- Review results: green = valid, yellow = warnings, red = errors
The left panel shows your code; the right panel shows detected items and any issues with exact line numbers. Fix errors and re-test until everything passes.
Google confirms: “You can test compliance with technical guidelines using the Rich Results Test and the URL Inspection tool, which catch most technical errors.”
Schema Markup Validator
What it does: Validates ALL structured data against the complete Schema.org specification—not just Google-supported types
How to use it:
- Go to validator.schema.org
- Paste code or enter a live URL
- Run the test
- Review errors and warnings
Best for: Comprehensive schema validation regardless of which search engine you are targeting.
Google Search Console (Enhancements Reports)
For ongoing monitoring at scale:
- Log into Google Search Console
- Navigate to the Enhancements section in the left sidebar
- You will see reports for each schema type detected across your site
- Each report shows valid items, items with warnings, and items with errors
- Click into any report for page-level details
Use the URL Inspection Tool for checking individual pages. Google’s documentation recommends: “Confirm that your markup is valid, and that Google has found your structured data using the URL Inspection tool on your page.”
For a full list of recommended validation and auditing platforms beyond Google’s own tools, see our roundup of the best SEO tools.
Common Schema Errors and How to Fix Them
| Error | What Causes It | How to Fix |
| Missing required field | A mandatory property was not included | Add the required property with a valid value |
| Invalid value type | Wrong data format (text where a date is expected) | Use the correct format (ISO 8601 for dates, URLs for url properties) |
| Syntax error | Missing comma, bracket, or quotation mark | Run code through a JSON validator to find the exact position |
| Schema-content mismatch | Schema data does not match what is visible on the page | Update schema to reflect actual, visible page content |
| Deprecated type or property | Using an outdated element no longer supported | Replace with the current equivalent from Schema.org |
| Missing @context declaration | No Schema.org reference at the start | Add “@context”: “https://schema.org” |
| Duplicate schema | Same entity marked up multiple times on one page | Remove duplicates; use @id to reference a single entity |
💡 Tip: Always validate your schema TWICE. First, test the raw code in isolation (paste into the testing tool). Second, test the live URL after deployment. Schema that works perfectly in isolation can break when embedded in a page due to conflicts with existing scripts, CMS modifications, or plugin interference.
Schema Markup Best Practices
Follow these rules to ensure your structured data is effective, compliant, and sustainable. These are drawn directly from Google’s official guidelines:
- Use JSON-LD format — It is Google’s recommended format, easiest to implement, and cleanest to maintain
- Choose the most specific type available — Use “Restaurant” not “LocalBusiness,” use “NewsArticle” not “Article,” when the more specific type applies
- Only mark up content that is visible on the page — Google states: “Your structured data must be a true representation of the page content.” Hidden or misleading markup violates spam policies and can trigger a manual action
- Include all required AND recommended properties — “Items that are missing required properties are not eligible for rich results.” Recommended properties improve your rich result quality and competitiveness
- Keep schema updated — Google’s policy states: “Provide up-to-date information. We won’t show a rich result for time-sensitive content that is no longer relevant.” When prices change, events get rescheduled, or job listings expire, update the corresponding schema immediately
- Use @id for entity consistency — Assign a stable @id value (typically a URL fragment like “@id”: “https://yoursite.com/#organisation”) so the same entity can be referenced across multiple schema blocks without duplication
- Connect schemas using @graph — When a single page has multiple schema types (Article + BreadcrumbList + Organisation + Person), use @graph to define them in one clean JSON-LD block with @id cross-references
- Never self-review — Your organisation cannot use Review schema about itself. Google warns that reviews not by actual users are considered spammy
- Mark all items in a list, or none — Google states: “If you mark up one item in a list you must mark up all items; marking up just one category entity from all listed on the page is against our guidelines.”
- Ensure images are crawlable — “All image URLs specified in structured data must be crawlable and indexable. Otherwise, Google Search can’t find and display them on the search results page.”
- Do not block Googlebot access — “Don’t block your structured data pages to Googlebot using robots.txt, noindex, or any other access control methods.”
- Validate before and after deployment — Test raw code first, then test the live URL to catch any implementation conflicts
- Monitor regularly in Google Search Console — Check Enhancements reports at least monthly for new errors or warnings
- Do not over-markup — Only add schema types that genuinely describe your content. Adding irrelevant schema is considered misleading
Schema Markup for AI Search and Modern SEO
The relationship between schema markup and AI search is one of the most discussed topics in SEO right now. Here is what the evidence actually shows. For a deeper understanding of how to optimise specifically for AI-powered search experiences, see our guide on generative engine optimisation.
How Google Uses Structured Data in AI Overviews
Google’s AI Overviews (the AI-generated summaries that appear at the top of some search results) draw heavily from the Knowledge Graph. Since structured data feeds entity information into the Knowledge Graph, schema plays an indirect but meaningful role in AI search visibility.
Google’s documentation clarifies that no special or new schema is required for AI features. Standard, accurate structured data implementation is sufficient. The key principle remains the same: make sure your structured data accurately represents your page content.
Can ChatGPT, Claude, and Other LLMs Read Schema?
Large language models are certainly capable of reading structured data—it is machine-readable by design. However, most LLMs do not actively crawl websites the way Google does. They rely on curated training data with periodic updates.
Research by SEO professionals has demonstrated that AI models may process schema as plain text within HTML rather than interpreting it as semantic metadata with special meaning. The structured format itself may not matter to these systems—the information is simply read as part of the overall page content.
The notable exception is Google Gemini. Evidence suggests that Gemini uses structured data as part of its “grounding” process—the mechanism by which Gemini queries Google’s search index to verify its responses.
The Indirect Pathway: Schema → Knowledge Graph → AI
This is the most reliable and proven pathway for schema to influence AI:
- You implement comprehensive schema on your website
- Google crawls your site and extracts structured data
- Entity information feeds into Google’s Knowledge Graph
- The Knowledge Graph provides grounding data for Gemini and AI Overviews
- When someone asks a question related to your entity, the AI can surface accurate information about you
This is why Organisation schema, Person schema, and sameAs links are so valuable for AI visibility. They establish your brand as a clearly defined entity in Google’s knowledge base.
Practical Recommendations for AI Search Visibility
- Implement schema as static HTML — Use <script type=”application/ld+json”> directly in your source code. AI crawlers (GPTBot, ClaudeBot, PerplexityBot) typically cannot execute JavaScript, so schema deployed only via GTM or client-side JS may be invisible to them.
- Complete your Organisation schema — Include comprehensive sameAs arrays linking to all your verified profiles across the web.
- Use Person/Author schema — Connect your content to named individuals with real credentials. This strengthens E-E-A-T signals that both Google and AI systems evaluate.
- Make Product schema complete — AI shopping agents (including ChatGPT’s shopping features and Google’s AI-powered product discovery) evaluate structured product data to recommend products. Incomplete Product schema means incomplete visibility to these systems.
- Keep schema consistent with visible content — AI systems cross-reference claims. If your schema says one thing and your page content says another, trust signals break down.
- Monitor Bing Webmaster Tools — Several AI platforms, including Perplexity and ChatGPT Search, use Bing’s index as a data source. Strong performance in Bing may influence your visibility in these AI-powered search products.
If your business is looking for hands-on support with AI search visibility, explore our AI SEO services.
💡 Key Point: Schema markup’s greatest AI value is indirect. It strengthens your entity signals in Google’s Knowledge Graph, which then serves as the factual foundation that AI systems—especially Gemini and AI Overviews—use to verify and generate responses about your brand, products, and content.
Advanced Schema Techniques
Using @graph for Connected Schemas
When a single page needs multiple schema types—which is the norm for most pages—you can define them all in one JSON-LD block using @graph. This creates a clean, interconnected structure where entities reference each other through @id values.
JSON
{
“@context”: “https://schema.org”,
“@graph”: [
{
“@type”: “Organisation”,
“@id”: “https://www.example.com/#organisation”,
“name”: “Your Company”,
“url”: “https://www.example.com”,
“logo”: {
“@type”: “ImageObject”,
“url”: “https://www.example.com/logo.png”
}
},
{
“@type”: “WebSite”,
“@id”: “https://www.example.com/#website”,
“url”: “https://www.example.com”,
“name”: “Your Company”,
“publisher”: {“@id”: “https://www.example.com/#organisation”}
},
{
“@type”: “Article”,
“@id”: “https://www.example.com/blog/post/#article”,
“headline”: “Your Article Title”,
“author”: {“@id”: “https://www.example.com/#author”},
“publisher”: {“@id”: “https://www.example.com/#organisation”},
“datePublished”: “2026-06-11”
},
{
“@type”: “Person”,
“@id”: “https://www.example.com/#author”,
“name”: “Author Name”,
“url”: “https://www.example.com/team/author-name”
}
]
}
Notice how each entity has an @id, and other entities reference it using {“@id”: “…”} instead of repeating all the information. This eliminates duplication and creates a clear semantic map of your page.
Entity Disambiguation with @id and sameAs
@id gives each entity a unique identifier so it can be referenced consistently across your entire website’s schema. Best practice is to use URL fragments:
- “@id”: “https://yoursite.com/#organisation” for your company
- “@id”: “https://yoursite.com/#website” for your website entity
- “@id”: “https://yoursite.com/team/name/#person” for team members
sameAs links your entity to authoritative external sources. This helps Google perform entity linking—connecting your entity to the correct entry in its Knowledge Graph:
JSON
“sameAs”: [
“https://www.linkedin.com/company/yourcompany”,
“https://www.instagram.com/yourcompany”,
“https://en.wikipedia.org/wiki/Your_Company”
]
Together, @id and sameAs help search engines resolve ambiguity and build a complete picture of who you are.
Nesting Schemas for Depth
Schema types can be nested inside each other to create rich, detailed descriptions:
- Review nested inside Product (a product review with the product it reviews)
- Person (author) nested inside Article (the article they wrote)
- PostalAddress nested inside Organisation (where the company is located)
- Offer nested inside Product (the price and availability of the product)
- HowToStep nested inside Recipe (each cooking step)
- ListItem nested inside BreadcrumbList (each breadcrumb link)
The general rule: if a property’s expected value is another entity type, you should nest a full entity there rather than using a plain text string.
Google confirms you can “include multiple structured data objects on a page, as long as they describe user-visible page content.”
Schema for Multilingual Websites
If your website serves content in multiple languages (common for UAE businesses publishing in both English and Arabic), use the inLanguage property:
JSON
{
“@type”: “Article”,
“headline”: “Your Article Title”,
“inLanguage”: “en-AE”
}
Each language version of a page should have its own schema with the appropriate language tag. Combine this with hreflang tags for complete international SEO coverage.
Monitoring Schema Markup Performance
Google Search Console Enhancements
The Enhancements section in GSC is your primary monitoring dashboard:
- What you see: Each detected schema type gets its own report (Articles, Products, Breadcrumbs, etc.)
- Status categories: Valid, Valid with warnings, Errors
- Historical view: Track valid/error counts over time to spot new issues quickly
- Page-level detail: Click into any item to see which specific pages have problems
Set up email notifications in GSC to get alerted when new errors appear.
Measuring the Impact of Schema
Google recommends a clear before-and-after methodology: “Take some pages on your site that are not using any structured data, and have several months of data in Search Console… Add structured data… Record the performance for a few months in the Performance report, and filter by URL to compare performance of your page.”
To understand whether your schema implementation is working:
- In GSC Performance Report — Filter by “Search appearance” to see impressions and clicks specifically for rich results
- Track CTR changes — Compare click-through rates before and after schema implementation on specific pages. Understanding which SEO KPIs to track ensures you measure the right outcomes.
- Monitor rich result ownership — Use position tracking tools to see which SERP features your pages appear in
- Check Bing Webmaster Tools — Bing provides performance metrics for AI chat references to your website, which is increasingly valuable
When Rich Results Do Not Appear
Valid schema does not guarantee rich results. Google decides based on:
- Page and site quality
- Authority and trust signals
- Query type and user intent
- User context (location, device, search history)
- Google’s assessment of whether the rich result improves the search experience
Google’s structured data policies are clear: implementing structured data “enables a feature to be present” but “does not guarantee that it will be present.”
If your schema is valid but no rich results appear:
- Focus on content quality and depth
- Build site authority through quality backlinks
- Ensure a strong E-E-A-T foundation (expertise signals, author credentials, trustworthiness indicators)
- Be patient—rich results may take weeks to appear after implementation
Unlike render-blocking JavaScript or large media files, JSON-LD schema has zero impact on your Core Web Vitals—it is a lightweight script block that does not affect page loading speed or layout stability.
Frequently Asked Questions About Schema Markup
What is schema markup in simple terms?
Schema markup is code you add to your website that tells search engines exactly what your content is about. It uses a standard vocabulary from Schema.org to label things like products, events, businesses, articles, and people so that Google can understand your pages without guessing. Google describes it as “a standardized format for providing information about a page and classifying the page content.”
Is schema markup a ranking factor?
No. Google has confirmed that structured data is not a direct ranking factor. However, it provides significant indirect benefits: better rich results increase click-through rates, more accurate entity understanding improves relevance matching, and Knowledge Graph inclusion strengthens your brand’s visibility across Google products including AI Overviews.
What does schema markup do for SEO?
Schema markup helps SEO in four main ways. First, it helps Google understand your content more accurately so it shows for more relevant searches. Second, it makes your pages eligible for rich results (star ratings, prices, FAQ dropdowns, event dates) with “increased click-through rates, visits, and user engagement.” Third, it feeds your entity information into Google’s Knowledge Graph. Fourth, it prepares your content for voice search and AI-powered search features.
What is the difference between schema markup and structured data?
Structured data is the broad concept—any information organised in a machine-readable format. Schema markup is the specific implementation of the Schema.org vocabulary on a website using formats like JSON-LD. Think of structured data as the category and schema markup as the specific tool within that category.
Which format should I use for schema markup?
JSON-LD. Google’s documentation states: “In general, we recommend using a format that’s easiest for you to implement and maintain (in most cases, that’s JSON-LD).” It is the easiest to implement (a separate script block that does not interfere with your HTML), the simplest to read and maintain, and compatible with all major CMS platforms and plugins.
Does schema markup help with AI search?
Indirectly, yes. Schema feeds entity information into Google’s Knowledge Graph, which AI systems like Gemini use for grounding and verification. While ChatGPT and Claude do not directly parse schema as semantic metadata during generation, Google’s AI Overviews draw from Knowledge Graph data—which is partially built from your structured data. For maximum AI visibility, implement schema as static HTML (not via JavaScript or GTM alone) since most AI crawlers cannot execute JS.
How important is schema markup for local SEO?
Very important. LocalBusiness schema powers your presence in the Local Pack and local Knowledge Panels. Include complete details: business name, address (PostalAddress), telephone, opening hours, geo coordinates, price range, area served, and sameAs links to your Google Business Profile and social accounts. For UAE businesses with multiple locations, each location should have its own LocalBusiness schema on its dedicated page.
Can I use multiple schema types on one page?
Yes. Google confirms: “You can include multiple structured data objects on a page, as long as they describe user-visible page content.” A blog post typically has Article + BreadcrumbList + Organisation (publisher) + Person (author). Use @graph to define all entities in a single JSON-LD block with @id cross-references.
What is JSON-LD?
JSON-LD stands for JavaScript Object Notation for Linked Data. It is an open web standard for encoding structured information in JSON format. In SEO, it is the coding format used to write schema markup inside a <script type=”application/ld+json”> tag on your web pages. Google recommends it because it is clean, readable, and completely separated from your visible HTML.
How often should I update schema markup?
Update schema whenever the content it describes changes. If product prices change, update the Offer schema. If events get rescheduled, update Event schema with the new dates and appropriate eventStatus. If articles receive substantial edits, update the dateModified property. Google’s policy states they “won’t show a rich result for time-sensitive content that is no longer relevant.”
What happens if my schema has errors?
Schema with errors may not qualify for rich results, and in serious cases (misleading or spammy markup), Google can take action that removes your pages from rich result eligibility. Minor syntax errors (missing commas, incorrect value formats) simply prevent the schema from being read correctly. Always validate before deployment using the Rich Results Test and Schema Markup Validator.
Do I need schema markup on every page?
Not necessarily the same types on every page. Organisation and WebSite schema belong on your homepage. BreadcrumbList belongs on most pages. Article or BlogPosting schema belongs on content pages. Product schema belongs on product pages. The principle is: add schema that accurately describes the content and entities on each specific page. Google’s structured data policies state to “put the structured data on the page that it describes.”
“`html id=”k8n2xp”
“`