Shopify merchants with thriving loyalty programs now have a powerful new tool to stand out in Google search results. Google has introduced the MemberProgram structured data type: a way to describe your store’s loyalty program in your website’s code so that search engines can understand it.
In practical terms, this means Google can directly highlight your loyalty program benefits (like member-only prices or points earned) right on the search results page.
For established Shopify brands that invest in customer retention, implementing this schema can improve search visibility and entice customers with your loyalty perks before they even click through to your site.
Many ecommerce sites already use structured data (schema markup) for products, reviews, etc., to get rich snippets. MemberProgram schema extends this to loyalty programs.
It’s relatively new (launched in 2025) and currently supported in several major markets, including the US, UK, Canada, Australia, France, Germany, Brazil, and Mexico.
MemberProgram structured data is essentially a piece of code that tells search engines about your loyalty program
Structured data is code that you put on your website to give search engines and other website crawlers contextual information about your organization, products, or services. It’s not visible on the page to humans, but it can still improve your performance within search engines by helping them understand your business.
MemberProgram is a Schema.org structured data type that defines a loyalty or membership program and its benefits. It allows you to describe your loyalty program’s details in a standardized format that search engines (like Google) can parse.
For example, you can specify that your store has a loyalty program (e.g., “VIP Rewards Club”) that gives members benefits such as exclusive discounts, free shipping, or the ability to earn points on purchases.
Crucially, MemberProgram schema also lets you outline multiple membership tiers (e.g., Silver, Gold) and the specific perks each tier provides (like a higher points multiplier or special pricing).
This structured data is embedded in your site’s HTML as a JSON-LD script (just like product or organization schema). Google specifically requires that the MemberProgram markup be nested under your main Organization schema on your site.
In other words, you’ll be adding information about your loyalty program as part of your business’s structured data profile. By doing so, you directly communicate to Google the existence of your loyalty program, its name, its tiers, and what members get.
Google can then use this data to enhance your search snippets – showing, for instance, a note about “member prices” or “earn points” alongside your product listings or in your brand’s knowledge panel.
MemberProgram structured data offers several benefits to Shopify brands
Implementing the MemberProgram schema on your Shopify store can bring several benefits for SEO – and, consequently, low-cost customer acquisition. Here are the key advantages:
Enhanced search visibility
Your loyalty program perks can appear directly in Google Search results, making your listings more eye-catching. For example, Google might display a message like “5% off for Gold Members” or “Earn 5× loyalty points” next to your product snippet.
This rich snippet enhancement draws attention and can improve click-through rates, as customers see extra value upfront.
Differentiation and trust
Showing loyalty benefits in SERPs distinguishes your brand from competitors. It signals to searchers that your store offers rewards or VIP treatment, which can build trust and interest even before they visit your site.
A shopper might be more inclined to click on a result that clearly highlights “Exclusive price for members” over a standard listing.
Improved user experience
By surfacing loyalty program info early, you help potential customers quickly understand the value of joining your program. For instance, a user could see “Earn 100 points on this purchase” on your Google result – a prompt that might encourage them to choose your site and sign up for the rewards program.
Deeper brand understanding (for search engines and large language models)
Providing structured data about your loyalty program gives search engines and AI systems a more complete picture of your brand’s offerings. Google’s algorithms (and even AI chat tools like ChatGPT’s browsing mode) can better appreciate that your business values loyalty and rewards customers.
This could indirectly support your SEO by aligning with Google’s focus on comprehensive, brand-specific information. (It also aligns with Google’s 2025 emphasis on experience and personalization in search results.)
Coverage in key markets
As noted, Google currently supports loyalty program rich results in a range of countries (US, UK, Canada, Australia, France, Germany, Brazil, Mexico).
If your Shopify business targets any of these regions, you can benefit immediately. And even if you sell elsewhere, adopting the schema now positions you ahead of the curve if Google expands support globally.
MemberProgram structured data can be visible on product listings and Knowledge Panels
When you implement the MemberProgram structured data correctly, Google can display loyalty program info alongside your products or brand information in search.
As shown in the figure above, a search result for a product might show a member-only price (e.g., “With VIP Club: $299”) beneath the standard price, or a note about points (e.g., “Earn 50 points on this purchase”).
Google can also include loyalty perks in a Knowledge Panel for your brand (the info box that appears for brand-name searches), indicating something like “Loyalty program: VIP Club – members get free shipping and points.”
It’s important to note that Google will display these loyalty snippets only in certain contexts and regions (as of now). The user still sees the usual product title, URL, and description, but with an added line of loyalty benefits.
By providing this data, you essentially give Google the green light to show off your loyalty program directly in search results. This is especially beneficial for Shopify merchants who rely on organic search: you’re turning your hard-won loyalty perks into a mini marketing message in Google Search itself.
You can use MemberProgram data to communicate the existence of your loyalty program, detail loyalty tiers, and specify product-level offers
Before diving into implementation steps, let’s outline how the MemberProgram schema ties into your site’s structured data:
Organization-level markup
First, you define your loyalty program at the organization level. Typically, you’ll include a JSON-LD script on a page like your homepage, “About us”, or a dedicated loyalty program info page.
This script uses @type: “Organization” (or the more specific “OnlineStore” type) and includes a hasMemberProgram property that contains the details of your loyalty program.
In that section, you specify the program’s name, a description of the benefits, and the tiers it includes. Each tier is described with its own properties (tier name, what benefits it offers, etc.). This is effectively telling Google, “My store has a loyalty program called X with these tiers and perks.”
Tier benefits
Within the MemberProgram data, you list what each tier offers.
Google’s supported vocabulary includes TierBenefitLoyaltyPoints (meaning the tier earns loyalty points on purchases) and TierBenefitLoyaltyPrice (meaning the tier gets special member-only pricing).
So, for example, your “Gold” tier might have benefits [ “TierBenefitLoyaltyPoints”, “TierBenefitLoyaltyPrice” ] to indicate Gold members earn points and get exclusive prices.
If a tier offers points, you can also specify how many points per dollar (or per currency unit) with the membershipPointsEarned property (e.g., Gold earns 10 points per $1). If the tier has requirements (like a paid membership or a certain credit card), you can optionally describe that too (using hasTierRequirement). All of this info lives in the Organization-level JSON-LD.
Product-level markup
Once your site “knows” about the loyalty program, the next step is to connect it to individual product offers.
On each product page, in the Product schema markup (which many Shopify themes have by default), you’ll add extra pricing info indicating member discounts or points.
This is done via a UnitPriceSpecification inside the Offer that has a validForMemberTier property referencing one of the tiers from your MemberProgram.
In simple terms, you tell Google “this product has a special price (or points reward) for Gold members.”
The validForMemberTier acts like a pointer linking the product’s offer to the tier definition in your organization schema. Google then understands that the offer is only valid for members of that tier and can display it accordingly as a loyalty perk in search results.
Putting it together, the MemberProgram schema works hand-in-hand with your existing product schema. The organization-level markup defines the overall program and tier benefits, and the product-level markup flags specific prices or points that apply to those tiers.
You can implement MemberProgram structured data by adding JSON-LD code to your Shopify theme
Now let’s get practical. Implementing the MemberProgram structured data on a Shopify store involves adding JSON-LD code to your theme.
If you or your team are comfortable editing theme code, you can do this manually. Otherwise, you might work with a developer or use an app (more on that later).
We’ll break the implementation into steps:
1. Add Organization/OnlineStore Schema with loyalty program details
Start by ensuring you have base Organization structured data on your site. Many Shopify themes include a basic Organization JSON-LD (often on the homepage) that specifies your business name, URL, logo, etc.
If your site already has this, you’ll be extending it. If not, you can add a new JSON-LD script in your theme (for example, in the <head> section of your layout or a section file).
Within your Organization markup, nest the MemberProgram data. Use hasMemberProgram to insert your loyalty program’s info under the Organization. For example, you might include something like:
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "OnlineStore",
"name": "My Shopify Store",
"url": "https://www.mystore.com",
"logo": "https://www.mystore.com/logo.png",
"hasMemberProgram": {
"@type": "MemberProgram",
"name": "VIP Rewards Club",
"description": "Our loyalty program gives members exclusive perks like discounts and points",
"url": "https://www.mystore.com/vip-rewards", <!-- Sign-up page for the program -->
"hasTiers": [
{
"@type": "MemberProgramTier",
"@id": "#vip-silver", <!-- Tier ID (for linking) -->
"name": "Silver",
"hasTierBenefit": [
"https://schema.org/TierBenefitLoyaltyPoints" <!-- Silver tier earns points -->
],
"membershipPointsEarned": 5 <!-- e.g., 5 points per currency unit -->
},
{
"@type": "MemberProgramTier",
"@id": "#vip-gold",
"name": "Gold",
"hasTierBenefit": [
"https://schema.org/TierBenefitLoyaltyPoints",
"https://schema.org/TierBenefitLoyaltyPrice" <!-- Gold tier gets member pricing + points -->
],
"membershipPointsEarned": 10, <!-- e.g., 10 points per currency unit -->
"hasTierRequirement": {
"@type": "MonetaryAmount",
"value": 100,
"currency": "USD"
} <!-- e.g., requires spending $100 to reach Gold -->
}
]
}
<!-- ...other Organization properties... -->
}
</script>
In the example above, we define a VIP Rewards Club with two tiers.
The “Silver” tier is free and grants loyalty points (5 points per dollar, for instance).
The “Gold” tier grants points (10 per dollar) and a loyalty price benefit, with a requirement (perhaps needing $100 spent to qualify).
We included a “@id” for each tier (#vip-silver and #vip-gold). These IDs are crucial: they will be used on product pages to reference the tier. You can use fragment IDs (like #tiername) as shown, or full URLs (e.g., “https://www.mystore.com/vip-rewards#vip-gold”).
The key is that the @id is unique and consistent.
Required fields: At minimum, include the program name, description, and hasTiers (with at least one tier) in your MemberProgram schema.
Each MemberProgramTier must have a name and at least one hasTierBenefit entry describing what members get (points, special price, etc.).
In practice, you’ll likely add more details (as we did above), such as the url where customers can learn about or join the program (recommended for the program and for each tier sign-up page).
Including a membershipPointsEarned value for point-earning tiers is also recommended so Google knows the rate of points accumulation.
If joining a tier isn’t free, use hasTierRequirement to explain the condition (a spend threshold, a subscription fee, a specific credit card, etc.)
Finally, add this JSON-LD script to an appropriate page. Google’s guidelines suggest placing the MemberProgram markup on the page where you detail your business’s policies or program info (an “About us” or dedicated loyalty program page is ideal).
You typically do not need to inject it on every page of your site – one page is enough to define the program, as long as your product pages can reference it via the @id links.
2. Tag member-only prices or points on product pages
With your loyalty program now described in the site’s schema, the next step is to integrate it with your Product schema on individual product pages. The goal here is to mark any special pricing or points that apply to members.
Most Shopify themes include a JSON-LD script on product pages with @type: “Product” containing an “offers” section (@type: “Offer”) for the product’s price. You will extend that offers data to include member-specific info:
Member pricing: If your loyalty program offers member-only prices (e.g., members get a discount price), you should add an extra UnitPriceSpecification within the offer.
This will sit alongside the regular price. You’ll use the property validForMemberTier on that UnitPriceSpecification to point to the tier it’s valid for.
For example, if Gold members have a special price of $80 (while everyone else pays $100), your JSON-LD might look like this:
"offers": {
"@type": "Offer",
"price": 100.00,
"priceCurrency": "USD",
"priceSpecification": [
{
"@type": "UnitPriceSpecification",
"price": 100.00,
"priceCurrency": "USD"
},
{
"@type": "UnitPriceSpecification",
"price": 80.00,
"priceCurrency": "USD",
"validForMemberTier": {
"@type": "MemberProgramTier",
"@id": "#vip-gold"
}
}
]
}
In the snippet above, we list two price specifications: one is the standard price ($100), and the other is a discounted $80 price marked as only valid for the Gold tier (“@id”: “#vip-gold” referencing the Gold tier defined earlier).
Google’s guidelines require that a normal price is provided alongside any member price: you can’t just list a member-only price by itself. So always keep the base price in the Offer (either as offers.price or a UnitPriceSpecification without a validForMemberTier).
The presence of both prices tells Google “this product’s regular price is $100, but Gold members can get it for $80.”
Points rewards: If your program offers points on purchase (which most do), you might also want to indicate how many points a member would earn for buying the product.
Google provides a way to do this via the membershipPointsEarned property, used in conjunction with validForMemberTier on a price specification.
Essentially, instead of (or in addition to) a special price, you include a price spec that says something like “this purchase yields X points for Gold members.” For example:
"priceSpecification": {
"@type": "UnitPriceSpecification",
"membershipPointsEarned": 20,
"validForMemberTier": {
"@type": "MemberProgramTier",
"@id": "#vip-gold"
}
}
This would indicate that a Gold member earns 20 points for buying the item (presumably on a product costing $20 if Gold gets 10 points per $1, based on our earlier tier definition). In practice, you might include both a member price and a points-earning spec if the tier offers both benefits.
Multiple Tiers: If you have different perks for multiple tiers (say Silver members also get a smaller discount), you can include multiple UnitPriceSpecifications each with a different validForMemberTier pointing to the respective tier.
Google’s merchant listing documentation shows an example with a silver and gold price in one product’s schema.
Just ensure each references the correct @id of the tier and that a non-member price is always present as well.
To implement this on Shopify, you will edit your theme’s product template.
In older Shopify themes, this might be in product.liquid. In Online Store 2.0 themes, it could be a JSON template or a section (like main-product.liquid or similar).
Locate the JSON-LD snippet for the Product. You’ll insert the extra UnitPriceSpecification JSON, and you may need to use Liquid variables to dynamically populate prices or point values.
For instance, you could use Liquid to output the product’s regular price and the discounted member price if you store that info. If you don’t have dynamic values readily available, you might hard-code the difference (less ideal), or calculate it via Liquid (e.g., {{ product.price | times: 0.8 }} for a 20% discount, etc.).
Tip: The @id in validForMemberTier should match exactly the @id you used in the Organization-level markup (including the same URL or fragment). For example, if your MemberProgram Tier was “@id”: “https://www.mystore.com/vip-rewards#vip-gold”, you must use that full string here. It’s often convenient to use a fragment (like #vip-gold) in both places – just ensure that the product page is either the same page or that Google can resolve the fragment by crawling the other page.
A common approach is to use your dedicated loyalty page URL plus #tiername as the ID.
By marking up products with member-specific prices or points, you enable Google to display those specifics in search results. For instance, one of Google’s examples shows a product listing with both the regular price and a “member price” for a Gold tier.
In your Shopify store’s case, a customer searching for a product you sell might see the price, a strikethrough (if on sale), and additionally something like “Gold members: $80” directly on Google – a direct result of this schema implementation.
3. Validate your structured data
After adding the schema markup, it’s crucial to test and validate it:
- Use Google’s Rich Results Test
Paste a URL of a page where you implemented the markup (such as a product page or your loyalty program page) into the Rich Results Test tool. This tool will parse your structured data and show you what Google detects.
Confirm that it recognizes your Product schema, Offer, and the MemberProgram/MemberProgramTier references.
Specifically, check that it sees the validForMemberTier property and that it’s not reporting errors. You should see your loyalty program and tier data linked in the tool’s output if all is well.
- Fix any errors or warnings
If you’re getting errors, it could be:
- “@id not found”: this means your validForMemberTier is pointing to an ID that Google didn’t find. Double-check that the @id string exactly matches between your product and the MemberProgram definition (including no typos or missing URL parts).
- validForMemberTier invalid or unrecognized: make sure you included the MemberProgramTier definition somewhere Google can see (like on a crawlable page) and that you used the correct schema type references. Also remember not to use priceType on a UnitPriceSpecification that has validForMemberTier (they are mutually exclusive markers).
- missing field warnings: Google’s tool might warn if you omit recommended fields. For example, if you have TierBenefitLoyaltyPoints but no membershipPointsEarned, it might not be an error but it’s better to include it. Similarly, adding a url for the MemberProgram is recommended.
- conflict in pricing: as noted, always present a standard price when using member prices, otherwise Google may ignore the schema. Don’t mark a member price as the only offer.
- page isn’t crawlable: Your structured data won’t help if Google can’t see it. So avoid putting the JSON-LD on a page that’s blocked by robots.txt or behind a login. In Shopify, most pages are public by default, but if you have your loyalty program info only in a customer account section, consider also placing the schema on a public page. You can use the URL Inspection tool in Google Search Console to fetch a page and verify that the structured data is present and indexed.
Once your markup passes the tests with no critical errors, deploy it to your live site.
It might be wise to start with one or two products and your program page, get those right, and then roll it out to all products (especially if you have many SKUs, implementing member pricing for all might be a bigger project).
Keep in mind that after deployment, it can take Google several days or more to crawl and update rich results.
There’s no guarantee Google will always show the loyalty info in SERPs, but having the schema in place makes it possible when conditions align.
4. Monitor and refine
After implementation, monitor your search results and Google Search Console for any reported issues. Keep on eye on:
- Search Console enhancements: Google may eventually list “Merchant listings” or other schema types in the Enhancements section of Search Console, where errors or warnings would appear. Check periodically for any flags (for example, errors in your schema could be listed there once Google indexes your pages).
- Performance impact: Watch your search performance (click-through rates on relevant queries) after the markup is indexed. If you start seeing impressions or clicks for rich results, that’s a good sign. While a loyalty rich snippet might not be explicitly labeled in performance reports, an uptick in CTR on product pages could indicate the richer snippet is attracting more attention.
- Necessary adjustments: If you change aspects of your loyalty program (like adding a new tier, or altering benefits), update the structured data to match. Consistency is important: the schema should reflect the actual program details users will find on your site. Also, if you spot that Google isn’t showing the info, ensure that the on-page content is also clearly stating the loyalty benefit (Google’s rich result guidelines prefer that the structured data is corroborated by visible content to avoid any perception of being misleading). For example, if you offer a member price, it’s good to also mention on the product page “Gold members pay $80” so that this isn’t just hidden in code.
Alternatively, you can work with a developer or use an app/plugin to implement the code
If the above implementation sounds a bit technical, don’t worry: many Shopify merchants will involve a developer, Shopify expert, or an app to help with adding structured data.
Working with a developer or agency:
Collaboration is important. Make sure you:
- share Google’s documentation
- forward any Search Console messages or error reports
- keep them in the loop with your loyalty program info so your structured data isn’t out-of-date
Shopify apps & plugins:
There are SEO and schema markup apps in the Shopify App Store (for example, Smart SEO, Schema Plus, JSON‑LD for SEO, etc.) that might add structured data to your site.
At time of writing, the MemberProgram type is very new, so not all apps may support it yet.
However, some apps allow adding custom JSON-LD snippets. You could use such features to insert the MemberProgram schema without directly editing theme code.
Google Merchant Center alternative:
If you are already using Google Merchant Center for your product feeds, note that Google offers an alternative way to provide loyalty program info through Merchant Center.
In Merchant Center, you can configure loyalty program settings (points per dollar, member discounts, etc.). Google has stated that if you set up your loyalty program in Merchant Center, it will use that data instead of your on-page markup.
The downside is that it only applies to Google’s ecosystem (and primarily Shopping results), whereas schema markup is on your site and could be used by any search/AI platform. Still, for completeness, consider updating Merchant Center with loyalty info if applicable, especially if you run Shopping Ads or free listings, as it might enhance those listings as well.
This natural extension of your loyalty strategy is a game-changer
Adopting the MemberProgram structured data is a proactive step for Shopify merchants to stay ahead in SEO and enrich how your brand appears in search results.
In an ecommerce landscape where every SERP listing is a competition for attention, displaying “Members get X benefit” right under your product name can be a game-changer. It not only boosts visibility but also communicates your value proposition (your loyalty program) at the earliest possible touchpoint.
For mature ecommerce brands, this is a natural extension of your loyalty strategy into the realm of SEO. You’ve invested in creating a loyalty or VIP program to retain customers, now make sure prospective customers know about it when they discover you via Google.
Early adopters of this schema have the opportunity to stand out and attract high-intent shoppers who are looking for the best value. Moreover, you’re aligning with Google’s direction of rewarding rich, user-centric information in search results.
