Schema markup for Nepali websites: a practical guide

Schema markup is structured data you add to your website's HTML so search engines understand your content in a precise, machine-readable way. Instead of guessing that a page mentions a restaurant's name, address and opening hours somewhere in a paragraph, the search engine reads a clearly labelled data block that says "this is a Restaurant, here is its address, here are its hours." That clarity directly enables rich results in Google, improves how your site appears in local search, and makes your content far more useful to AI systems like Google's AI Overviews and ChatGPT.

Most Nepali websites still don't use schema markup at all. That's actually good news if you're reading this, because adding it now puts you ahead of the majority of local competitors. This guide covers the schema types that matter most for businesses in Nepal, walks through real JSON-LD examples you can copy and adapt, and shows you how to test everything before it goes live.

What is schema markup and how does it work?

Schema markup uses a standardised vocabulary maintained at Schema.org to describe entities on a web page: businesses, articles, products, people, events, recipes and hundreds of other types. When you add schema to a page, you're essentially giving search engines a structured summary they can read without having to interpret your content from scratch.

There are three formats for adding schema: JSON-LD, Microdata and RDFa. Google recommends JSON-LD because it's the simplest to implement and maintain. JSON-LD sits inside a <script> tag in your HTML, completely separate from your visible content. You don't need to modify your page's layout or CSS to use it, which makes it much less error-prone than the other formats.

Here's a minimal example of what JSON-LD looks like in practice:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "LocalBusiness",
  "name": "Himalayan Bites",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "Thamel Marg",
    "addressLocality": "Kathmandu",
    "addressCountry": "NP"
  },
  "telephone": "+977-1-4XXXXXX"
}
</script>

That block tells Google exactly what the business is called, where it's located and how to reach it. Without schema, Google would have to extract those details from paragraph text, and it might get them wrong or miss them entirely.

Why schema markup matters for websites in Nepal

Schema is valuable everywhere, but it's especially impactful in Nepal's search environment for a few specific reasons.

Most local competitors haven't added it yet

Run a quick check on the websites of restaurants in Thamel, trekking agencies in Pokhara or clinics in Lalitpur, and you'll find that the vast majority have zero structured data. That means even basic LocalBusiness schema gives your site a meaningful edge in how it appears in search results and on Google Maps.

Rich results stand out on crowded result pages

When someone searches "best momo in Kathmandu" or "dental clinic near me," the results that show star ratings, opening hours, FAQ dropdowns or breadcrumb trails get far more attention than plain blue links. Schema is what triggers these rich results. The local SEO guide for Nepal I wrote earlier covers this from the local ranking angle; schema is the technical piece that makes those features possible.

Google uses schema for local pack results

The local pack (the map and three business listings at the top of a local search) pulls information directly from Google Business Profile and from schema on your website. If your website has LocalBusiness schema with consistent NAP (Name, Address, Phone) details that match your Google Business Profile, Google has higher confidence in showing your business there.

AI systems rely on structured data

As I covered in the AI search optimization guide, AI engines like ChatGPT and Perplexity prefer content that's easy to parse and trust. Schema gives them a pre-structured summary rather than forcing them to infer details from unstructured text, which makes your content much more likely to be cited in an AI-generated answer. Schema markup plays a role in all three modern search strategies: traditional SEO, AEO and GEO. My SEO vs GEO vs AEO guide explains how these layers stack.

Schema types every Nepali website should know

Schema.org defines hundreds of types, but most Nepali websites will get the majority of their value from six. Here they are, with examples tailored to businesses you'd actually find in Kathmandu, Pokhara or Chitwan.

1. LocalBusiness

This is the most important type for any business with a physical location or a defined service area. It covers restaurants, shops, clinics, hotels, trekking agencies and professional services.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Restaurant",
  "name": "Himalayan Bites",
  "image": "https://example.com/photos/himalayan-bites.jpg",
  "address": {
    "@type": "PostalAddress",
    "streetAddress": "Thamel Marg, opposite Garden of Dreams gate",
    "addressLocality": "Kathmandu",
    "addressRegion": "Bagmati",
    "postalCode": "44600",
    "addressCountry": "NP"
  },
  "geo": {
    "@type": "GeoCoordinates",
    "latitude": 27.7142,
    "longitude": 85.3145
  },
  "telephone": "+977-1-4XXXXXX",
  "openingHoursSpecification": [
    {
      "@type": "OpeningHoursSpecification",
      "dayOfWeek": ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday"],
      "opens": "10:00",
      "closes": "21:00"
    }
  ],
  "priceRange": "NPR 200-800",
  "servesCuisine": "Nepali, Newari",
  "url": "https://example.com/"
}
</script>

Notice a few things: the @type is "Restaurant," which is a more specific subtype of LocalBusiness. Google prefers the most specific type that applies. A trekking agency would use "TravelAgency," a dental clinic would use "Dentist," and a general shop would use "Store." Also, the geo property with latitude and longitude helps Google place your business accurately on maps, which is especially useful when Nepali addresses don't always follow a standard format.

2. Article

If you publish blog posts, news or educational content, Article schema helps Google identify the headline, author, publish date and description at a glance.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Best trekking routes near Pokhara for beginners",
  "description": "Five beginner-friendly treks near Pokhara, with difficulty ratings, costs and what to pack.",
  "datePublished": "2026-08-15",
  "dateModified": "2026-08-15",
  "author": {
    "@type": "Person",
    "name": "Your Name",
    "url": "https://example.com/about/"
  },
  "publisher": {
    "@type": "Organization",
    "name": "Your Site Name"
  },
  "mainEntityOfPage": "https://example.com/blog/trekking-routes-pokhara/"
}
</script>

This is the exact schema structure used on the page you're reading right now. The datePublished and dateModified fields matter because Google uses them to determine content freshness. For time-sensitive topics, keeping your dateModified current signals that your information is up to date.

3. FAQPage

FAQPage schema can trigger a rich result where your questions and answers appear directly in Google's search results, taking up more space and drawing more clicks.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "How much does the Annapurna Base Camp trek cost?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "A guided Annapurna Base Camp trek typically costs NPR 45,000 to NPR 90,000 per person, depending on group size, season and whether accommodation is teahouse or camping."
      }
    },
    {
      "@type": "Question",
      "name": "Do I need a permit for the Annapurna region?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. You need a TIMS card and an Annapurna Conservation Area Permit (ACAP). Your trekking agency can arrange both."
      }
    }
  ]
}
</script>

One important rule: every question and answer in your FAQPage schema must also be visible as real text on the page itself. Google explicitly says the schema must reflect actual page content, not hidden or invented questions. If your FAQ section has five questions on the page, mark up those same five questions in the schema.

4. Product

For e-commerce sites or any page selling a specific product, Product schema unlocks rich results showing price, availability and review ratings directly in search.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Product",
  "name": "Hand-knitted Dhaka Topi",
  "image": "https://example.com/images/dhaka-topi.jpg",
  "description": "Traditional Nepali Dhaka topi, handwoven in Palpa district.",
  "brand": {
    "@type": "Brand",
    "name": "Nepal Craft Store"
  },
  "offers": {
    "@type": "Offer",
    "priceCurrency": "NPR",
    "price": "1200",
    "availability": "https://schema.org/InStock",
    "url": "https://example.com/products/dhaka-topi/"
  },
  "aggregateRating": {
    "@type": "AggregateRating",
    "ratingValue": "4.6",
    "reviewCount": "38"
  }
}
</script>

If you run an online store selling Nepali crafts, clothing or food products, Product schema is essential. It's also relevant for service pages where you list specific packages with prices. The e-commerce SEO guide for Nepal goes deeper into how structured data fits into an online store's overall SEO strategy.

5. Person

Person schema is useful for freelancers, consultants and any professional whose personal brand is central to their website. It tells Google who you are, what you do and how to find you online.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Bikesh Tamang",
  "jobTitle": "SEO Specialist",
  "url": "https://bikeshtamang.com.np/",
  "sameAs": [
    "https://www.linkedin.com/in/bikeshtamang/"
  ],
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "Kathmandu",
    "addressCountry": "NP"
  },
  "knowsAbout": ["SEO", "Technical SEO", "Front-End Development"]
}
</script>

The sameAs property is particularly useful because it links your website to your social profiles and directory listings, helping Google build a more complete picture of your online identity. This feeds directly into E-E-A-T signals, which matter for both traditional search and AI citations.

6. BreadcrumbList

BreadcrumbList schema creates the breadcrumb trail you see in Google search results (Home > Blog > Post Title). It helps both users and search engines understand your site's structure.

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://example.com/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Services",
      "item": "https://example.com/services/"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Trekking Packages",
      "item": "https://example.com/services/trekking/"
    }
  ]
}
</script>

BreadcrumbList is one of the easiest schema types to implement and one of the most consistently displayed in search results. Even if you add no other schema, this one gives your pages a cleaner, more professional appearance in Google.

How to add schema markup to your site

The implementation method depends on how your website is built. Here are the three most common approaches for Nepali websites.

WordPress with a plugin

If your site runs on WordPress, plugins like Rank Math and Yoast SEO can generate schema automatically. Rank Math is particularly good at this and supports LocalBusiness, Article, FAQ, Product and many other types through its settings panel. For most WordPress sites, this is the fastest path to getting schema live without writing any code.

The tradeoff is that plugins generate generic schema. You'll usually want to review what they produce using a testing tool to make sure the output is complete and accurate. For example, a plugin might generate Article schema but leave the author name as "admin" if your WordPress user profile isn't set up properly.

Manual JSON-LD in HTML

For static HTML sites, custom-coded sites or situations where you need full control, you write the JSON-LD yourself and paste it into the <head> section of your HTML. This is the approach I use on this site and the one shown in all the examples above.

The process is straightforward:

1. Decide which schema types fit the page (Article + BreadcrumbList for a blog post, LocalBusiness for your homepage, Product for a product page).
2. Write the JSON-LD using the examples above as a starting point, replacing the placeholder values with your own real information.
3. Paste each JSON-LD block inside a <script type="application/ld+json"> tag in your page's <head>.
4. Test the markup using Google's tools (covered in the next section).
5. Deploy and monitor.

You can have multiple JSON-LD blocks on a single page. This page, for instance, has three: Article, BreadcrumbList and FAQPage.

Google Tag Manager

If you don't have direct access to your site's HTML but do have Google Tag Manager set up, you can inject JSON-LD through a Custom HTML tag. This is a practical workaround when a web developer built the site and you can't easily edit templates. However, Google Tag Manager injects the schema after page load, which means there's a small risk that crawlers might not always pick it up. Direct HTML placement is more reliable whenever possible.

Testing and validating your schema

Adding schema is only half the job. You need to verify that it's valid, complete and actually eligible for rich results. Three tools handle this.

Google's Rich Results Test

The Rich Results Test is the most important tool. Paste your page URL or a code snippet, and it tells you whether your schema qualifies for rich results, what type of rich result it can trigger, and whether there are any errors or warnings.

A green checkmark means the schema is valid and eligible. Yellow warnings suggest optional fields you could add to improve the result. Red errors mean something is broken and needs fixing before the schema will work.

Schema Markup Validator

The Schema.org validator at validator.schema.org checks your markup against the full Schema.org specification, not just the subset Google supports. It's useful for catching structural errors that the Rich Results Test might not flag, like mistyped property names or incorrect nesting.

Google Search Console

Once your schema is live, Google Search Console's Enhancements section shows you how Google is processing it across your entire site. You'll see separate reports for each rich result type (FAQ, Breadcrumbs, Articles, Products) with counts of valid items, warnings and errors. This is where you monitor schema health over time rather than page by page.

A testing workflow

Here's the process I follow when adding schema to a client's site:

1. Write the JSON-LD and paste it into the page.
2. Run the page through the Rich Results Test. Fix any red errors.
3. Run it through the Schema.org validator for a second check.
4. Deploy the page.
5. Wait a few days, then check Google Search Console's Enhancements reports to confirm Google has picked it up.
6. Search for the page's target query in Google and see whether the rich result actually appears.

Rich results aren't guaranteed even with valid schema. Google decides whether to show them based on many factors, including the quality and relevance of your page. But valid schema is the necessary first step.

Schema markup and AI search

Structured data has become more important than ever because of how AI search systems work. When ChatGPT, Google's AI Overviews or Perplexity pull information from the web to generate an answer, they prefer sources where the data is already organised and unambiguous.

Think about it from the AI's perspective. Given two pages about a restaurant in Thamel, one with structured LocalBusiness schema (clear name, address, hours, cuisine type, price range) and another with the same information scattered across paragraphs, the structured version is far easier to extract a confident, accurate answer from.

This is especially relevant for Nepali businesses because AI engines are increasingly answering queries like:

• "What's a good restaurant near Thamel for Newari food?"
• "How much does an Annapurna Base Camp trek cost?"
• "Which clinics in Kathmandu offer dental implants?"

If your website has clean, valid schema that directly answers these questions in a structured format, you're significantly more likely to be the source cited in the AI's response. The AI search optimization guide covers the broader strategy, but schema is one of the most practical technical actions you can take today to prepare for this shift.

FAQ schema is particularly powerful here. When an AI system encounters a page with FAQPage markup, it gets a clean question-answer pair it can use almost directly in its output, complete with proper attribution to your site.

Common schema mistakes to avoid

After auditing schema on dozens of Nepali websites, these are the mistakes I see most often.

Schema that doesn't match visible content

This is the most serious mistake. Google requires that every piece of information in your schema must also be visible to users on the page. If your FAQPage schema includes a question that doesn't appear anywhere on the page, or your Product schema lists a price that's different from what's displayed, Google may penalise the page or simply ignore the schema entirely.

Using the wrong type

Marking a trekking agency as "LocalBusiness" works, but "TravelAgency" is more specific and gives Google better information. A common error is using generic types when more specific subtypes exist. Check Schema.org's type hierarchy to find the most accurate type for your business.

Missing required properties

Each schema type has properties that Google considers required for rich result eligibility. For Product schema, you typically need name, image, offers (with price and currency) and review or aggregateRating. For Article, you need headline, datePublished and author. Missing a required property means the schema won't trigger a rich result even if the rest is perfect.

Inconsistent NAP information

If your LocalBusiness schema says your address is "Thamel Marg, Kathmandu" but your Google Business Profile says "Thamel Road, KTM," that inconsistency weakens the signal. Your business name, address and phone number should be identical across your website schema, Google Business Profile, social media profiles and directory listings.

Adding schema and forgetting about it

Schema isn't a set-and-forget task. When your business changes its hours, moves to a new address, updates its prices or publishes new content, the schema needs to be updated too. Stale schema that contradicts what's on the page is worse than having no schema at all, because it actively sends wrong signals to search engines.

Marking up content that shouldn't be marked up

Not every page needs schema beyond BreadcrumbList. A privacy policy page or a terms of service page doesn't benefit from Article schema. A "Contact Us" page with just a form and an address might benefit from LocalBusiness schema but doesn't need Article or FAQ markup. Be selective and intentional about which types you apply where.

If you're not sure where to start, focus on the basics first. Add LocalBusiness schema to your homepage and contact page, Article schema to your blog posts, BreadcrumbList to every page, and FAQ schema only where you have genuine, visible questions and answers. That covers the highest-value ground for most Nepali websites.

For the broader technical SEO context that schema fits into, including crawling, indexing, speed and security, the technical SEO guide for beginners walks through the full picture. Schema is one piece of that foundation, but it's a piece with an outsized impact when done right.

Need help adding schema markup to your website? I implement structured data for Nepali businesses as part of my technical SEO work. Get in touch and we'll figure out which schema types will have the biggest impact for your site.