Tutorial

How to Detect if a Website Uses Shopify Programmatically (API Guide 2026)

Published March 29, 2026 · 11 min read

Shopify powers over 4 million live stores. If you sell to e-commerce businesses — apps, themes, services, integrations — knowing which websites run Shopify is the difference between a targeted outreach list and noise. The question is: how do you check if a website uses Shopify programmatically, at scale, without clicking through sites one by one?

This guide covers every method: manual detection tricks, their limitations, and the API approach that lets you scan thousands of URLs in minutes. By the end, you'll have working code in curl, Node.js, and Python that detects Shopify stores reliably.

Why Detecting Shopify Matters

Shopify detection isn't just a curiosity exercise. It drives real business outcomes across multiple workflows:

The common thread: you need to check many websites, not just one. Manual methods break down fast. Let's look at them anyway, because understanding why they fail will make the API solution click.

Manual Methods for Detecting Shopify

Before reaching for an API, you should understand the signals that indicate a Shopify store. These are the same signals that detection tools use under the hood.

1. Check the /admin redirect

Visit example.com/admin. If the site runs Shopify, it redirects to accounts.shopify.com/store-login or the Shopify admin login page. This is one of the most reliable manual checks because Shopify reserves the /admin path for store management.

curl -sI "https://example.com/admin" | grep -i "location"
# If Shopify: Location: https://accounts.shopify.com/store-login

2. Look for cdn.shopify.com in page source

Shopify serves assets — images, stylesheets, scripts — from cdn.shopify.com. View the page source and search for this domain. Nearly every Shopify store loads at least some assets from this CDN, even stores using custom domains and themes.

curl -s "https://example.com" | grep -c "cdn.shopify.com"
# Returns a count > 0 if Shopify assets are present

3. Check for Shopify JavaScript objects

Shopify injects global JavaScript objects into every storefront page. Open your browser's developer console on the target site and type Shopify. If the site runs Shopify, you'll see an object containing Shopify.theme, Shopify.shop, and Shopify.locale. In automated detection, you can search the HTML source for references to these objects.

4. Look for Shopify meta tags

Many Shopify stores include a meta tag with name="shopify-checkout-api-token" in their HTML head. Some also include shopify-digital-wallet meta tags for Apple Pay and Google Pay integration.

curl -s "https://example.com" | grep -i "shopify-checkout-api-token"

5. Inspect HTTP headers

Shopify stores sometimes return headers like X-ShopId, X-Sorting-Hat-ShopId, or X-Shopify-Stage. These are less consistent than other methods because they depend on Shopify's current infrastructure configuration, but when present they are definitive.

curl -sI "https://example.com" | grep -i "shopify"

The Problem with Manual Detection

Each of the methods above works for checking a single website. But they all share the same fatal flaw: they don't scale.

This is why purpose-built detection APIs exist. They combine multiple detection signals, handle edge cases, manage infrastructure changes, and return structured results you can feed directly into your pipeline.

The StackPeek API Solution: One GET Request

The StackPeek API detects 120+ technologies — including Shopify — from a single HTTP request. No headless browser. No scraping. No maintaining your own fingerprint database. You send a URL, you get back a JSON array of detected technologies with confidence scores.

Here's what it looks like.

curl

curl "https://stackpeek.web.app/api/v1/scan?url=allbirds.com"

Response:

{
  "url": "allbirds.com",
  "technologies": [
    {
      "name": "Shopify",
      "category": "E-commerce",
      "confidence": 0.97
    },
    {
      "name": "Google Analytics",
      "category": "Analytics",
      "confidence": 0.95
    },
    {
      "name": "Cloudflare",
      "category": "CDN",
      "confidence": 0.99
    }
  ],
  "scanTime": "412ms"
}

One request. Structured JSON. Confidence scores. Under 500 milliseconds. No API key required for the free tier (100 scans/day).

To check whether Shopify was detected, just filter the technologies array for name === "Shopify". Let's see this in real code.

Node.js

const response = await fetch(
  `https://stackpeek.web.app/api/v1/scan?url=${encodeURIComponent(url)}`
);
const data = await response.json();

const shopify = data.technologies.find(
  t => t.name.toLowerCase() === 'shopify'
);

if (shopify) {
  console.log(`Shopify detected with ${(shopify.confidence * 100).toFixed(0)}% confidence`);
} else {
  console.log('Not a Shopify store');
}

Python

import requests

url = "allbirds.com"
resp = requests.get(
    f"https://stackpeek.web.app/api/v1/scan?url={url}"
)
data = resp.json()

shopify = next(
    (t for t in data["technologies"]
     if t["name"].lower() == "shopify"),
    None
)

if shopify:
    print(f"Shopify detected ({shopify['confidence']:.0%} confidence)")
else:
    print("Not a Shopify store")

Batch Scanning: Check Thousands of URLs for Shopify

The real power of an API approach is batch processing. Instead of checking one URL at a time, you can feed an entire list of domains and get a filtered report of Shopify stores.

Here's a complete Python script that reads URLs from a CSV, scans each one via StackPeek, and writes the Shopify stores to a separate output file:

import requests
import csv
import time

API_BASE = "https://stackpeek.web.app/api/v1/scan"

def is_shopify(url):
    try:
        resp = requests.get(f"{API_BASE}?url={url}", timeout=10)
        data = resp.json()
        return any(
            t["name"].lower() == "shopify"
            for t in data.get("technologies", [])
        )
    except Exception:
        return False

# Read URLs from input CSV
with open("urls.csv") as f:
    urls = [row[0] for row in csv.reader(f)]

# Scan and filter
shopify_stores = []
for i, url in enumerate(urls):
    print(f"Scanning {i+1}/{len(urls)}: {url}")
    if is_shopify(url):
        shopify_stores.append(url)
        print(f"  -> Shopify detected")
    time.sleep(0.2)  # respect rate limits

# Write results
with open("shopify_stores.csv", "w") as f:
    for store in shopify_stores:
        f.write(f"{store}\n")

print(f"\nFound {len(shopify_stores)} Shopify stores out of {len(urls)} URLs")

For higher throughput, add concurrency with asyncio and aiohttp in Python, or Promise.allSettled in Node.js. The StackPeek API handles concurrent requests well, so you can safely run 5–10 parallel scans without issues.

A Node.js concurrent version looks like this:

async function scanBatch(urls, concurrency = 5) {
  const results = [];

  for (let i = 0; i < urls.length; i += concurrency) {
    const batch = urls.slice(i, i + concurrency);
    const promises = batch.map(async (url) => {
      const res = await fetch(
        `https://stackpeek.web.app/api/v1/scan?url=${encodeURIComponent(url)}`
      );
      const data = await res.json();
      const hasShopify = data.technologies?.some(
        t => t.name.toLowerCase() === 'shopify'
      );
      return { url, isShopify: hasShopify };
    });

    results.push(...await Promise.allSettled(promises));
  }

  return results
    .filter(r => r.status === 'fulfilled' && r.value.isShopify)
    .map(r => r.value.url);
}

Use Cases in Detail

Sales prospecting for Shopify app developers

If you build Shopify apps, your ideal customers are already on Shopify. But the Shopify App Store doesn't give you a list of stores that need your specific solution. The workaround: build a list of websites in your target niche (from directories, Google searches, or industry lists), scan them all through StackPeek, and filter for Shopify. Now you have a qualified prospect list of Shopify store owners you can reach out to with a relevant pitch.

E-commerce market research

Want to know what percentage of DTC fashion brands use Shopify? Scrape a list of brand websites from an industry directory, batch-scan them, and calculate the platform distribution. The same approach works for any vertical: food and beverage, electronics, beauty, home goods. The data feeds into market reports, investor presentations, and competitive strategy documents.

Competitive intelligence

Tracking whether competitors switch platforms is a valuable signal. A company migrating from WooCommerce to Shopify suggests they're investing in e-commerce operations. A company leaving Shopify for a custom build suggests they've outgrown the platform. Set up a weekly scan of competitor URLs and track changes over time.

Agency lead generation

E-commerce agencies that specialize in Shopify need a steady pipeline of Shopify store owners who might need help with design, development, SEO, or migration. Scanning business directories and filtering for Shopify gives you a targeted list. Combine it with SEOPeek data to find Shopify stores with poor SEO scores — those are the ones most likely to need your services.

Why StackPeek Over DIY Detection

You could absolutely build your own Shopify detection script. The manual methods described earlier are not secret. But there are real costs to the DIY approach that aren't obvious until you're maintaining it in production:

StackPeek isn't the only API option, though. Let's compare pricing so you can make an informed choice.

Pricing: StackPeek vs Wappalyzer vs Building Your Own

Approach Monthly cost Scans included Maintenance
DIY script $0 (your time) Unlimited High (ongoing)
StackPeek Free $0 100/day Zero
StackPeek Starter $9/mo 5,000/mo Zero
StackPeek Pro $29/mo 25,000/mo Zero
Wappalyzer API $250/mo Varies by plan Zero

For Shopify detection specifically, StackPeek's accuracy matches what you need at a fraction of Wappalyzer's cost. Wappalyzer's larger database of 1,500+ technologies matters when you need to detect niche WordPress plugins or obscure JavaScript libraries. For e-commerce platform detection — Shopify, WooCommerce, BigCommerce, Magento, Squarespace — StackPeek covers them all. For a deeper dive on the differences, see our WhatRuns vs Wappalyzer vs StackPeek comparison.

Detect Shopify stores for free

100 scans per day. No API key. No credit card. One GET request and you know.

Try StackPeek free →

Getting Started in 60 Seconds

  1. Open your terminal and run: curl "https://stackpeek.web.app/api/v1/scan?url=gymshark.com"
  2. Check the response for "name": "Shopify" in the technologies array.
  3. Scale up with the batch scripts above when you need to scan hundreds or thousands of URLs.
  4. Upgrade to Starter ($9/mo) when you exceed 100 scans/day and need higher throughput.

No sign-up required for the free tier. No API key. Just send a request and get results. You can generate social preview images for your own tools with OGPeek, or audit SEO alongside tech detection with SEOPeek.

Frequently Asked Questions

Can StackPeek detect headless Shopify (Hydrogen) stores?

Yes. StackPeek checks for Shopify Storefront API signatures and other headless-specific indicators beyond the traditional cdn.shopify.com check. Detection confidence may be slightly lower for heavily customized headless builds, but the API catches the majority of Hydrogen/Oxygen storefronts.

How accurate is Shopify detection?

For standard Shopify storefronts, detection accuracy is above 95%. The confidence score in the API response tells you exactly how certain the detection is. A score of 0.90 or higher is a strong signal. Scores below 0.70 may indicate a headless setup or partial Shopify usage (e.g., Shopify checkout on a non-Shopify frontend).

Can I detect Shopify Plus specifically?

StackPeek detects Shopify as a platform. Distinguishing between Shopify Basic, Shopify, Advanced, and Shopify Plus is not currently possible through external detection alone, because all tiers share the same infrastructure and CDN. Some indirect signals (like checkout customization or certain Shopify Plus-specific scripts) may appear in future updates.

What other e-commerce platforms does StackPeek detect?

In addition to Shopify, StackPeek detects WooCommerce, BigCommerce, Magento, Squarespace Commerce, Wix eCommerce, PrestaShop, and OpenCart. All from the same API request — no extra configuration needed.

Ready to build your Shopify detection pipeline? Start with the free tier and scale from there.

Try the live scanner →  |  Read the API docs →  |  View pricing →

More from StackPeek