# How to Tell If a Website Uses Shopify > Learn 7 reliable ways to check whether any website runs on Shopify. Includes quick checks, source-code signals, and when each method fails. Published: 2026-02-19 Author: StoreInspect Team Tags: shopify, competitor-research, ecommerce Canonical HTML: https://storeinspect.com/blog/how-to-tell-if-a-website-uses-shopify ![How to tell if a website uses Shopify](/images/blog/how-to-tell-if-a-website-uses-shopify.webp) **TL;DR:** Use a detector extension first, then verify in source code (`cdn.shopify.com`, `Shopify.theme`, `/cdn/shop/`). For high-value leads, confirm with one more signal (cart/checkout behavior or app footprints). --- Most teams waste time here. Platform detection should be a quick filter, not a research project. If you're building lead lists, qualifying outbound accounts, or analyzing competitors, what you need is *enough confidence to act*. In practice, that means 2-3 independent signals, not one perfect proof. ## Why Platform Detection Is a High-Leverage Step A bad platform assumption breaks your downstream workflow: - You pitch Shopify services to non-Shopify stores - You misread app and theme choices - You contaminate lead lists with bad-fit accounts - You waste analysis time before qualification And it matters at scale. Tech intelligence providers track large Shopify footprints across the web, which is why this filtering step shows up in almost every ecommerce prospecting workflow ([BuiltWith trend report](https://trends.builtwith.com/websitelist/Shopify), [Wappalyzer profile](https://www.wappalyzer.com/technologies/ecommerce/shopify/)). Two official Shopify docs also explain why Shopify detection can be tricky: - Stores are assigned a `myshopify.com` domain at creation, but custom primary domains can hide it from casual checks ([Shopify Help: Domains](https://help.shopify.com/manual/domains/manage-domains)). - Cart and checkout behavior can be customized, so UI clues alone are not always enough ([Shopify Help: Checkout customization](https://help.shopify.com/en/manual/checkout-settings/customize-checkout-configurations)). If a site is Shopify, move immediately into deeper research: - App stack: [how to see what apps a Shopify store is using](/blog/how-to-see-what-apps-a-shopify-store-is-using) - Theme stack: [how to detect what Shopify theme a store is using](/blog/how-to-detect-what-shopify-theme-a-store-is-using) - Pixel stack: [how to detect what pixels a Shopify store is using](/blog/how-to-detect-what-pixels-a-shopify-store-is-using) - Prospecting workflow: [how to find Shopify stores](/blog/how-to-find-shopify-stores) ## Quick 60-Second Workflow (Use This First) 1. Run an extension check 2. Confirm with source-code signals 3. Use one tie-breaker signal for important accounts This catches most cases fast enough for day-to-day prospecting. ## Method 1: Use a Shopify Detector Extension **Best for:** speed, routine checks, and non-technical users. Open the store and run a one-click detector. [Store Inspector](https://chromewebstore.google.com/detail/store-inspector-theme-app/gbchfcpcpikdmdeipbkjgelkpfdnebpj) is built for Shopify workflows and returns platform + stack clues in one pass. Broader tools like BuiltWith and Wappalyzer also work, but are less Shopify-specific in single-store analysis. **Strengths** - Fastest first-pass signal - No code inspection required - Good enough for most low-stakes checks **Weaknesses** - Can miss heavily customized storefronts - Browser profile / extension conflicts can create noise - Should not be your only signal for high-value targets ## Method 2: Check Source Code for Shopify Signatures **Best for:** manual validation and ambiguous extension output. ### What to do 1. Open the page source (`Cmd+Option+U` on Mac, `Ctrl+U` on Windows) 2. Search for high-signal patterns: - `cdn.shopify.com` - `shopifycdn.net` - `Shopify.theme` - `Shopify.shop` - `/cdn/shop/` - `myshopify.com` If you find two independent Shopify signatures, confidence is typically high. ### Why this works Even customized Shopify stores usually load some platform-linked assets or objects. Not always visible in the rendered UI, but often visible in source or scripts. ### Failure modes - Headless setups can reduce obvious signatures - Asset rewriting and caching layers can mask expected patterns - Source can include stale snippets after migrations ## Method 3: Check URL and Route Behavior **Best for:** quick secondary signal. Test common storefront routes: - `https://domain.com/cart` - `https://domain.com/collections/all` - `https://domain.com/products/all` Shopify uses these patterns broadly, and official cart permalink behavior confirms how cart URLs are used in Shopify storefront flows ([Shopify Help: Cart permalinks](https://help.shopify.com/en/manual/products/details/cart-permalink)). Treat route behavior as supportive evidence, not final proof. ## Method 4: Validate Cart and Checkout Flow **Best for:** high-confidence confirmation when source clues are mixed. Add a product to cart and begin checkout. Watch for: - Shopify-like cart handling patterns - Shopify-style checkout transitions - Domain/flow behavior consistent with Shopify storefronts Important caveat: checkout can be customized and extended, especially on larger stores. Shopify explicitly supports broad checkout customization (with advanced capabilities on Plus), so visual similarity is not enough by itself ([Shopify Help: checkout customization](https://help.shopify.com/en/manual/checkout-settings/customize-checkout-configurations)). ## Method 5: Use BuiltWith or Wappalyzer as Cross-Checks **Best for:** list validation and mixed-platform datasets. - [BuiltWith](https://builtwith.com) - [Wappalyzer](https://www.wappalyzer.com) These tools are strong for breadth and speed when you process many domains, and useful when your workflow includes non-Shopify context (analytics stack, framework, infrastructure). For high-value accounts, always manually verify because third-party tech databases can be delayed or incomplete. ## Method 6: Look for Shopify App Footprints **Best for:** deeper confirmation during competitive teardown. Many Shopify apps leave fingerprints in scripts, comments, and network calls: - Reviews: Judge.me, Loox, Yotpo - Lifecycle: Klaviyo, Omnisend - Subscriptions and upsell tooling Clear Shopify app signatures are usually decisive for platform ID. If this is your main workflow, use: - [how to find Shopify stores by app](/blog/how-to-find-shopify-stores-by-app) - [best Shopify competitor research tools](/blog/best-shopify-competitor-research-tools) ## Method 7: DNS/CNAME Clues (Advanced Fallback) **Best for:** hard edge cases after front-end checks fail. Use DNS tools (`dig`, `nslookup`, DNS inspectors) to inspect infrastructure hints. This can help when storefront rendering hides obvious platform clues. It's slower and less practical for daily prospecting, but useful for strategic accounts where false positives are expensive. ## False Positives and False Negatives: Where Teams Get Burned The biggest operational problem is not missing Shopify stores. It's confidently being wrong. ### Common False Positives | Scenario | Why it happens | How to fix | |----------|----------------|------------| | Script mentions Shopify on a migrated site | Legacy code left in templates | Confirm with live cart/checkout behavior | | Third-party detector says Shopify but source is weak | Detection model is stale | Require a second independent signal | | Cached pages show old Shopify assets | CDN cache lag | Test multiple pages and network requests | | Aggregated tools inherit outdated tech tags | Dataset refresh lag | Manually inspect source for current scripts | ### Common False Negatives | Scenario | Why it happens | How to fix | |----------|----------------|------------| | Headless storefront hides obvious Shopify globals | Front-end abstraction | Use app footprints and route behavior checks | | Highly customized enterprise checkout | Standard visual cues are altered | Confirm via source + cart workflow | | Regional/multi-domain architecture | Signals vary by locale/domain | Test root domain and country subpaths | | Aggressive script optimization | Platform clues minimized in HTML | Inspect network requests, not only source | ### Practical rule If one signal says Shopify and one says not Shopify, treat as unresolved and run tie-breakers. Do not push unresolved accounts into outreach automation. ## Troubleshooting Guide With Real-World Patterns These are recurring patterns we see in prospecting and competitor analysis workflows. ### Pattern 1: "The extension says Shopify, but source looks clean" What is usually happening: - Dynamic assets load after initial HTML render - Script injection hides obvious static signatures What to do: 1. Open DevTools Network tab 2. Reload page 3. Filter for `shopify`, `cdn/shop`, and known app vendors If you do not use network inspection often, MDN has a good neutral primer on browser Network Monitor workflows: [MDN Network Monitor](https://developer.mozilla.org/en-US/docs/Tools/Network_Monitor). If network requests show Shopify-linked assets, treat that as a strong confirmation. ### Pattern 2: "The site looks like Shopify but nothing obvious appears" What is usually happening: - Custom front-end architecture - Heavily customized theme output What to do: 1. Test `/cart` 2. Test product-to-checkout flow 3. Inspect app script footprints This combination usually resolves ambiguous cases. ### Pattern 3: "Different pages give different answers" What is usually happening: - Mixed templates - Regional domains with different deployment states - Partial migrations What to do: 1. Check homepage, product page, and cart page 2. Repeat checks on `www` and non-`www` variants 3. Compare behavior across one regional path if present Only classify after page-level inconsistency is resolved. ### Pattern 4: "BuiltWith says Shopify, extension says no" What is usually happening: - Historical detection vs live rendering mismatch What to do: 1. Prioritize live evidence (source + network + route behavior) 2. Keep BuiltWith/Wappalyzer as directional, not final 3. Mark account as "needs manual confirmation" in your lead sheet ### Pattern 5: "Everything looks right until checkout" What is usually happening: - Checkout customization masks expected visuals - Plan-level differences in customization capabilities What to do: 1. Ignore design cues 2. Focus on flow mechanics and technical signals 3. Combine checkout observations with source evidence ## Confidence Scoring Model (Copy This) Use this lightweight scoring system in your prospecting process: | Signal | Points | |--------|--------| | Extension identifies Shopify | +2 | | Source includes `cdn.shopify.com` or `/cdn/shop/` | +3 | | `Shopify.shop` / `Shopify.theme` present | +2 | | Cart/route behavior matches Shopify patterns | +2 | | Shopify app footprints detected | +3 | | DNS/CNAME supports Shopify hypothesis | +1 | Classification: - **0-2 points:** Unclear, do not classify - **3-5 points:** Probable Shopify, add manual spot check - **6+ points:** High-confidence Shopify This keeps your team consistent and reduces subjective calls. ## Worked Examples (Real Prospecting Situations) These are practical examples you can mirror in a live workflow. ### Example A: Fast qualification for outbound You find a store through search and need to decide if it belongs in your Shopify outreach sequence. What you do: 1. Run extension check: positive (+2) 2. Open source and find `/cdn/shop/` (+3) 3. Stop there and classify as Shopify (total: 5, probable) Why this is enough: - This is a mid-value lead - You have two independent high-signal checks - Extra validation has low marginal value here What to do next: - Move to [how to qualify Shopify leads](/blog/how-to-qualify-shopify-leads) - Pull contact workflow from [how to get Shopify store owner emails](/blog/how-to-get-shopify-store-owner-emails) ### Example B: High-value enterprise target with mixed signals You are evaluating a strategic account and cannot afford a misclassification. What you see: - Extension says not Shopify (0) - Source has one weak clue (`shopifycdn`) but no strong globals (+1) - `/cart` behavior looks Shopify-like (+2) - App footprint includes Shopify app script signatures (+3) Total: 6 (high-confidence Shopify), despite extension miss. Why this happens: - Heavily customized storefronts can reduce extension visibility - Source-level clues may be partial - App and route behavior become decisive tie-breakers ### Example C: Suspected false positive from stale datasets A tech lookup tool says Shopify, but live checks disagree. What you see: - BuiltWith says Shopify (+2 directional, not final) - Extension says no (0) - Source has no Shopify signatures (0) - Cart route does not behave like Shopify (0) Result: - Treat as unresolved or likely non-Shopify - Mark "recheck later" instead of auto-qualifying This prevents low-fit accounts from entering your pipeline. ## SOP Template for Teams (Copy/Paste) Use this checklist in your CRM or lead spreadsheet. **Field group 1: Detection signals** - Extension result: `yes / no / unclear` - Source signatures found: `none / one / multiple` - Route behavior: `matches / does not match / unclear` - App footprints: `present / absent / unknown` - DNS signal (optional): `supports / no support / not checked` **Field group 2: Scoring** - Auto-calculate score using the model above - Classification output: `unclear`, `probable`, `high-confidence` **Field group 3: Action rule** - `unclear` -> manual review queue - `probable` -> include but flag for spot check - `high-confidence` -> proceed to qualification **Field group 4: Next-step link** - Prospecting: [how to find Shopify clients for your agency](/blog/how-to-find-shopify-clients-for-your-agency) - Competitive teardown: [how to analyze Shopify competitors](/blog/how-to-analyze-shopify-competitors) - Stack intelligence: [shopify tech stack](/blog/shopify-tech-stack) This is simple, but it keeps teams from debating every edge case in Slack and makes quality control measurable. ## What To Read Next If your job is **lead generation**: - [how to find Shopify clients for your agency](/blog/how-to-find-shopify-clients-for-your-agency) - [how to qualify Shopify leads](/blog/how-to-qualify-shopify-leads) - [how to get Shopify store owner emails](/blog/how-to-get-shopify-store-owner-emails) If your job is **competitor teardown**: - [how to analyze Shopify competitors](/blog/how-to-analyze-shopify-competitors) - [how to check Shopify store traffic](/blog/how-to-check-shopify-store-traffic) - [how to check Shopify store revenue](/blog/how-to-check-shopify-store-revenue) If your job is **tech stack intel**: - [shopify tech stack](/blog/shopify-tech-stack) - [how to detect what pixels a Shopify store is using](/blog/how-to-detect-what-pixels-a-shopify-store-is-using) - [how to detect what Shopify theme a store is using](/blog/how-to-detect-what-shopify-theme-a-store-is-using) ## Common Mistakes (Still Worth Calling Out) ### 1. One-signal classification A single clue is a hint, not a decision. ### 2. Over-trusting UI cues Visual checkout patterns are useful, but customization can mislead. ### 3. Ignoring inconsistencies across pages Mixed signals across homepage/product/cart often indicate architecture complexity. Resolve before labeling. ### 4. Skipping manual checks for high-value accounts If one account is worth meaningful revenue, spend the extra minute and verify. ## FAQ ### Can stores hide Shopify completely? They can hide obvious clues, but most still expose enough indicators through source, network, cart/checkout behavior, or app scripts. ### Is this legal for competitor research? Inspecting public storefront behavior and source code is standard research practice. Still comply with tool terms and local rules. ### Should I trust tech databases for final classification? Use them for discovery and prioritization, then validate high-value accounts with live technical checks. ### What is the fastest reliable workflow for agencies? Extension -> source check -> one tie-breaker signal -> classify. Then move directly into qualification and outreach planning. ## Final Takeaway If your team does this every week, turn platform detection into a standard operating step: 1. First-pass detection (fast) 2. Manual confirmation (reliable) 3. Tie-breaker for ambiguous accounts (safe) That combination is fast enough for volume and accurate enough for serious outbound work. When confirmed, go deeper immediately: - [How to see what apps a Shopify store is using](/blog/how-to-see-what-apps-a-shopify-store-is-using) - [How to find Shopify stores by app](/blog/how-to-find-shopify-stores-by-app) - [How to qualify Shopify leads before outreach](/blog/how-to-qualify-shopify-leads) Or run the one-click approach with [Store Inspector](https://chromewebstore.google.com/detail/store-inspector-theme-app/gbchfcpcpikdmdeipbkjgelkpfdnebpj) and validate strategic targets with a manual source check.