A watchdog for borrowed code

Website Script Monitoring: Change Detection for the Code Your Visitors' Browsers Actually Receive

Most website monitoring asks one question: is the site up? A checkout carrying a card skimmer answers yes, promptly, with a valid padlock. Script monitoring asks a nosier question, every day, of every script: are you still the code we approved?

November 19, 2026 · 10 min read

acmecoffeeroasters.com · script watch, checkout
Desktop and iPhone checks of the checkout page
Same chat widget address, new contents
  1. 09:00 desktop: 9 scripts, every fingerprint matches
  2. 09:00 iPhone: 9 scripts, every fingerprint matches
  3. 10:15 chat widget fingerprint changed; 41 KB to 47 KB
  4. 10:15 new destination: collect.acme-metrics.example
  5. 10:16 vendor release notes list no update today
  6. 10:22 widget tag paused; both versions saved
  7. 10:40 store owner called; response opened
Illustrative: sample script-watch log for a fictional coffee roaster's checkout

The short answer

Website script monitoring loads your pages the way customers do, in real browsers on desktop and iPhone, records every script, its contents and where it sends data, and alerts a person when any of that changes. It catches tampering that server file checks miss, because the change shows up in what the visitor's browser receives. DataCram adds it to a hosting and maintenance plan.

On this page
  1. Up, fast and quietly skimming
  2. Six things we record on every page we watch
  3. The server says the files are clean. The browser disagrees.
  4. What lands in your inbox when a script changes
  5. Alert fatigue and the folder of 400 unread warnings
  6. Audit first, policy second, then the watching
  7. Priced into your maintenance plan, and when to skip it

Up, fast and quietly skimming

Ask a typical monitoring service whether a store is healthy and it checks three things: the page answered, it answered quickly, and the security certificate is valid. A checkout with a skimmer on it passes all three. It loads. It is fast. The padlock is there. The only thing wrong is that a script on the page now sends what customers type to somebody else, and nothing in a standard uptime check looks for that.

Script monitoring looks for that. It is change detection for the code your pages run: a record of every script, what it contains and where it sends data, compared with the previous check, with a person told when something moves. It does not prevent an attack. It shortens the time between a change and somebody noticing, which is exactly the stretch of time an attacker gets paid for.

The Optimizely incident showed how long and how busy that stretch can be. Report URI, a company that sells script monitoring, reported on November 16, 2026, updated the next day, that the first tampered Optimizely script appeared at 04:21 UTC, every infected file was clean by 23:11 UTC, and the attacker rebuilt the payload 26 times in between. A check run once at breakfast would have seen a different file from one run at dinner. Our Optimizely write-up has the full timeline.

Six things we record on every page we watch

We load your pages the way customers do, in real browsers on a desktop and on an iPhone, and record what each one receives. Real browsers matter because many scripts are added after the page opens, by a tag manager or by another script, and appear only when the page actually runs. A tool that reads the raw page source never sees them.

What DataCram's script monitoring records on each watched page, and why a change matters
What we recordWhy a change matters
Script listEvery script that loads, including ones added after the page opensA script nobody added on purpose is the first question to ask about
Contents fingerprintA hash of each script: a short code that changes if even one character of the file changesSame address with different contents is how a trusted vendor's file gets swapped
SizeEach script's file size, check to checkA jump with no release note from the vendor deserves a human look
DestinationsEvery address the page sends data to while it runsA new destination is where stolen form data would travel
Security headersThe Content Security Policy and related headers the page arrives withA loosened policy can wave everything else through
Device differencesWhat loads on desktop compared with iPhoneScripts can behave differently by device, and so can attackers

That last row is not paranoia. Report URI's November 2026 analysis of the same payload found it tried iPhone exploit kits against older versions of iOS. A desktop-only check would have recorded a calmer story than iPhone visitors got. Where your audience is mostly on phones, the iPhone checks are the ones that matter most.

The server says the files are clean. The browser disagrees.

Plenty of security tools watch the files on your server: they record what is there and warn when one changes. That is useful work, and the malware scans in a hosting and maintenance plan do something similar. None of it can see a script that lives on someone else's server. When your page loads a chat widget, the visitor's browser fetches the widget company's file directly. Your server never holds it, so your server never sees it change.

Tag managers widen the gap. A tag manager is a single script that adds other scripts according to settings kept in the vendor's account. Publish a change there and your pages run new code, with no change to a single file you host. If nobody can say who holds the keys to yours, our tag manager cleanup starts there.

Flat sticker of a teal-collared watchdog peering through binoculars from a Hill Country hilltop at a tiny browser window below, agave and sunset behind
Monitoring watches what arrives in the browser, because that is where the change shows up.

The card industry wrote this gap into its rules. PCI DSS requirement 11.6.1, in effect since 2025, asks for alerts to unauthorized changes in payment page scripts and security headers "as received by the consumer browser," according to conference material hosted by the PCI Security Standards Council, read in November 2026. Received by the browser, not stored on the server. Our page on payment page scripts and PCI covers what else those rules ask of a store.

Your server can vouch for the files it holds. The skimmer was never one of them.

What lands in your inbox when a script changes

An alert earns its keep only if a busy owner can read it in a minute and know whether to worry. Ours say what changed, where, and what we already checked, in that order. Here is a sample for a fictional coffee roaster, with an invented vendor address:

  • What changed: the chat widget script on the cart and checkout pages, loaded from cdn.acme-chatwidget.example.
  • How: same address, new contents, and the file grew from 41 KB to 47 KB between the morning check and the next one.
  • New destination: the page now sends data to an address the widget has never contacted before.
  • What we checked: the vendor lists no release today, and the new code reads the card form fields.
  • What we did, as agreed in advance: paused the widget's tag and saved copies of both versions.
  • What we need from you: confirm nobody on your side changed the widget. If card fields were read, your processor and attorney come next.

Most alerts are duller. A vendor ships an update, the fingerprint changes, we read the change, match it to the vendor's release and record it as expected. Either way the entry goes into the log, which is the document an assessor asks to see under 11.6.1 and the one you will want when somebody asks what happened last March.

Alert fatigue and the folder of 400 unread warnings

A business buys a monitoring tool, switches on every rule and gets 400 alerts in the first week. Someone creates an email filter. The filter turns out to be the most effective control in the building: it stops the alerts completely. The skimmer arrives in week nine and lands, politely, in the same folder as the other 3,600.

Much of the noise comes from scripts that change by design: testing tools, tag managers, chat widgets and anything a vendor updates on its own schedule. MDN's Subresource Integrity guide, last modified April 14, 2026, explains why those cannot simply be pinned with a fingerprint the browser enforces: any change to the file, legitimate updates included, breaks the match and the browser refuses to load it. So we set expectations script by script instead.

  • Scripts that should never change are pinned, and any change to them is treated as urgent.
  • Scripts that change on a vendor's schedule are compared with the vendor's releases, and only unexplained changes become alerts.
  • A new destination always alerts, because a new place to send visitors' data is worth a human look even when the reason turns out to be innocent.
  • Payment and login pages are watched more closely than the blog and the about page.
  • Every script has a named owner on your side, so an alert reaches someone who can answer for it.

Audit first, policy second, then the watching

Monitoring works best as the third step. A script audit builds the list of what should be there, so monitoring knows what normal looks like. A content security policy tells browsers to refuse anything not on that list. Monitoring then watches for the changes the policy still allows and the ones nobody planned.

The audit answers

A one-time inventory: what runs on your pages today, who owns each script and whether it should stay.

The policy refuses

Browsers decline scripts and destinations you did not approve, and can report each refusal back to you.

The monitoring notices

A running record that flags when an approved script's contents, size or destinations change, and tells a person.

The policy's reports and the monitoring log feed each other. MDN's Content Security Policy guide, last modified March 22, 2026, describes a report-only mode in which the policy is not enforced but violations are sent to a reporting endpoint. We read those reports alongside monitoring alerts, which is how a strict policy gets written without breaking checkout on launch day. Sites that test page versions in the browser carry more moving scripts than most; server-side testing removes that source of change entirely.

Priced into your maintenance plan, and when to skip it

Script monitoring is added to a hosting and maintenance plan and quoted with your estimate. We do not publish a separate monthly price for it, because the work depends on how many pages and scripts we watch. Plans start from $55 a month and, per that page, cover managed hosting, updates checked on a staging copy, tested off-server backups, security monitoring and small changes. Setting script monitoring up, including the audit it depends on, is from $575, depending on complexity, with a written estimate before work starts.

We respond the same business day during the hours on our contact page. We do not promise night or weekend response, so plan around that if most of your sales happen after hours, and make sure your browser policy is doing the refusing while nobody is reading alerts.

Skip monitoring if your site has no forms, no logins, no checkout and three scripts you can name from memory. A free website health check and a report-only policy will tell you more than a contract would. If you have already found a changed script, monitoring is for later: start with script compromise response. The rest of this section is on the website security hub, and older infections go to malware removal. DataCram is a San Antonio web studio, building since 1999. Our work is public, and the phone number is (210) 346-0848.

Questions owners ask about website security

Uptime monitoring asks whether a page loads and how fast. Script monitoring asks whether the code on the page is still the code you approved: which scripts load, what they contain and where they send data. A skimmed checkout can be perfectly up and fast, so an uptime check alone will not notice it.

Not if the plugin only checks files on your server. A script loaded from a vendor's server never passes through your files, so its changes are invisible to a file check. Server-side plugins still do useful work. Script monitoring covers what the visitor's browser receives, the wording PCI requirement 11.6.1 uses.

Because scripts can behave differently by device, and attackers know it. Report URI's analysis of the November 2026 Optimizely payload found it tried exploit kits aimed at older iPhones. A desktop-only check would have missed what those visitors received. We run both and compare them.

No. It detects change and tells a person; it does not block anything. Blocking is the job of a content security policy, which tells browsers to refuse scripts and destinations you did not approve. Used together, the policy narrows what an attacker can do and monitoring shortens the time before someone notices.

The schedule is set by page in your estimate. Checkout and login pages are checked more often than content pages, and the plan accounts for how often your scripts change by design. No schedule closes the gap between checks entirely, which is why we pair monitoring with a browser policy that refuses unapproved code.

Confirm whether anyone on your team or the vendor made the change. If nobody did, save a copy of the changed script before removing it, then rotate the logins that could have changed it. If it touched card or login fields, call your processor, attorney and insurer. Our script compromise response page sets out the order.

Keep reading

Free · No obligation

Put a watchdog on your checkout

Tell us which pages take payments or logins and roughly what scripts they load. We reply the same business day with what we would watch and a written estimate.

Which of these sounds like you? (pick any)

Rather talk now? Call (210) 346-0848.

CallGet a quote