> ## Documentation Index
> Fetch the complete documentation index at: https://beta.docs.replo.app/llms.txt
> Use this file to discover all available pages before exploring further.
# Why Publish to a Subdomain
> Understand why Replo pages live on a subdomain, what stays on Shopify, and how tracking, ads, and checkout keep working.
export const Screenshot = ({src, altText, width, shadow = true}) => {
const generateAltText = imageSrc => {
if (!imageSrc) return "Screenshot";
const filename = imageSrc.split("/").pop() ?? "";
const nameWithoutExt = filename.replace(/\.[^/.]+$/, "");
const readable = nameWithoutExt.replace(/[-_]/g, " ").replace(/\b\w/g, char => char.toUpperCase());
return readable === "" ? "Screenshot" : readable;
};
const finalAltText = altText ?? generateAltText(src);
const imageWidth = width ? `${width}px` : "100%";
return ;
};
Replo publishes your pages to a subdomain of your own domain (for example, `shop.yourbrand.com`) instead of into your Shopify theme. If your first reaction is "I don't want a subdomain, I want to publish to Shopify," this page explains why the subdomain exists, what actually changes (less than you'd expect), and the few cases where a subdomain genuinely isn't the right tool.
The short version: your Shopify store stays your Shopify store. Products sync from Shopify, every add to cart writes to a real Shopify cart behind the scenes, checkout happens on Shopify checkout, and orders land in your Shopify admin like any other order.
The cart drawer a visitor sees is Replo's (rebuilt to match yours, if you want); the cart data, checkout, and orders are Shopify's. The only thing that moves is where the page itself is hosted.
## What a subdomain is
A subdomain is a section of the domain you already own. If your store is `yourbrand.com`, then `shop.yourbrand.com` is a subdomain of it. It's not a new domain, a Replo-branded URL, or a third-party address; it's your brand in the address bar, controlled by one DNS record you add at your domain provider.
Browsers and ad platforms treat subdomains as part of the same site for the things that matter to marketers: cookies set by Meta and Google Analytics are shared across `yourbrand.com` and `shop.yourbrand.com`, and Meta's domain verification for `yourbrand.com` covers every subdomain automatically (details below).
## Why Replo pages don't publish into your theme
Your root domain points at Shopify, and Shopify only serves Liquid theme code from it. Replo pages are modern web apps: server-rendered React, deployed to Cloudflare's edge network. That architecture is what makes the pages fast and lets Replo build and edit them for you in chat, and it can't be uploaded into a Liquid theme.
So the page needs its own address, and a subdomain of your existing domain is the address that keeps your brand, your cookies, and your ad account verification intact.
The separation also works in your favor:
* **No theme risk.** Nothing Replo publishes can touch your theme, navigation, or existing pages. Test aggressive offers freely.
* **No app bloat.** Your theme loads every app script you've ever installed. Replo pages load only what's on the page, which is a big part of why they're fast. See [Page Speed](/features/page-speed).
* **Campaign independence.** Marketing ships landing pages without waiting on whoever owns the theme, and without a deploy that could break the store.
If you need pages that live inside your theme (sections, blog posts, product templates), that's what the [Replo Theme Builder](/getting-started/sites-vs-themes) is for. The two products work side by side.
## What stays on Shopify
Connecting Shopify to Replo means the commerce layer is Shopify's, regardless of where the page is hosted:
* **Products**: your catalog syncs automatically, including variants, selling plans, inventory, and pricing. Changes sync within about 5 minutes; cart prices and inventory are always real time.
* **Cart**: the slide-out cart on a Replo page is Replo's own cart UI, and you can have Replo recreate your theme's cart design, including its upsells and messaging. Underneath, every add to cart writes to a real Shopify cart through Shopify's Storefront API, the same mechanism headless storefronts use, which is why discount codes and Shop Pay work at checkout.
One nuance: this cart is separate from a cart the same visitor may have started on your theme site, so items don't merge across the two; each funnel checks out with what was added in it.
* **Checkout**: customers check out on your Shopify checkout, with Shop Pay, discount codes, and your checkout apps.
* **Orders and automations**: orders appear in your Shopify admin like any other order. Abandoned cart emails, confirmation flows, and segmentation keep working because the cart and order data live in Shopify.
For the full picture, see [Selling with Shopify](/commerce/shopify).
## Setup is about five minutes, and Replo walks you through it
If you've never set up a subdomain, this is probably the part that feels daunting, especially when your current stack already works and you know your Shopify publishing flow cold. So here is the entire setup, start to finish:
1. **Tell Replo the subdomain you want** (say `shop.yourbrand.com` in chat, or type it in Site settings → **Domains**).
2. **Copy one DNS record.** Replo shows you the exact record (a CNAME) with the exact values. You paste it into your domain provider (GoDaddy, Namecheap, Cloudflare, or Shopify admin if Shopify manages your DNS).
3. **Click Check Connection.** Replo verifies the record and provisions the SSL certificate automatically. There is nothing to buy, renew, or maintain.
That's the whole thing: about five minutes of actual work, and if it takes longer, the extra time is DNS propagation (waiting, not doing). If you get stuck on step 2, ask Replo in chat; it will tell you exactly where to click for your specific domain provider.
Two more fears worth putting down:
* **You don't have to touch DNS to start.** Every site publishes to a free `replosites.com` staging domain with zero setup. Build, publish, and share pages there today, and connect the subdomain whenever you're ready to run traffic.
* **You're not learning a new publishing flow.** There's no theme editor equivalent to master. You describe the page, Replo builds it, and publishing is one click (or just ask). If anything, it's fewer steps than the flow you already know.
The full walkthrough with screenshots is in [Custom Domains](/custom-domains).
## Common concerns, answered
No. Meta verifies domains at the root, and verification is inherited by every subdomain. Meta's developer FAQ states it directly: "domain verification status is inherited by subdomains. For example, verifying 'domain.com' will also verify 'm.domain.com'." Meta's [domain verification instructions](https://www.facebook.com/business/help/321167023127050) work the same way: you enter the root domain without any prefixes when you verify.
If `yourbrand.com` is already verified in your Business Manager, `shop.yourbrand.com` is covered, with nothing new to verify.
The one exception, from that same Meta help page: "You'll only need to verify subdomains when you're onboarding to Facebook Commerce." That's Shops onboarding, unrelated to running ads to a landing page.
No, and this is worth understanding precisely because it's the most common worry.
The Meta Pixel identifies visitors with the `_fbp` cookie, which is a first-party cookie set at your root domain. That means the same visitor identity is shared across `yourbrand.com`, `shop.yourbrand.com`, and your Shopify checkout. A visitor who lands on your Replo page from an ad and buys through your checkout is one person to Meta, not two.
Setup is the same pixel IDs you already use, added once in your site's **Scripts & Pixels** settings (or ask Replo in chat). Replo supports Meta, GA4, Google Tag Manager, TikTok, Pinterest, Snapchat, Reddit, and more; see [Integrations](/integrations/introduction).
Two things Replo does for you automatically:
* **Every query parameter follows the visitor to checkout.** UTMs and click IDs (`fbclid`, `gclid`, and everything else on the landing URL) are carried onto the Shopify checkout URL, so attribution survives the handoff from your Replo page to Shopify.
* **No double counting.** When checkout is Shopify-hosted, Shopify's native ad-platform integrations already report checkout and purchase events, so Replo's pixels suppress their duplicates.
One honest caveat: page views on your Replo pages show up in Replo's analytics and your GA4/pixel dashboards, not in Shopify's built-in Analytics reports (Shopify only reports on pages it hosts). Orders, revenue, and conversion attribution in Shopify are unaffected.
You don't have to take any of this on faith. Before you launch, ask Replo to audit your tracking setup:
```text theme={null}
Audit my tracking setup before I drive paid traffic. Compare the pixels installed on this site against my main store at yourbrand.com, list anything missing, and flag anything that would break attribution.
```
Replo reads your **Scripts & Pixels** configuration, compares it against your live store, and tells you exactly what to fix, so "did I set this up right?" gets a concrete answer instead of a guess.
GA4 handles subdomains automatically. Its default `cookie_domain` setting stores the analytics cookie at your root domain, so the same measurement ID tracks one visitor across `yourbrand.com` and `shop.yourbrand.com` with no cross-domain configuration. Google documents this in the [GA4 configuration reference](https://developers.google.com/analytics/devguides/collection/ga4/reference/config). Use the same measurement ID on both, and you're done.
These tools attribute with the same building blocks: their pixel on the page, plus UTMs and click IDs surviving to checkout. Add their snippet in **Scripts & Pixels** (Triple Whale and Northbeam are supported alongside the ad-platform pixels), keep UTMs on your ad URLs as usual, and Replo forwards everything to checkout. If your attribution tool has a setup checklist for landing page domains, it takes the subdomain the same way it takes your root domain.
Pointing an ad at a new landing page URL is the same operation whether that page is `yourbrand.com/pages/offer` or `shop.yourbrand.com/offer`: a new ad or an edited destination behaves the same either way. There's no domain-level penalty, allowlist, or review triggered by using your verified domain's subdomain. Google Ads destination requirements are also satisfied because the display and destination domains match your brand.
For the pages you'd build in Replo (paid landing pages, campaign funnels, advertorials), SEO usually isn't the goal, and you can keep them out of search entirely with per-page indexing controls; see [Site & Page Settings](/features/site-page-settings).
For search itself, Google's official position is that subdomains and subdirectories are [equivalent for crawling and ranking](https://developers.google.com/search/help/crawling-index-faq). The honest nuance: a subdomain builds its own authority rather than inheriting your root domain's, so content whose job is organic growth (your blog, your collection pages) belongs on your main site.
That's a reason to keep SEO content where it is, not a reason to avoid subdomains for campaign pages. Replo sites also generate their own sitemap and robots rules automatically.
You rebuild them once, and rebuilding is fast. The cart drawer on a Replo page is Replo's own UI (your theme's cart can't render outside your theme), backed by a real Shopify cart underneath.
Point Replo at your live site and ask it to recreate your cart's design, including gift-with-purchase logic, upsells, and promotional messaging. Metafield-driven offers can read the same metafields your theme cart uses, so you control both from one place. Many teams get an exact copy of their theme cart in one session.
It's one DNS record and about five minutes of work; [the setup section above](#setup-is-about-five-minutes-and-replo-walks-you-through-it) lists all three steps. And if you're not ready to touch DNS at all, publish to your free `replosites.com` staging domain first and connect the subdomain when you want to run traffic.
Customers see your brand in the address bar (`shop.yourbrand.com`), then check out on your normal checkout. Subdomains are standard practice across ecommerce: brands routinely run stores, campaign pages, and content on subdomains, and paid traffic in particular never notices, because visitors arrive from an ad and leave through checkout without ever typing a URL.
"Keep everything in one place" is a fair instinct, but the place your pages live and the place your commerce lives are already separate concerns; Shopify itself hosts your checkout on different infrastructure than your theme.
The subdomain buys you real things: pages that load without your theme's app scripts, campaigns that can't break your store, and a build workflow where you describe the page instead of assembling it. The setup cost is one DNS record; the concerns that make subdomains feel risky (tracking, ads, checkout) are covered above, with sources.
## When a subdomain isn't the right choice
Some pages should live inside your Shopify theme, and a subdomain is the wrong tool for them:
* **Core product and collection pages** that need your theme's navigation, search, and installed theme apps around them.
* **SEO content** (blog posts, buying guides) whose job is building your root domain's authority.
* **Pages that depend on theme-specific Liquid** or apps that only render inside a Shopify theme.
For those, use the [Replo Theme Builder](/getting-started/sites-vs-themes), which publishes directly into your theme on your store's domain. Teams commonly run both, and it isn't an even split: the Theme Builder handles the pages that must live in your theme, and Replo Agent does everything else.
That's because publishing pages is only one part of what Replo Agent does. The same chat captures your brand kit and guidelines and applies them to every page you build, audits your tracking setup before you spend on ads, duplicates landing pages into A/B variants and designs the test so the result is trustworthy, reads your analytics and builds reports on demand, and runs scheduled tasks (weekly performance summaries, broken-link checks) in the background. [Common Workflows](/use-cases/workflows) shows each of these in practice.
The subdomain is just where the pages live; the agent working across your whole funnel is what you're actually getting.
## Before you drive paid traffic
A short checklist so the first campaign is attributed correctly:
1. **Connect and verify your subdomain** in Site settings → **Domains** ([Custom Domains](/custom-domains)).
2. **Add your pixels** in **Scripts & Pixels**: the same Meta, GA4, TikTok, and attribution-tool IDs you use on your main store ([Integrations](/integrations/introduction)).
3. **Ask Replo to audit the setup** against your main store (the prompt is in the tracking question above). Fix anything it flags.
4. **Keep UTMs on your ad URLs** exactly as you do today. Replo forwards them (and click IDs) through to checkout.
5. **Click through the funnel once**: land on the published page with test UTMs, add to cart, and reach checkout. Confirm your pixel events fire and the parameters arrive.
6. **Publish and launch.** Orders appear in your Shopify admin; page analytics appear in Replo's insights and your GA4.
## Next steps
Connect your subdomain with one DNS record.
How products, cart, and checkout work end to end.
Why Replo-hosted pages load fast.