PCI DSS 4.0 was released in March 2022, replacing version 3.2.1. The transition period ended March 31, 2024 — after which 4.0 became the only active standard. But several of the most significant new requirements were designated as "future-dated," meaning they didn't become mandatory until March 31, 2025. Those requirements are now in force, and two of them specifically target ecommerce checkout pages in ways that affect a large proportion of online merchants.

If you run an ecommerce store with any JavaScript loading on your payment pages — which is essentially every ecommerce site — this is relevant to you. Here's what changed, which merchants are most affected, and what implementation looks like in practice.

Background: What PCI DSS 4.0 Was Trying to Fix

The new checkout-focused requirements address a specific and increasingly common attack vector: Magecart-style JavaScript skimming. In a Magecart attack, malicious JavaScript is injected into a merchant's checkout page — either by compromising the merchant's own code or, more commonly, by compromising a third-party script that the checkout page loads. The malicious script silently captures card details as customers type them and exfiltrates the data to the attacker.

These attacks are particularly insidious because they're invisible to the merchant and the customer. The payment completes normally. The merchant's server is never directly breached. The customer's card data is stolen at the browser level, before it's encrypted and transmitted. Standard server-side security controls don't catch it.

The scale of the problem became undeniable as Magecart attacks compromised thousands of ecommerce sites — including some very large ones — over a multi-year period. PCI DSS 4.0's new requirements are specifically designed to make this attack vector harder to execute and easier to detect.

The Two New Requirements That Matter for Checkout Pages

Requirement 6.4.3 — Script Management for Payment Pages

Requirement 6.4.3 applies to all scripts loaded on payment pages that are delivered to the customer's browser. It requires that merchants:

Maintain an inventory of all scripts on payment pages. Every JavaScript file and inline script that executes on any page where payment card data is entered or processed must be documented. The inventory must include the script's purpose, a method to confirm the script is authorized, and a method to confirm the script's integrity.

Confirm each script is authorized. You need a process for approving scripts before they're added to payment pages and for identifying unauthorized additions. This doesn't mean manual review of every line of code — it means a process for knowing what scripts are supposed to be on your payment pages and detecting when something unexpected appears.

Protect scripts from unauthorized modification. This is implemented technically through Subresource Integrity (SRI) for externally loaded scripts, or through Content Security Policy (CSP) headers that restrict which scripts are allowed to execute on your payment pages.

Who this affects most: Merchants with custom checkout pages that load third-party scripts — analytics, chat widgets, A/B testing tools, marketing pixels, and similar third-party JavaScript that may not be payment-related but executes on the checkout page. Merchants using fully hosted payment pages (where the checkout is on the processor's domain, not the merchant's) are largely shielded from this requirement — the processor's page is their compliance responsibility.

Requirement 12.6.3.1 — Security Awareness Training Update

This requirement mandates that security awareness training specifically acknowledge phishing and social engineering threats, with training reviewed and updated at least annually to reflect the current threat landscape. Less directly relevant to checkout page implementation but worth noting for merchants updating their compliance documentation.

What SRI and CSP Actually Look Like in Practice

For most merchants, Requirement 6.4.3 compliance comes down to implementing two technical controls on payment pages:

Subresource Integrity (SRI) is an HTML attribute that lets browsers verify that a remotely loaded file hasn't been tampered with. When you load an external script, you add an integrity attribute containing a hash of the expected file content:

<script src="https://example.com/script.js"
        integrity="sha384-[hash]"
        crossorigin="anonymous"></script>

If the script file at that URL has been modified — by the host, by a CDN compromise, or by an attacker — the hash won't match and the browser will refuse to execute the script. SRI is straightforward to implement for scripts loaded from fixed URLs. It's less practical for scripts that update frequently (like analytics libraries that self-update), which is where CSP becomes the more practical control.

Content Security Policy (CSP) is an HTTP response header that tells the browser which script sources are allowed to execute on a given page. A CSP header for a payment page might look like:

Content-Security-Policy: script-src 'self' https://cdn.cyogate.com https://www.google-analytics.com; object-src 'none';

This tells the browser: only execute scripts from this domain, the CyoGate CDN, and Google Analytics. Any other script — including a malicious script injected by an attacker — will be blocked and a violation report can be sent to a reporting endpoint for detection. CSP is the most comprehensive protection against Magecart-style attacks because it restricts what can execute even if something manages to get injected.

Implementing CSP on an existing checkout page requires an inventory of every script source currently loading on that page — which is also the 6.4.3 inventory requirement. The two controls support each other.

The hosted payment page advantage: Merchants using CyoGate's hosted payment page or Collect.js tokenization have significantly reduced exposure to Requirement 6.4.3. When card data is entered on a page hosted by CyoGate or captured through Collect.js before it reaches your server, the payment page under PCI scope is primarily CyoGate's — not yours. Your checkout pages still warrant script inventory and CSP implementation as good security practice, but the full weight of 6.4.3 compliance falls on the processor's infrastructure rather than yours. If you're currently using a direct API integration that processes card data on your own pages, this is a good time to evaluate whether migrating to Collect.js would reduce your compliance burden.

How This Affects Your SAQ Type

PCI DSS 4.0's new requirements affect SAQ types differently — which matters for your annual compliance process:

SAQ A merchants (fully hosted payment pages, card data never touches merchant systems) have the most limited exposure. The 6.4.3 script management requirements for SAQ A are focused on the scripts on your order confirmation page and any page that might redirect to the hosted payment page — not on the hosted payment page itself. The compliance burden is manageable.

SAQ A-EP merchants (ecommerce with partially outsourced payment, merchant controls the page) have more significant 6.4.3 obligations. Your checkout pages are in scope, your script inventory needs to be comprehensive, and CSP/SRI implementation is expected.

SAQ D merchants (merchants who store, process, or transmit cardholder data directly) face the full weight of all new 4.0 requirements. If you're in this category and haven't assessed your checkout pages against 6.4.3 yet, that's overdue.

Our guide to PCI compliance for small businesses covers the full SAQ type framework and how to determine which applies to your integration.

The Practical Compliance Checklist

  • Identify all pages in your checkout flow where payment card data is entered or where a customer is directed to enter it
  • For each page, generate a complete inventory of all JavaScript loading — both inline scripts and externally loaded files
  • Document the purpose and owner of each script
  • Implement SRI hashes for any external scripts loaded from fixed, versioned URLs
  • Implement a Content Security Policy header that whitelists approved script sources and blocks everything else
  • Set up CSP violation reporting to a monitoring endpoint so unauthorized script injections generate alerts
  • Review the inventory and CSP configuration whenever new third-party scripts are added to checkout pages
  • Update your SAQ documentation to reflect the new controls when completing your annual certification through CyoGate's PCI compliance tool

What If You're Not Yet Compliant?

March 31, 2025 has passed, which means these requirements are technically in force. The practical enforcement consequence for most small merchants isn't immediate — PCI enforcement actions targeting small merchants directly are rare, and the more immediate risk is processor non-compliance fees and increased breach liability rather than direct PCI fines.

That said, the compliance gap is worth closing for reasons beyond the formal requirement. Magecart attacks are real, ongoing, and affect merchants of all sizes. The controls required by 6.4.3 — script inventory, CSP, SRI — are genuinely effective at preventing the attack they're designed to stop. Implementing them protects your customers, reduces your breach liability, and closes the compliance gap simultaneously.

If your checkout integration uses Collect.js or a hosted payment page, the implementation overhead is modest. If you're on a direct API integration with a custom checkout page, this is also a good opportunity to evaluate whether migrating to a hosted or tokenized approach would reduce your ongoing compliance burden while improving security.

Questions about how these requirements apply to your specific integration? Contact us — our team is familiar with the technical requirements across different integration approaches and can point you in the right direction.