How To Tell What Ecommerce Platform A Site Is Using: Technical Detection Protocol
Determine what e-commerce platform any website uses by combining automated technology profilers with manual source code analysis, HTTP response header inspection, and DNS record tracing. Identifying unique JavaScript window objects, server cookies, asset directory structures, and canonical CNAME records allows technical analysts to reverse-engineer any online store's backend stack within minutes.
E-Commerce Platform Reverse Engineering Checklist
Uncovering an online store's underlying commerce engine requires systematically analyzing client-side render files, network traffic, and domain configurations. Before initiating an audit, assemble the appropriate diagnostic environment to ensure high-fidelity detection across both traditional monolithic and modern headless architectures.
- Essential Diagnostic Equipment & Software: Chrome or Firefox Developer Tools (F12 suite), command-line terminal utilities (curl, dig, or nslookup), browser extension profilers (Wappalyzer, BuiltWith, or WhatRuns), and network proxy logs.
- Prerequisite Technical Standards: Working knowledge of the Document Object Model (DOM), HTTP request/response header operations, DNS resource record types (specifically CNAME and A records), and standard web directory architecture.
- Benchmark Operational Parameters:
- Estimated Audit Time: 2 to 5 minutes per domain for monolithic systems; 5 to 15 minutes for decoupled/headless setups.
- Direct Tooling Cost: $0 (utilizing open-source command-line tools and native browser developer suites).
- Expected Accuracy Rate: Exceeds 98% when combining multi-layer manual verification methods.
Step-by-Step E-Commerce Platform Detection Workflow
Step 1: Execute Rapid Automated Fingerprinting
Begin your investigation by running automated web technology profilers. These applications cross-reference a target domain's public footprint against vast databases of platform signatures, scripts, and stylesheet conventions.
- Open the target website in a clean browser profile free from script-blocking extensions.
- Launch your preferred browser extension profiler (such as Wappalyzer or BuiltWith) from the browser toolbar.
- Review the categorized breakdown under the E-Commerce or Web Shops section. The extension scans for global JS variables, known plugin directories, and specific inline framework indicators.
- Record the detected core platform, content delivery network (CDN), and active third-party analytics integrations.
Pro-Tip: Automated profilers rely heavily on static signatures. If a site uses custom minification, obfuscation, or a custom frontend proxy, extensions often fail or return false positives. Always validate automated findings using manual inspection steps.
Step 2: Inspect Document Source Code and DOM Footprints
When automated tools return ambiguous results, manual source code inspection reveals low-level frameworks, script loaders, theme declarations, and unique DOM element attributes.
- Right-click on any non-media area of the store's homepage and select View Page Source, or press Control+U (Command+Option+U on macOS).
- Open the page search function using Control+F (Command+F on macOS).
- Search for platform-specific metadata tags and script initializations by executing queries for key terms:
- Search for Shopify.theme or cdn.shopify.com to identify Shopify instances.
- Search for wp-content/plugins/woocommerce or generator content="WooCommerce" to identify WooCommerce stores.
- Search for mage/cookies or Mage_Core to identify Adobe Commerce (Magento) deployments.
- Search for stencil-config or cdn11.bigcommerce.com to identify BigCommerce stores.
- Search for demandware.static or dw.ac to identify Salesforce Commerce Cloud (Demandware) architectures.
- Open the live Browser Console (Control+Shift+J or Command+Option+J) and enter specific global window object queries. Type window.Shopify, window.Magento, or window.bcPay into the prompt and press Enter. If the console returns an instantiated object rather than undefined, the underlying engine is confirmed.
Warning: Monolithic theme files are often modified during custom agency builds. Do not rely solely on meta generator tags, as developers frequently strip these for performance optimization or security hardening.
Step 3: Analyze Network HTTP Headers and Cookie Signatures
E-commerce backends emit distinct cryptographic tokens, session variables, and custom server response headers during the HTTP handshake process. Inspecting network traffic bypasses client-side frontend masking.
- Open Developer Tools (F12) and switch to the Network tab.
- Ensure the Preserve log checkbox is enabled, then refresh the browser page (Control+R or Command+R).
- Click on the primary domain document request (typically the top entry under the Name column) and select the Headers sub-tab.
- Inspect the Response Headers section for proprietary operational headers:
- Shopify sites emit x-shopify-stage, x-sorting-hat, or x-storefront-renderer-rendered headers.
- BigCommerce sites return x-bc-store-id or x-bc-apiversion headers.
- Salesforce Commerce Cloud outputs x-dw-request-id or x-cq-squeaks headers.
- Switch to the Application tab (or Storage tab in Firefox), expand the Cookies section, and select the target origin URL.
- Search the cookie key list for mandatory session flags:
- WooCommerce stores set woocommerce_cart_hash, woocommerce_items_in_cart, and wp_woocommerce_session_.
- Magento instances generate frontend, frontend_cid, or PHPSESSID with Magento-style payloads.
- Shopify sets _shopify_s, _shopify_y, _shopify_m, and _y tracking IDs.
- SAP Commerce Cloud (Hybris) typically issues JSESSIONID paired with route parameters specific to Hybris clusters.
Step 4: Audit URL Routing Architecture and Static Asset Paths
Most e-commerce engines enforce strict default URL routing patterns for core commerce operations, including user carts, catalog taxonomy, checkout paths, and static asset storage paths.
- Navigate through the site to a product category page, add an item to the shopping cart, and proceed toward the checkout interface.
- Examine the address bar structure at each stage:
- Shopify forces product URLs into /products/product-name and collections into /collections/category-name. The checkout flow redirects to checkout.shopify.com or routes through a native /checkouts/c/ subpath.
- WooCommerce defaults to catalog URIs like /product/product-name and /product-category/category-name, with cart interactions loading on a dedicated /cart/ or /checkout/ WordPress page structure.
- BigCommerce standardizes catalog structures using /products/ or custom slugs, but distinctively processes cart routes via /cart.php and checkout interactions via /checkout.
- Squarespace processes static shop operations using paths ending in /cart or asset calls mapped directly to static1.squarespace.com.
- Inspect image sources by right-clicking a product thumbnail and choosing Inspect. Examine the src attribute of the image element:
- Shopify images load from //cdn.shopify.com/s/files/
- BigCommerce images route through //cdn11.bigcommerce.com/
- Magento assets typically route through /media/catalog/product/
Step 5: Query DNS Records and CNAME Mapping
For stores using headless architectures—where a custom React, Vue, or Next.js frontend completely masks the client-side code—querying Domain Name System (DNS) records exposes the authoritative infrastructure routing traffic.
- Open your terminal interface (macOS Terminal, Linux Shell, or Windows Command Prompt).
- Execute a CNAME record lookup on the target domain using the dig utility:
dig CNAME store.example.com +short(replace store.example.com with the target host). - If using Windows Command Prompt without dig installed, run
nslookup -type=CNAME store.example.com. - Trace the resulting canonical name record mapping:
- CNAME entries resolving to shops.myshopify.com confirm a Shopify backend integration.
- CNAME entries pointing to store.mybigcommerce.com verify a BigCommerce engine.
- CNAME aliases referencing edge.commercelayer.io, dn.commercetools.com, or hosted.nacelle.com indicate a modern headless, composable commerce configuration.
Pro-Tip: If the primary apex domain uses a direct A Record pointing to an IP address (such as Cloudflare or AWS IP ranges), target the checkout or account subdomains (e.g., checkout.example.com or account.example.com) via DNS lookup to isolate the backend endpoint.
How to Tell What Ecommerce Platform a Site is Using? | Nomadic Soft
Structural Footprints of Major E-Commerce Engines
The following table provides an authoritative breakdown of technical markers used to distinguish between top-tier e-commerce engines during manual code, network, and infrastructure audits.
| Platform Name | Distinct HTML/JS Signatures | HTTP Cookie Indicators | Canonical URL Patterns | CNAME / Host Signatures |
|---|---|---|---|---|
| Shopify | window.Shopify, cdn.shopify.com, boosterMicrodata |
_shopify_s, _shopify_y, _shopify_m |
/products/, /collections/, /checkouts/ |
shops.myshopify.com |
| WooCommerce | wp-content/plugins/woocommerce, wc-cart-fragments |
woocommerce_cart_hash, woocommerce_items_in_cart |
/product/, /product-category/, /cart/ |
Standard Web Host / WP Engine |
| Adobe Commerce (Magento) | mage/cookies, Mage_Core, requirejs-config.js |
frontend, frontend_cid, STORESESSID |
/catalog/product/view/, /checkout/cart/ |
Custom Server / Adobe Cloud |
| BigCommerce | window.bcPay, stencil-config, cdn11.bigcommerce.com |
SHOP_TOKEN, SESS_, stencil_ |
/cart.php, /checkout, /categories/ |
store.mybigcommerce.com |
| Salesforce Commerce Cloud | demandware.static, dw.ac, dw.storefront |
cqcid, dwsecure_, dwsid |
/*.html with dwvar_ query parameters |
production.*.demandware.net |
| SAP Commerce Cloud (Hybris) | ACC.config, yacceleratorstorefront |
JSESSIONID, acceleratorSecureGUID |
/-p-, /-c-, /cart |
Custom Enterprise Host / SAP |
| Squarespace Commerce | Static.SQUARESPACE_CONTEXT, static1.squarespace.com |
crumb, SS_MID, SS_ANALYTICS_ID |
/shop/, /cart |
ext-cust.squarespace.com |
Edge Case Diagnostics and Detection Failures
Scenario 1: Headless E-Commerce Masking (Decoupled Frontends)
- Root Cause: The merchant uses a modern Jamstack frontend framework (e.g., Next.js, Nuxt.js, or Gatsby) hosted on Vercel or Netlify, consuming backend e-commerce APIs via GraphQL or REST without emitting traditional backend HTML markup.
- Actionable Fix: Open browser Developer Tools and select the Network tab. Filter network activity by Fetch/XHR. Trigger a cart interaction (such as selecting a product variant or adding an item to the basket) and inspect the destination endpoint URLs of outgoing POST or GraphQL operations. Look for API targets such as myshopify.com/api/graphql, api.bigcommerce.com, api.commercetools.com, or api.swell.is.
Scenario 2: Strict CDN Reverse Proxies Stripping Server Headers
- Root Cause: Enterprise edge protection layers like Cloudflare Enterprise, Fastly, or Akamai scrub outgoing HTTP response headers, stripping proprietary server identifiers like x-shopify-stage or x-powered-by flags.
- Actionable Fix: Inspect static media asset endpoints rather than primary HTML pages. CDN rules rarely modify original media storage paths. Inspect product image URLs, CSS bundle source maps, or site manifest files (manifest.json). Search specifically for unstripped CDN origins like cdn.shopify.com, media.magento.com, or commerce cloud storage buckets.
Scenario 3: Legacy Migrations Yielding Dual-Platform Artifacts
- Root Cause: A store recently migrated from WooCommerce to Shopify (or vice versa), but residual code, domain redirects, or third-party tracking scripts from the old framework remain embedded in the site layout, causing diagnostic tools to return conflicting platforms.
- Actionable Fix: Determine which platform currently handles the active transactional engine by executing an actual checkout flow up to the payment entry screen. Inspect the final domain host handling the payment processing session. The platform that manages cart state persistence and checkout tokenization is the true active underlying engine, regardless of legacy scripts on marketing pages.
Frequently Asked Questions
Can a website completely hide what e-commerce platform it uses?
While merchants can remove frontend generator tags and route traffic through custom headless frontends, it is nearly impossible to hide an e-commerce platform completely. Payment gateway integrations, security tokens, asset paths, and checkout logic must eventually communicate with the platform backend, leaving identifiable network traffic signatures during cart or checkout interactions.
How can I identify custom-built e-commerce platforms?
A platform is likely custom-built if manual inspection yields no matching global variables (like Shopify or Magento), HTTP response headers reference standard framework runtimes (such as Laravel, Ruby on Rails, Django, or ASP.NET), and the site displays non-standard URL structures without any common CDN asset paths.
Are browser extensions like BuiltWith or Wappalyzer always accurate?
No, browser extensions rely on surface-level static rules and known file path patterns. They frequently mistake third-party apps or legacy tracking pixels for the main e-commerce platform, and they regularly misidentify custom headless frontends. Always confirm automated results with manual DOM, header, and network inspections.
Why does a website display signatures for two different e-commerce platforms?
This occurs when a business uses a hybrid architecture. For example, a merchant might run its main content website on WordPress while embedding Shopify Buy Buttons or routing catalog subdomains to a BigCommerce store. Inspecting the DOM during cart creation and checkout will identify which engine handles the transaction.
How do I specifically identify if a site uses Shopify without using plugins?
Inspect the page source code (Control+U) and search for the term window.Shopify or cdn.shopify.com. Alternatively, open the browser developer console and type window.Shopify. If it returns an active JavaScript object containing theme and store data, the site is running on Shopify.
Elevate Your Competitive Intelligence Audit
Accurately mapping an e-commerce platform's tech stack provides critical leverage for competitive benchmarking, technical SEO audits, and custom software integration planning. Use this technical detection protocol during every site review to dissect underlying architectures, evaluate frontend performance trade-offs, and discover optimization opportunities across any online retail domain.