Tracing a Shopify Checkout Hijack Through DevTools
A shopify checkout hijack hides from the admin, fires once per browser session, and lives in a vendor config call. Here is the DevTools trail.

A merchant pinged me in late October. Their bank had called one customer about a possible card test. The Shopify admin showed the order was fine: one successful line, no chargeback flag, nothing marked risky, payouts already settled. The customer swore the first checkout attempt had failed with a generic error, and that they'd re-entered the card and the second try went through. The merchant wanted to know if they'd been hacked. I didn't have a good answer for about three hours. Walking back through what I checked, in the order I checked it, is also the best way I've found to teach what a shopify checkout hijack actually looks like from the inside.
Quick answer, before the chase: the store had been fine by the time I looked, because the hijack had already been pulled from the vendor's configuration endpoint. The admin would never have shown anything either way. That is the whole reason a shopify checkout hijack is so unpleasant to investigate, and it is also the thing I now check first.
What I checked first
I did the obvious stuff. I logged into the admin, opened the order, and looked at everything that normally reveals card trouble: the payment method (card, Shopify Payments), the risk score (low), the IP (the customer's country), the fulfilment status (unfulfilled, to be shipped Monday). Nothing had the small triangle icon Shopify uses for suspected fraud. I pulled the Orders CSV for the week and sorted by payment status. Six "pending" orders, all with standard reasons. One cancelled order a week earlier. Nothing weird.
Then I went where I usually go next: the live theme. Online Store, Themes, Edit code. I opened theme.liquid and used the file search for <script src=, then for any domain that wasn't cdn.shopify.com, cdn.shopifycdn.net, or the vendor domains I recognised. I found two: a Klaviyo embed and a GTM container. Both the merchant had set up herself, both known good. I also searched for .top as a TLD on the off chance a bad domain had been written directly into theme files. Nothing.
I checked app embeds. Online Store, Themes, Customize, App Embeds. Eight were enabled. Six I recognised from the merchant's own admin tour; two I asked her about and she confirmed. All looked fine.
So the admin was clean, the theme was clean, and the apps all showed Active. That is where most merchant tutorials on this topic stop. It is also where my first mistake was.
Why that wasn't it
The mistake was assuming the admin's view of the apps is the same thing as the apps' view of the storefront. It isn't. An app's listing in Shopify admin shows you what Shopify knows about the app: the version reviewed and approved by the App Store, the scopes it requested, whether its extension is enabled. It does not show you what the app's own servers are telling the storefront to execute right now.
For roughly five of the six compromised Shopify vendors this autumn, that is where the malicious code lived. Not in the reviewed .js file served from Shopify's CDN. Not in the theme. In a configuration payload the app fetched at runtime from its own API endpoint, delivered as a settings value that happened to contain JavaScript. The payload executes from memory. It does not appear as a file anywhere a merchant can find it in the editor.
Which meant my clean-theme finding was not evidence of anything. I had to actually look at what was running in the browser, not what Shopify thought was installed.
The DevTools pass I should have run sooner
I opened the storefront in a fresh Chrome profile, hit F12, and went to the Network tab with "Preserve log" ticked. Then I did a full checkout: added the merchant's bestseller to cart, clicked through to the cart page, clicked Checkout, and watched the URL bar.
The URL did exactly what it was supposed to: it went straight to the merchant's custom checkout domain. No redirect through anything odd. No biliing.top, no .top TLDs at all, no unfamiliar POST requests to anywhere. I checked Response Headers on every third-party call in the Network pane. Nothing looked off.
I was about to close the laptop when I remembered the detail from the r/shopify thread that broke this story open on October 10 and the follow-up on community.shopify.dev the week after: the hijack fires only once per browser session, then disables itself with a sessionStorage flag. Testing on a browser I had already used to visit the store would have caught nothing even if the store had been compromised at that exact second. The flag was the whole point.
So I opened the Application tab (in Firefox it's Storage), expanded Session Storage, clicked the merchant's domain, and read through the keys. Nothing beginning with __ctf_. Nothing matching __ctf_shim_handoff_done_v1 or __ctf_checkout_txn_v1, which are the two markers the October campaign set. The storage was clean on my fresh profile.
Then, on a hunch, I asked the merchant to open her store on her own laptop and send me a screenshot of her own Session Storage for the same domain. The screenshot came back with __ctf_shim_handoff_done_v1 sitting there, set to "1", from a date sometime in early October. Her browser had been through the fake checkout at least once. The customer whose bank had called was not an isolated case.
Where the trail actually led
At that point I stopped trying to find the malicious script on the live store and started trying to figure out which installed app had been the delivery vehicle during the shopify checkout hijack window her customer's browser had clearly touched. The customer's second-attempt order had been placed through a card form, not Shop Pay, not Apple Pay, not Google Pay. That lines up with every public writeup of this campaign: the fake form only ever appeared for customers who were about to manually type a card number. Accelerated checkouts went straight to the real flow and never saw the redirect at all.
I pulled the merchant's installed app list and cross-referenced it against the vendors that had been publicly confirmed as compromised between July and October 2026. She had one match: a wishlist app from a vendor I recognised, installed about fourteen months earlier, which had been disabled globally by its vendor on October 18 after a second wave of unauthorised activity and quietly re-enabled on October 22. That window lined up roughly with when the customer had attempted the order and been redirected.
I was not going to find the malicious payload on the live store. The vendor had already revoked the compromised configuration, re-enabled their app, and almost certainly rotated whatever credential let an attacker into their internal tool in the first place. What I had was the fingerprint on the merchant's own browser, a plausible delivery vehicle in her app list, and a timing match.
Roman Zipp's original write-up on October 10 is the piece of research that walked through the technical mechanism end to end. He traced the HulkApps variant by setting a breakpoint on addEventListener in DevTools, catching a click handler that referenced the string hijack, and following it to a custom_js field in a response from productoption.hulkapps.com/api/v2/store/get_all_relationships. The payload was around 22.7 KB of unminified JavaScript, delivered as what looked like a settings value. The file the app actually loaded from Shopify's CDN was clean.
The reason none of this trips a Content Security Policy violation is that the vendor's domain is already on the CSP allowlist. It has to be: the app needs to call its own backend. Delivering malicious JavaScript as a configuration value from that same backend is not a CSP violation, it is the configuration doing its job.
The one-redirect-per-session thing that fooled every merchant who tested
This is the part I wish I had internalised a week earlier, and it is the single most important operational detail of the whole shopify checkout hijack pattern.
The injected code sets a sessionStorage key after it redirects you the first time. Every subsequent click on the checkout button in the same browser session, same tab, same profile, falls through to the normal flow. You could test twenty times on your own laptop and see nothing wrong, while a shopper opening your store for the first time that day gets routed to the fake form. The hijack is not probabilistic. It is deterministic in a way that happens to excuse the merchant from ever catching it manually.
The fastest reliable test, which I now run first on any store where a customer has reported a "glitchy" checkout:
- Open an incognito window, or a browser profile you have not used on that store before.
- Add a product to the cart.
- Click Checkout. Watch the URL bar from the moment you click until the real checkout page settles.
- If the URL passes through anything that is not your custom checkout domain or
checkout.shopify.com, stop and record it. - Open DevTools, Application tab, Session Storage. Look for anything beginning with
__ctf_. If it is there, the redirect fired on this session.
The second test does not require a fresh browser. If the merchant has already been through the hijack at any point, the key is sitting in whichever browser their customer used, and as long as a shopper hands you a screenshot of their own Session Storage for your domain, you can confirm or rule out whether their session touched the fake form.
If that pattern is turning up on live stores you run and you want someone to look at the DevTools output with you while the merchant is on the phone to their payment processor, the first fifteen minutes with a help1 expert is free and that is usually enough to tell whether you are looking at this specific campaign or at something else that happened to produce a similar customer complaint. The admin won't give you the answer on its own, and the time pressure during BFCM makes guessing expensive.
What I did about it, and what I still don't know
With the merchant, I did three things. I had her uninstall the suspected wishlist app and, separately, open a Shopify Support ticket referencing the October incident and asking whether any residual configuration might still be cached for her storefront (on at least one vendor, the config payload was held in localStorage, so disabling the app did not instantly stop the behaviour). I had her message her payment processor, flag the window between October 14 and October 22 as potentially affected, and ask about monitoring for fraud patterns on orders from that period. And we set up a weekly Monday morning manual test in a fresh profile, which she runs for five minutes before her first standup.
What I still cannot tell her:
- How many of her customers paid on the fake form before entering again on the real one. The attack domain is attacker-controlled, the vendor has since rotated the configuration, and Shopify has not published figures.
- Whether her particular storefront was actually among those served the hijack during her app vendor's exposure window, or whether her customer's browser picked up the
__ctf_flag from a different compromised store. Session Storage is per-origin, so this ought to be ruleable-out, but if any part of the vendor's delivery chain was using a shared origin we'd only find out from the vendor's own post-incident forensics. I have not seen a public one that goes to that level. - Whether another vendor on her app list will get hit next week. The configuration-API vector is not addressed by Shopify's IP allowlist mandate (which takes effect November 20 and is about Admin API traffic, not app vendor backends). If I knew which vendor would be next I would already have told her.
I have written here about one store I looked at and the specific shopify checkout hijack indicators I can show you how to find. I have not tested every variant. Qikify's July incident and Orichi's September one used different timing and were cleaned up before most merchants saw them; the Swym variant used an onerror HTML handler and cached through localStorage rather than sessionStorage, so the detection step needs adjusting slightly. I'd check both storage buckets, not only session.
The broader piece I keep coming back to is the same one that showed up when I wrote about why Shopify's native checkout monitoring watches the storefront, not the checkout in a different context a couple of weeks ago. The admin is not the right surface for detecting a checkout problem that starts outside Shopify's infrastructure. Right now, nothing in Shopify's native tooling will tell a merchant in real time that an app they installed in 2024 just served malicious JavaScript to a shopper this morning.
So my closing question is the one I asked the merchant, and the one I think every store with more than five apps ought to answer before BFCM lands. Open your installed apps list. Which of them has a Custom JavaScript or Custom HTML field in its settings? If you can't tell me, in under a minute, which five accounts in your vendor list could inject code into your checkout page tomorrow morning without triggering a single line of admin red, that is the one to audit today.
Still stuck? Talk to an expert.
Our vetted Shopify experts can fix this issue for you in a live session. $39 per session. Your first 15 minutes are free.