Hijacked Optimizely scripts put a card skimmer on 178 companies' sites. Count what runs on your checkout page
On Monday, code slipped into Optimizely's testing scripts went after card numbers and crypto payments on sites like CNN and Zoom, straight from Optimizely's own servers. Whatever tools you use, count what runs on your checkout this week.

On November 16, 2026, an attacker used a flaw in Optimizely Web Experimentation to plant card-skimming, crypto-swapping code in customers' testing scripts, served from Optimizely's own CDN to 178 organizations' sites. If you use Optimizely, check Project JavaScript for 1688360 and atob(, rotate account tokens and treat cards typed into your own forms that day as exposed. Everyone else: list every script on your checkout, remove the ones that don't need to be there, let the payment provider host card fields, and set a strict CSP.
Monday's code came from a host everyone trusted
On Monday, November 16, visitors to CNN, the BBC, Zoom, Salesforce, IKEA, HSBC and dozens of other well-known sites were served malware. None of those companies wrote it, and as far as anyone has shown, none of their own servers were broken into. It arrived inside a script they had loaded on purpose, from a company they pay: Optimizely.
Optimizely Web Experimentation is an A/B testing tool. Each customer site loads a snippet from Optimizely's servers. Inside it is Project JavaScript, custom code written in the Optimizely dashboard, and it runs on every page. According to Report URI's analysis, the attacker wrote a small loader into that field across many customer projects and left everything else alone. The files still came from cdn.optimizely.com, with Optimizely's own certificate. Report URI found the code in 188 of the 1,611 snippets it checked, belonging to 178 organizations, and says the real number is probably higher.
The loaded script swapped crypto wallet addresses on the page and in the clipboard for the attacker's own. From 13:43 UTC on Monday (8:43 AM Eastern) it also grabbed card numbers, expiry dates and CVVs typed into a site's own payment forms. When it swapped an address next to payment wording, it sent the visitor's cookies and a screenshot of the page back to the attacker. On iPhones and iPads it tried to load two known iOS exploit kits, though nobody has shown a phone being taken over. Report URI counted about $7,000 in crypto sent to the attacker's wallets by Monday afternoon, and says it has no way to see how many cards were taken.
Optimizely posted on its status page at 8:02 PM Eastern on Monday (01:02 UTC Tuesday) that an "unauthorized party exploited a vulnerability in Experimentation," and that it has fixed the flaw, removed the injected code and secured affected accounts. It told BleepingComputer the hole was in the Experimentation account signup flow, and that it ended sessions, revoked tokens and notified affected customers. Most snippets were clean by late Monday afternoon Eastern.
Allowing a vendor's domain doesn't vouch for what it sends
Most security advice about scripts boils down to "only load code from places you trust." That's what these sites did. The problem is that trust in a domain is trust in everything that domain will ever send, including whatever an attacker manages to put there.
Every script on a page runs with the same access as your own code: it can read what customers type, change what they see, and send data anywhere the browser allows. A testing tool, a chat widget, a heatmap and a tag manager all get that access, whether or not they need it.
Report URI tested this directly. It crawled 256 of the affected organizations' own hosts and checked whether their Content Security Policy, the browser rule that says which scripts may load and where the page may send data, would have stopped the payload. The results are in the chart below. Only 24 organizations had a policy that blocked it. Sixty-eight had no policy at all.
The ones that weren't protected mostly had the same blind spot. Listing cdn.optimizely.com didn't help, because the bad code came from there. Two common settings let it straight through: 'strict-dynamic', which trusts anything a trusted script adds, and 'unsafe-eval', which Optimizely's own documentation tells customers to allow for some features. HSBC's policy blocked the main payload, but a backup copy of the code tucked inside the snippet still ran through eval. What saved the 24 was a restrictive script-src that listed only the hosts each site actually needs.
Data in context
Did the affected sites' security policy stop it?
Trust in a domain is trust in everything that domain will ever send, including whatever an attacker manages to put there.
If you use Optimizely, check these today
Optimizely says the code is gone, but a snippet that's clean now may still have served the bad version on Monday. These checks, from Report URI and StepSecurity, don't take long:
- Read the code, not just the file. Open the Project JavaScript in every project and the custom code in every experiment. Look for
1688360, foratob(, and for anything you didn't write. One version hid the attacker's address in base64, so a search for the domain alone misses it. If you serve the snippet from your own domain, check that too; it comes from the same project. - Review who can write to your account. List the users, API tokens and integrations with write access, remove anything you don't recognize, and rotate the rest. Ask Optimizely which of your projects were changed, when, and through which account.
- Treat Monday's cards as exposed if you take them in your own form. If your checkout has card fields that are part of your own page, Report URI's advice is to treat cards entered on November 16 as possibly exposed. Talk to your payment provider about what that means for you, and decide whether to tell customers.
- Rotate anything readable in a cookie. The script could only read cookies not marked HttpOnly. Any session token or secret in one of those should be treated as exposed and rotated.
- Look at your own logs. CSP reports or browser telemetry showing blocked requests to the attacker's server point straight at pages where the loader ran.
Salesforce told BleepingComputer it has disabled Optimizely scripts in preview and production as a precaution. Turning the snippet off for a few days is reasonable if you can't finish the checks quickly. If you browsed affected sites on Monday from an iPhone or iPad, Report URI advises updating to iOS 18.7.3 or later, or iOS 26.3 or later.
If you don't, open your checkout page and count
This is worth doing even if you've never logged into Optimizely. Report URI says the same attacker's earlier injector had already turned up in scripts from Kissmetrics, StorifyMe and Minute Media. Researchers at Hudson Rock, quoted by Help Net Security, say that doesn't prove one operator or one way in, but it does show this isn't a one-vendor problem.
Take a census with whoever looks after your site. It's about half an hour:
- Open your checkout page, and any form that takes card details, logins or personal information, in Chrome. Open DevTools, go to the Network tab, filter by JS, and reload.
- Write down every domain that sends a script. Then go to the Sources tab, where scripts that other scripts loaded show up too.
- Next to each one, write what it's for and who on your team asked for it. If nobody knows, that's a finding.
- Ask one question per line: does this script need to be on the page where a customer types a card number? Most won't.
- Note how each one gets onto the page. Is it hard-coded, added by a tag manager, or added by an app or plugin? That decides who can change it later.
You'll end up with a short list that most businesses have never written down: everyone who can, in practice, run code next to your customers' card details.
How the work moves
A half-hour script census for your checkout
- Open the page
Checkout and any form taking cards, logins or personal details; DevTools, Network, JS, reload.
- List the domains
Every host that sends a script, including ones other scripts pull in (Sources tab).
- Name the owner
What each script is for and who asked for it. Unknown is a finding.
- Ask if it belongs
Does it need to run where a customer types a card number?
- Note the route in
Hard-coded, tag manager, or app/plugin: that decides who can change it.
Keep the payment page boring
With the list in hand, the fixes are less exotic than the attack:
- Take testing and marketing scripts off checkout and payment pages. A/B tests, heatmaps, chat widgets and ad pixels rarely need to be there.
- Let the payment provider own the card fields. The skimmer couldn't read cards typed into a provider's hosted fields in a cross-origin iframe, such as Stripe's or Adyen's. Cards typed into a site's own form fields were fair game.
- Set a strict Content Security Policy for those pages. List only the script hosts the page actually needs in script-src, and only the destinations it should talk to in connect-src. Avoid
'unsafe-eval'and be careful with'strict-dynamic'. Start in report-only mode so you can see what would break. Report URI found that a tight connect-src stopped the card and cookie theft even where the script ran, though not the address swapping. - Mark session cookies HttpOnly. It's usually a one-line setting, and it took cookies out of reach.
- Use Subresource Integrity where the file doesn't change. A fixed library version can be pinned to a hash. As StepSecurity points out, a snippet that rebuilds itself whenever someone edits an experiment can't, so SRI won't cover tools like this one.
- Watch what your pages actually load. Script monitoring tells you when a trusted file changes or a new destination appears. The payload was rebuilt 26 times on Monday alone, per Report URI. A cookie banner doesn't help: as StepSecurity notes, it controls when a script runs, not what's in it.
None of this means dropping your testing or analytics tools. It means deciding where they're allowed to run, and making sure the page where money changes hands has the fewest guests.
Put this into practice
Before you close the tab, send three questions to each vendor whose script is on your list: who on their side, or on yours, can change the code your visitors receive; how would you hear about it if that code changed unexpectedly; and do they ask you to allow 'unsafe-eval' or anything similar in your security policy? The answers tell you which scripts deserve a place near your checkout.
Tracing the scripts on your checkout, moving card entry into the provider's hosted fields, and writing a security policy that doesn't break the site is the kind of storefront work our ecommerce team does. Send us your list and we'll help you decide what stays on the payment page.
Related work: Paddle8.
We build alongside the people doing the work.
Bring us the problem you’re thinking about.