Free cardholder data discovery tools do exist: ccsrch, PANhunt, Cornell's Spider and its descendants, the Presidio library and pdscan all search for card numbers at no cost. They are good at finding stray primary account numbers (PANs) in files and, with more effort, in data stores. They cannot, by themselves, prove that no cardholder data is stored anywhere. That proof comes from the scan plus the evidence you build around it.

Key takeaways

  • Free scanners find PAN-like strings using pattern matching and the Luhn check, so they produce both false positives and misses.
  • Of the 2008-era trio, ccsrch lives on through forks, the Senf download is now dead, and Spider survives mainly as copies and derivatives.
  • PANhunt is the simplest current option for Windows and Linux file shares, and Presidio or pdscan suit text pipelines and data stores.
  • A scan with zero hits shows only that the tool found nothing in the places it looked, so record coverage, method and exclusions with the result.
  • Free tools stop being enough when you have many hosts, databases, cloud storage, or a service provider's six-month scope confirmation cycle.

Why scan for unencrypted card numbers at all?

Because PCI DSS scope depends on where card data actually sits, not where your diagram says it sits. Requirement 12.5.2 requires you to document and confirm PCI DSS scope at least once every 12 months and after significant change to the in-scope environment. Service providers must do the same confirmation every six months under 12.5.2.1. A scan is the practical way to test the claim that card numbers exist only in the systems you've declared.

The standard doesn't dictate a tool. PCI DSS doesn't mandate a particular tool, but it's hard to confirm locations outside the cardholder data environment (CDE) with confidence without some form of discovery. The guidance for 12.5.2 in PCI DSS v4.0.1, published in the PCI SSC Document Library, says a data discovery tool or methodology can be used to identify all sources and locations of account data. If you are a merchant who says you never store card numbers, the scan is the supporting exhibit for that statement. It is also the question an assessor asks first: how do you know?

Two storage rules make the stakes concrete. PAN must be unreadable wherever it is stored (Requirement 3.5.1). Sensitive authentication data, including full track data, can't be retained after authorization even if encrypted (Requirement 3.3.1). Typical finds are an exported spreadsheet of orders, a support mailbox where customers pasted numbers, a debug log, or a database dump left on a file share. This article covers the free tools. For the surrounding process, see our guide to finding stored cardholder data.

Which free PAN scanners can you use today?

Five free options are worth knowing, and they cover different jobs: file-system hunting, desktop sweeps, text pipelines and data stores.

ToolLanguage and licenseBest forStatus
ccsrch and forksC, GPLv2Command-line sweeps of Windows and UNIX-like file systemsOriginal project is quiet; forks continue
PANhunt (Dionach)Python, BSD-3-ClauseOffice documents, email files and ZIPs on a PC or serverLast repository update April 2023
Spider and CUSpiderOpen source, Windows (Linux in older Spider builds)Desktop and laptop sweepsOrigin projects are old; availability varies
Presidio (originally Microsoft)Python, MITBuilding your own scanner for text and log streamsActively maintained
pdscanGo, MITSampling unencrypted data in data storesOlder project

ccsrch searches for unencrypted, contiguous card numbers and track data on Windows and UNIX operating systems, and it records where the PAN sits in the file and the file's MAC times. The PANhunt repository on GitHub describes a Python script that converts to a standalone executable you can run from a USB stick, and Dionach's own write-up of PANhunt explains the design. That portability helps when you can't install software on a locked-down machine.

Presidio is a different animal. It is an open-source Python framework for detecting and anonymizing personal data, and it is a library, not a product. The project began at Microsoft and now lives under the independent Data Privacy Stack organization on GitHub, with the MIT license unchanged. You write the code that feeds it files or log lines. pdscan is closer to a finished tool for databases: it scans data stores for unencrypted personal data, with credit card numbers among the types it looks for. Its README says it relies on data sampling, so don't treat a clean pdscan result as an exhaustive search of every row.

What happened to ccsrch, Senf and Spider?

ccsrch survived, Senf's downloads disappeared, and Spider lingers in modified or archived form. All three came out of the 2005 to 2008 period, when universities and security consultants needed cheap ways to find Social Security and card numbers.

ccsrch started with Mike Beekey in 2007 and was later maintained by Adam Caudill under the GPL. The ccsrch-adv fork on GitHub says it builds on version 1.0.9, the last upstream release, dated January 2, 2017. The fork adds options such as an ignore list for test cards, a check for card numbers wrapped across lines, and masking of PANs in output. Package trackers flag the old Caudill GitHub address as dead, so if you use ccsrch, pick a fork you've read and compiled yourself.

Senf, the University of Texas at Austin's Sensitive Number Finder, was the Java option that ran nearly anywhere. The product page is still online, but the GitHub download link and the support partner's link both return "404 Not Found." Treat it as retired. Spider came from Cornell. Cornell described it as a free, open-source tool used worldwide, supporting Windows and Linux as of August 2009. No currently maintained Cornell release is listed. Some universities still host copies, and Columbia's CUSpider is an open-source Windows scanner built for the same job. If you use any Spider-family build, verify where you got it and test it against known card numbers before relying on it.

Two other items from 2008-era lists were never PAN scanners in the strict sense. Nessus is a commercial vulnerability scanner, and Snort is a network intrusion detection system. Snort-style rules can flag card numbers crossing a network in cleartext. That is a separate job from finding data at rest, and it won't tell you what's sitting on a disk.

What does each tool detect: PAN, track data, files and databases?

Coverage differs more than the tool descriptions suggest, and the gaps matter when you're trying to show an assessor that you searched everywhere relevant.

ToolPANTrack dataFile typesDatabases
ccsrch forksYes, with prefix and Luhn checksYes, Track 2 or all tracks by optionReads files as raw data; the README doesn't describe unpacking Office, ZIP or mail formatsNo native support; scan dump files
PANhuntVisa, Mastercard and American ExpressNot documentedTXT, XML, DOCX, XLSX, ZIP, PSTNo
Spider familyYes, with custom patternsNot by defaultFiles, plus websites in Cornell's SpiderNo
PresidioYes, with Luhn validationOnly if you write a recognizerText you supplyNo native scanner
pdscanYes, among other PIINoFiles, including compressed onesYes, by sampling

On track data, ccsrch's track search examines the characters before a valid card number and the delimiter after it, with or without the expiration date that follows. That matters because full track data is sensitive authentication data and shouldn't exist after authorization at all. One forensics-forum user noted that Cornell's Spider doesn't do track data, though you may be able to add it with a suitable regular expression.

File types are where free tools diverge most. PANhunt uses simple regular expressions for Visa, Mastercard and American Express numbers in Word, Excel, text, XML and PST files, and it searches ZIP files recursively. That means Discover, JCB and other brands may slip past the default patterns, so check the regular expressions before running it. Databases are the weakest area. Older guidance noted that most free tools handle data at rest and don't speak server protocols, so you'd have to export the data to a text file first. That advice still describes ccsrch, PANhunt and Spider; pdscan is the exception, connecting to databases directly and sampling rows.

How do these tools find card numbers?

They match digit patterns, then filter the matches with the Luhn check, and sometimes with a look at the surrounding characters. A PAN is 13 to 19 digits, and its leading digits identify the card brand and issuer range. The scanner's regular expression looks for sequences with a plausible brand prefix and length, allowing for spaces or dashes in some tools and not others.

The Luhn check is a checksum all payment card numbers pass. The scanner doubles every second digit from the right, sums the digits and checks that the total is divisible by 10. It throws out most random digit strings, but about one in ten random strings of the right length still passes. Most scanners therefore add brand-prefix rules, ignore lists for published test cards, or context rules. ccsrch's documentation describes prefix validation applied to numbers that have already passed the mod 10 check. Newer scanners use the same approach: a regex matcher followed by validators.

Track data adds structure. Track 2, for example, carries the PAN, a separator, the expiration date and a service code in a fixed layout, which makes it easy to recognize even when the PAN alone might be ambiguous. Tools that look for it are really looking for that layout around a valid number. You can also add custom patterns to most of these tools, which is how people extend coverage to extra brands or to formats unique to a payment application.

Why do scans flag false positives and still miss card data?

Pattern matching can't tell a card number from a long number that happens to look like one, and it can't see what it can't read. Both limits are built into the method.

False positives come from order numbers, tracking numbers, timestamps, product IDs and test cards that pass Luhn, and from binary files where random bytes form a valid-looking sequence. Dionach notes that some system files generate false positives, which is why PANhunt excludes Windows system folders by default. Cornell's guidance for Spider was blunt: verify the results before moving, encrypting or removing files. Every hit needs a human review, and the reviewer should document why a hit was dismissed.

Misses are the more serious problem, and they have several sources:

Pepperdine's SENF guidance said the tool often reports a sensitive number it hasn't found, and a no-results report may still hide numbers it missed. That caveat applies to every tool here. Tokens deserve special mention. A token that preserves the card number's format and passes Luhn will trigger a scanner, while a properly encrypted PAN will not, which is what you want.

How do you document a clean scan as PCI DSS evidence?

Record what was searched, how, and what came back, and keep the report free of live card numbers. A bare screenshot showing zero results is weak evidence because it doesn't say what the scan covered. Discovery should test the architecture's claims rather than manufacture certainty from a zero-result dashboard.

A defensible package looks like this:

  1. Define the population. List the systems, shares, databases and endpoints in scope, including systems you believe are outside the CDE, tied to your data-flow diagrams and inventory.
  2. Fix the method. Record the tool, version and source, the patterns used (brands, track data), exclusions, and the account that ran it.
  3. Prove the tool works. Run it against a seeded file containing a known test card number and keep the result.
  4. Run and review. Scan, then triage every hit as a true finding or a false positive with a short reason.
  5. Remediate and rescan. Delete, tokenize or encrypt true finds, then rerun the scan on the same locations to show the fix worked.
  6. Record gaps. Note which locations were fully scanned, which were sampled, and which couldn't be scanned, with a follow-up plan.
  7. Date it and sign it. Tie the package to your annual 12.5.2 scope confirmation, or the six-month cycle for service providers.

A good evidence record preserves findings without duplicating PAN. Store file paths and masked values, not full numbers. PANhunt, for example, writes a report listing masked PANs, and ccsrch-adv has options to mask output. Your scan report shouldn't become a new place where card data lives. Your assessor decides what counts as sufficient, so share the method with them before the assessment, not after. And remember that a clean result speaks to one control. See why PCI compliant doesn't mean secure.

When are free tools no longer enough?

Free tools stop being enough when the effort of running, reconciling and defending their results exceeds what a license would cost. For a single-location merchant with a few PCs and a point-of-sale (POS) terminal, PANhunt and a documented procedure may be all you need. The picture changes as the environment grows.

Signs you've outgrown them:

Commercial products cover more formats, scan databases directly, handle remote hosts, and give you reporting built for audits. They cost money, and they still can't see data they weren't pointed at, so the scoping work and the evidence discipline stay the same. A sensible path is to use the free tools for a first pass and for spot checks between formal scans, then buy a commercial product once the free results show you have more locations than you can cover by hand.

Frequently asked questions

Can a free tool prove that no cardholder data is stored?

No tool can prove a negative. A scanner shows that it found no matches in the locations and formats it covered, using the patterns it was given. To support a no-storage claim, pair the scan with a documented scope, a seeded test file showing the tool works, and a record of any areas it couldn't reach.

Does PCI DSS require a card data discovery tool?

The standard requires you to confirm scope, including where account data is stored, but it doesn't name a tool. A data discovery tool or methodology is one accepted way to do it. Your assessor decides whether your method is sufficient.

Is it safe to run these scanners on production systems?

Scans read a lot of data and can slow busy servers, so test on a non-critical host and schedule off-peak runs. Use a least-privilege account, and write reports to a protected location. Prefer masked output, since a report full of real PANs becomes a new storage problem.

Will a scanner find encrypted or tokenized card data?

Properly encrypted PAN won't match a card-number pattern, which is why it's treated as unreadable. Format-preserving tokens that pass the Luhn check may match and show up as false positives. Document how you distinguish tokens from real PANs.

Which free tool is best for a small merchant?

For Windows or Linux machines holding documents, spreadsheets and email files, PANhunt is the easiest to run without installing anything. Check its patterns cover the card brands you accept. If you also have a database or custom application logs, you'll need to export that data or use a tool built for data stores.