How to Tell If a Website Uses Shopify [7 Free Methods + Accuracy Guide]

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, Wappalyzer profile).

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).
• Cart and checkout behavior can be customized, so UI clues alone are not always enough (Shopify Help: Checkout customization).

If a site is Shopify, move immediately into deeper research:

• App stack: how to see what apps a Shopify store is using
• Theme stack: how to detect what Shopify theme a store is using
• Pixel stack: how to detect what pixels a Shopify store is using
• Prospecting workflow: 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 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).

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

Method 5: Use BuiltWith or Wappalyzer as Cross-Checks

Best for: list validation and mixed-platform datasets.

• BuiltWith
• Wappalyzer

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

Common False Negatives

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.

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:

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
• Pull contact workflow from 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
• Competitive teardown: how to analyze Shopify competitors
• Stack intelligence: shopify tech stack

This is simple, but it keeps teams from debating every edge case in Slack and makes quality control measurable.

Internal Linking Map: What To Read Next

If your job is lead generation:

• how to find Shopify clients for your agency
• how to qualify Shopify leads
• how to get Shopify store owner emails

If your job is competitor teardown:

• how to analyze Shopify competitors
• how to check Shopify store traffic
• how to check Shopify store revenue

If your job is tech stack intel:

• shopify tech stack
• how to detect what pixels a Shopify store is using
• 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
• How to find Shopify stores by app
• How to qualify Shopify leads before outreach

Or run the one-click approach with Store Inspector and validate strategic targets with a manual source check.