November 10, 2026 · 9 min read

Shopify Checkout Phishing Redirects: How the Attack Works, How to Detect It, and the Controls That Stop It

Shopify checkout phishing redirects hijack the checkout click via compromised app code, not Shopify itself.

Shopify Checkout Phishing Redirects: How the Attack Works, How to Detect It, and the Controls That Stop It

Checkout phishing redirects on Shopify do not come from a flaw inside Shopify's hosted checkout. They come from JavaScript that runs on your storefront, delivered through a compromised third-party app, that intercepts the checkout button click before Shopify's checkout URL ever loads. The October 2026 wave, which hit at least four confirmed apps (HulkApps Product Options, Selleasy, Swym Wishlist Plus, and Qikify), is the clearest public proof of exactly how that chain works.

Key takeaways

  • The malicious script ran on the storefront, not inside Shopify's checkout sandbox, so PCI compliance on the checkout itself was irrelevant.
  • The redirect fired only once per browser session, which is why merchants testing their own store saw a clean checkout.
  • In the HulkApps case, the payload (~22.7 KB of attacker JavaScript) was returned by the app's own API under a custom JavaScript configuration field, not by editing any theme file.
  • On October 20, 2026, Shopify pushed a storefront redirect warning and published "Securing your app, together" requiring app developers to act that week.
  • Script tags (the older injection path) are already blocked from creation as of October 1, 2026, with full removal on March 1, 2027; app embeds are now the main surface to audit.

The attack chain, step by step

1. Credential or configuration compromise at the app vendor

In every confirmed October 2026 case, attackers did not break into Shopify. They compromised app developer credentials, CI/CD pipelines, or the app's own configuration APIs. Selleasy (Logbase) described it as "a deliberate, planned cyber attack" that placed an unauthorized script into some stores on October 13 for roughly 7 hours. HulkApps said "an exploit introduced unauthorized configurations into the Hulk Product Options app." In the Qikify case, confirmed as early as July 22, 2026, malicious code was injected into HTML content fields in app settings.

The common thread: each app had a field that accepted arbitrary content (custom JavaScript, HTML label text, translation fields) which was later rendered on the storefront without sanitization.

2. Script delivery through the app embed or script tag

Apps put JavaScript on Shopify storefronts via two routes: app embeds (injected by Shopify's theme infrastructure just before the closing </body> tag) and script tags (a legacy API method). In the HulkApps case, developer Roman Zipp traced the redirect to the app's theme extension, which fetched configuration including the payload from HulkApps' own API. The storefront loaded the app code from Shopify's CDN, which made it look completely legitimate to any network-layer inspection.

3. Checkout button interception

Once the script was on the page, it attached an event listener to the checkout button (or the form submit event). When a shopper clicked Checkout, the script canceled the default navigation and sent the browser to an attacker-controlled domain such as biliing[.]top or checkout-guard[.]top. The lookalike page collected card details, then forwarded the shopper to the real Shopify checkout so the order completed normally.

The script tracked which browsers it had already redirected using sessionStorage. One reported key was __ctf_. Because it only fired once per session, any merchant who opened the store in their usual browser saw a clean checkout on every test.

4. The card data leaves before Shopify sees anything

Shopify's hosted checkout is an isolated system; storefront app code has no access to it. But that isolation only protects data entered inside checkout.shopify.com. When the browser is sent to a different domain before checkout loads, the shopper types their card into a page Shopify never controlled. By the time the order lands in the Shopify admin looking normal, the attacker already has the card number.

Detection: how to verify your store right now

The single most important thing to understand is that searching your theme files will not find this. The malicious code lived in the app's configuration, not in theme.liquid or any .js asset you can grep.

Manual checkout test (the right way)

  1. Open a fresh incognito or private window (a new session, not one you have used before).
  2. Add a product to the cart.
  3. Click Checkout and immediately watch the address bar.
  4. The URL must become checkout.shopify.com/... or your store's custom checkout domain. Any other domain is a red flag.
  5. Repeat from a mobile device on a different network.

Using your everyday browser is useless because sessionStorage persists across tabs. Incognito clears it.

Browser DevTools check

Before clicking Checkout, open the Network tab in DevTools and filter by Fetch/XHR. Click Checkout. If the browser fires a navigation event to a non-Shopify domain before the checkout URL resolves, you will see it here as a 302 or a direct location change.

Also open Application > Session Storage and look for suspicious keys. The __ctf_ key was reported as the marker used to track already-redirected sessions.

Enumerate your app embeds

In the Shopify admin, go to Online Store > Themes > Customize, then open the App embeds panel. Every embed listed here runs JavaScript on every storefront page. For each one, ask:

  • Do I recognize this app and do I still need it?
  • When was the app last updated, and did that coincide with any support reports?
  • Does the app's vendor have a published security contact and an incident history page?

Flag any embed belonging to an app you have already uninstalled. Embeds can persist after an app is removed if the theme was not cleaned up.

Check the shopify app security check command

If you are building or maintaining an app (not just a merchant), Shopify CLI 4.9.0, released October 8, 2026, added shopify app security check. It scans your app codebase, its extension configuration, and its dependencies for known vulnerability patterns. Run it with:

shopify app security check

Note that its OPEN_REDIRECT rule covers auth callback redirects, not storefront checkout redirects specifically. It is a first-pass check, not a complete storefront audit.

The attack surface comparison

Injection pathHow attacker uses itVisible in theme files?Removed by Shopify timeline?
App embed (theme extension)Fetches malicious config from vendor API at page loadNoNo (embeds stay; must be audited manually)
Script tag (legacy API)Loads JS file hosted on attacker CDNNoYes: blocked from October 1, 2026; fully removed March 1, 2027
Theme file edit (direct admin access)Injects <script> or redirect logic into theme.liquidYesRequires separate admin credential compromise
App config field (custom JS / HTML field)Stores payload in app settings, rendered server-side or via APINoDepends on app vendor sanitizing input

The controls that actually reduce risk

For merchants

  • Minimize app count ruthlessly. Every app embed is code running in front of every shopper. On one 10,000+ SKU catalog I maintain, we went through a full app audit after October and removed six embeds from apps that were no longer active. The storefront got faster and the attack surface shrank.
  • Enable two-factor authentication on your Shopify Partner and admin accounts. Several incidents traced back to compromised vendor credentials. If your own admin is compromised, an attacker can edit theme files directly.
  • Watch for the new redirect prompt. Since October 20, 2026, Shopify storefronts ask shoppers to confirm before navigating to a site outside the store. A later October 23 update narrowed this to sites Shopify identifies as suspicious or malicious. This adds friction at exactly the moment a redirect attack depends on, but it is not a block, and a motivated shopper may click through.
  • Report suspicious redirects to partner-security-reports@shopify.com with timestamps, the destination URL, and a network log.

For app developers

Shopify's "Securing your app, together" post on October 20, 2026 marked "Action required" listed eight steps. The most important ones technically:

  • Treat all data your app stores as untrusted, including data from your own API. If your app has a field that accepts HTML or JavaScript (custom button text, translation fields, label overrides), you must escape or sanitize that content before it is ever included in a rendered response. This is the exact path the Qikify and Swym incidents used.
  • Move to expiring access tokens. Shopify has required expiring offline access tokens for new public apps since April 1, 2026, and has signaled this will become mandatory for all public apps. A stolen long-lived token can persist undetected; a short-lived one limits the blast radius.
  • Enable two-step authentication on every account that can touch your app: Shopify Partner, CDN, hosting, CI/CD, DNS, and email. The October incidents are consistent with credential compromise at the vendor level.
  • Add IP restrictions to your API keys so tokens only work from your own server IP ranges, reducing the value of a stolen credential to an attacker who is not on your infrastructure.
  • Sanitize app configuration fields server-side. If your app lets merchants enter custom JavaScript, treat that field exactly as you would user-generated content: strip or encode it before it is returned from your API, and never eval() or innerHTML the value client-side without validation.

The CSP angle (mostly for Hydrogen storefronts)

Liquid storefronts do not give merchants a practical way to set a strict script-src Content Security Policy because app embeds are injected dynamically by Shopify's infrastructure. On a Hydrogen storefront you have full control. Shopify's Hydrogen package exposes createContentSecurityPolicy from @shopify/hydrogen, which generates a nonce-based CSP and a provider component:

import { createContentSecurityPolicy } from '@shopify/hydrogen';

// In entry.server.tsx:
const { header, NonceProvider } = createContentSecurityPolicy({
  shop: { checkoutDomain: 'checkout.mystore.com' },
});
responseHeaders.set('Content-Security-Policy', header);

A navigate-to CSP directive would be the right tool to block outbound navigations to unknown domains at the browser level. At the time of writing, navigate-to has limited browser support, but adding a strict script-src with nonces is the strongest available layer on a headless store.

What Shopify's platform changes do and do not cover

  • Script tag deprecation (October 1, 2026 / March 1, 2027): removes one delivery path, but app embeds, the vector used in October, are not being removed. They remain the primary supported mechanism for apps to inject storefront code.
  • Redirect warning (October 20, 2026): prompts shoppers before off-site navigation. Friction, not a block. Sophisticated users may still click through on a convincing page.
  • shopify app security check (CLI 4.9.0, October 8): static analysis on app code, good for catching OWASP-class issues in your own codebase, does not monitor live storefronts.
  • Higher App Store security requirements (announced October 27, 2026): coming, no enforcement date published as of the time of writing.

The gap that none of these fully closes: an app embed that fetches its own configuration at runtime can always retrieve new malicious code after any static scan passes. The only durable control is requiring app vendors to sign or hash their remote configuration payloads and having the storefront extension verify the signature before executing anything fetched from the vendor API. No Shopify app infrastructure enforces this today.

Conclusion

The October 2026 checkout hijack wave worked because Shopify's app model lets third-party code run on the storefront with broad DOM access and no integrity verification of remotely fetched configuration. That is not a bug in Shopify; it is a deliberate extensibility trade-off. Understanding it at this level is what separates a reactive incident response from a proactive defense posture. For a worked example of how to audit an installed app stack from first principles, see my case studies. For definitions of terms used here (app embed, script tag, theme extension), see the glossary.

Frequently asked questions

Was Shopify itself hacked in the October 2026 checkout phishing attack?

No. Shopify's own systems and hosted checkout were not breached. Attackers compromised credentials or configuration endpoints at individual third-party app vendors, then used those apps to deliver malicious JavaScript to merchant storefronts.

Why did testing checkout in my own browser show a clean page even when my store was affected?

The redirect script used sessionStorage to track which browsers it had already redirected. It fired only once per session. If you tested checkout in a browser you had used before, the script stepped aside and let you through to the real checkout. Always test in a fresh incognito window on a different device or network.

Does removing the affected apps from my store guarantee the redirect is gone?

Uninstalling an app stops new code from loading through it, but app embed blocks can persist in theme files after an app is removed. After uninstalling any suspect app, open the App embeds panel in the theme editor and confirm no orphaned embed from that app remains enabled.

Seven years of Shopify, on one page.

Roles, projects, stack and certifications are on the resume.

Resume Download PDF LinkedIn