Schema markup for Nepali websites: a practical guide

Schema markup is structured data that describes visible entities and facts in a machine-readable format. Use it to label a real business, article or product accurately. Supported types can make a page eligible for particular search features when the applicable guidelines are met; display and ranking improvements are not guaranteed.

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.

For a product-specific example, use the NPR product schema and variant guide.

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.

Check your own implementation before assuming a competitive gap

This guide does not establish how many Nepali websites use structured data. Inspect a defined set of relevant pages before making a market-wide claim. Prioritize accurate business and content information over the number of schema types implemented.

Rich results stand out on crowded result pages

Supported search features vary by type, eligibility and result context. They are not guaranteed merely because markup validates. Google retired FAQ rich results in May 2026. For business visibility, the local SEO guide covers the broader work beyond markup.

Keep business details consistent

Keep your real business name, address, phone and hours consistent with your public profiles. LocalBusiness documentation describes supported properties and guidelines; it does not promise a Maps ranking lift from adding schema.

Separate accurate structure from citation promises

Use markup that matches the visible page. No universal ChatGPT or Perplexity citation multiplier is established here. For Google AI features, ordinary SEO fundamentals apply without special schema. The AI search guide and SEO, GEO and AEO comparison explain related concepts.

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-09-25",
  "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 remains Schema.org vocabulary for describing real questions and answers. Google retired FAQ rich results in May 2026. Keep the visible FAQ useful, and do not implement this type expecting Google FAQ dropdowns.

<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>

For an online store, select product markup that accurately describes the item and meets the relevant eligibility requirements. Do not mark every service package as a Product just because it has a price. The ecommerce SEO guide covers the broader store workflow.

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>

Use sameAs only for genuine identity references, such as the correct professional profile. It describes a relationship; it does not establish an E-E-A-T score or guarantee a knowledge panel, ranking increase or AI citation.

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.

The Rich Results Test checks supported Google features. Fix critical errors and review warnings, then check content and policy requirements too. Passing the tool does not guarantee display, and it is not a complete validator for all Schema.org vocabulary.

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

Search Console has reports for a supported subset of detected rich-result types. It does not provide a dedicated Article enhancement report, and retired FAQ display should not be expected there. Consult the rich-result report overview; absence of a report is not proof that all markup is invalid.

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. After Google recrawls, inspect available supported rich-result reports and the URL itself; not every schema type has a dedicated report.
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

For AI search, distinguish accurate content description from unverified citation promises. Implementing a type does not establish that an answer engine uses it as a ranking signal. Check the specific platform documentation rather than assuming all AI services work alike.

For example, keep a restaurant's actual hours and address visible and consistent with its structured description. A correct data block cannot rescue outdated or contradictory information in the page itself.

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?"

Clear information helps visitors evaluate those questions. Citation selection is a separate outcome that must be observed. The AI search guide discusses visibility work without making markup a substitute for evidence.

A useful FAQ answers genuine questions in visible text. Its value to a reader does not depend on a special display or a claimed citation multiplier. Keep the answers accurate and any matching markup synchronized.

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

Required and recommended properties depend on the supported feature. For Product snippets, review the relevant offers/review/rating alternatives rather than assuming all are required together. Article guidance lists recommended properties and does not set a required-property list. Do not invent reviews or other facts to satisfy a template.

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? As a Nepal SEO specialist, I implement structured data for 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.