PCI DSS is unavoidable if you handle card data. Here's the scope and the essentials, and the safest choice of all ("don't hold it"), in defensive terms.
Hold card numbers yourself — Scope: large
Encryption at rest, access control, monitoring, vulnerability management — all of it lands on you
Tokenise through a compliant payment provider — Scope: small
Design so you never touch the card number and the scope itself shrinks
What it requires (broadly)
Less about one technology than an operating posture: protect sensitive data in the smallest scope, in depth, and keep records.
Protect (encryption, access control)
Encrypt stored data with key management, encrypt data in transit, and enforce least-privilege access control (narrow who may touch card data). Authentication vs authorization is the basis.
Harden (no defaults, vulnerability management)
Eliminate default passwords and weak credentials, and monitor dependency CVEs and patch. Anti-malware included.
Record (logging, monitoring, regular testing)
Keep logs of who did what and when, and monitor. Scan and test regularly to maintain the standard.
The 12 requirements (v4.0.1)
PCI DSS groups 12 requirements under six goals.
| # | Requirement (summarized) |
|---|---|
| 1 | Install and maintain network security controls (firewalls, etc.) |
| 2 | Apply secure configurations to all system components (no default passwords) |
| 3 | Protect stored account data (never keep the security code after authorization) |
| 4 | Protect card data with strong cryptography over public networks |
| 5 | Protect systems from malware |
| 6 | Develop and maintain secure systems and software (patching, payment-page script management) |
| 7 | Restrict access to those with a business need |
| 8 | Identify users and authenticate access (including multi-factor) |
| 9 | Restrict physical access to card data |
| 10 | Log and monitor all access |
| 11 | Test security regularly (vulnerability scans, payment-page tamper detection) |
| 12 | Support information security with policies and programs |
The current version is v4.0.1 (published June 2024). Requirements introduced in v4.0 that became mandatory on 31 March 2025 include authorizing and inventorying the scripts that run on payment pages (Requirement 6.4.3) and a mechanism to detect unauthorized changes to payment pages (Requirement 11.6.1).
How you integrate payments changes your scope
The self-assessment questionnaire (SAQ) an online merchant uses depends on how card numbers pass through its systems.
| Integration | Path of the card number | Main questionnaire |
|---|---|---|
| Redirect to the provider's page, or embed the provider's page (iframe) | Touches neither your server nor your page | SAQ A (fewest items) |
| Your page sends it directly to the provider with the provider's JavaScript or form | Not your server, but your page takes part in the submission | SAQ A-EP |
| Your server receives the card number | Passes through your server | SAQ D (most items) |
In the January 2025 revision of SAQ A, Requirements 6.4.3 and 11.6.1 were replaced with an eligibility condition: the merchant must confirm its site is not susceptible to script attacks that could affect its e-commerce systems. Even the smallest-scope option still requires you to look after the site that sends customers to payment.
How it relates to Japan's rules
| Item | PCI DSS | Installment Sales Act and Credit Card Security Guidelines |
|---|---|---|
| Nature | Industry standard from the card brands (required by contract) | A law (Article 35-16) and its practical guide |
| What e-commerce merchants must do | Meet the requirements for their scope | Non-retention or PCI DSS compliance, plus vulnerability measures (since v6.0) and EMV 3-D Secure (cardholder authentication) |
| Payment-page tampering | Requirements 6.4.3 and 11.6.1 | Five vulnerability measures (admin-panel access restriction, vulnerability assessments, etc.) |
Non-retention alone does not stop malicious code planted on a payment page. That is why Japan's rules now require vulnerability measures on top of non-retention.
Real cases
- APORITO online store (RIZAP) (2026): a malicious script was planted on the store, and card numbers, expiry dates and security codes entered between 1 May and 5 August may have been exposed. This kind of theft happens on the input page even when card data is not stored
- ShopServe (E-store) (2026): malicious code ran on the servers and up to 8.85 million buyer records (cumulative) leaked. Card data was limited to partial numbers (first 6 and last 4 digits) and expiry dates; security codes were not held. Limiting what was stored limited the damage
- British Airways (2018): card details entered on its website's payment pages were sent to a third party, affecting about 429,612 people. The UK authority fined it GBP 20 million under GDPR in 2020 (→ GDPR)
How to check your own online store
Find out where card numbers travel
Check your contract or the provider's dashboard for the integration type (redirect, iframe, JavaScript, or your own server). If unsure, ask your payment provider which SAQ applies to you.
List the scripts on your payment pages
List the external scripts loaded on the payment page and the order pages before it, and remove those you don't need. The Site Transparency Checker shows where a page can send data.
Restrict which scripts can load
Use a Content-Security-Policy (CSP) to limit where scripts can load from and where data can be sent. Check your current setup with the CSP Builder / Checker and the Security Headers Check.
Review the admin panel and tamper detection
Restrict the IP addresses that can reach the admin panel and turn on multi-factor authentication. Set up alerts when payment-page files or content change (tamper detection).
Look for card numbers or security codes left behind
Check order data, access logs, error logs, support emails and backups for recorded card numbers or security codes.
The safest choice: shrink the scope
This site's view: the best defense is not holding it
Meeting each PCI DSS requirement one by one is a lot of work; what helps most is the design where you don't hold card numbers in your own system at all. Hand card processing to a compliant provider and work only with a tokenized reference, and your environment's scope shrinks sharply. Same principle this site follows: with sensitive data, don't hold it, don't place it, minimize it. That's both compliance and the most effective defense. Check that card-handling screens and traffic never land in public directories or logs (→ keep secrets out of public directories).
The related idea
Widening your scope (hard)
- storing card numbers in your own DB
- many servers and people can touch card data
- audit and encryption surface grows, burden balloons
Shrinking your scope (safe)
- hand card processing to a compliant provider
- you only work with a tokenized reference
- scope minimized, leak risk shrinks with it
Read next
- Basics: authentication vs authorization (least-privilege access) · public-key crypto (encryption basics)
- Practice: keep secrets out of public directories · monitoring dependency CVEs
- Related: GDPR (personal-data protection) · OWASP Top 10 · the history of security (timeline)
Sources
- PCI Security Standards Council (official): pcisecuritystandards.org
- PCI SSC — "Just Published: PCI DSS v4.0.1" (June 2024): blog.pcisecuritystandards.org
- PCI SSC — "Important Updates Announced for Merchants Validating to Self-Assessment Questionnaire A" (January 2025): blog.pcisecuritystandards.org
- Japan Consumer Credit Association — Credit Card Security Guidelines (Japanese): j-credit.or.jp
- UK ICO — British Airways Penalty Notice (16 October 2020): ico.org.uk