You've built something clever. Before you file, or before you spend a weekend building it, you want to know if it already exists. A shallow prior art search misses the one reference that matters; a good one is reproducible: you can re-run it, script parts of it, and know when you've actually looked hard enough. This is that workflow.
tl;dr - The 5-Layer Saturation Method
- Classification anchoring (CPC/IPC)
- Boolean + semantic query construction
- Citation chaining (forward/backward)
- Non-patent literature (NPL) sweep
- Validation & saturation check
Includes copy-paste queries, a runnable Python example against a public patent API, and a completeness checklist.
Why Most Prior Art Searches Miss the One Reference That Matters
Even careful searchers miss critical references, usually for the same three reasons. The fix isn't working harder; it's structuring the search so you can tell when it's actually done.
| Failure mode | Symptom | Fix |
|---|---|---|
| Shallow classification | You stop at one CPC symbol | Map the full class neighborhood (siblings + parents) |
| Keyword tunnel vision | You assume everyone names the concept your way | Anchor on classification, not vocabulary |
| Skipped NPL | You treat patents as the whole universe | Sweep papers, code, and standards |
That second one bites developers hardest: you name your own invention the way you think about it, but an examiner or a rival team may describe the identical concept in completely different terms.
What is a thorough prior art search? A thorough prior art search is one that is complete, reproducible, and documented across both patent and non-patent literature. If you can't reproduce and re-run it later, it didn't really happen.
You cannot read every document ever published. The goal is saturation: the point where new queries stop surfacing new relevant art. The 5-Layer Saturation Method gets you there predictably instead of by luck.
Layer 1: Anchor on Classification (CPC & IPC)
Keyword-only searches miss art described in unfamiliar terminology; classification catches it, because an examiner already sorted that document by concept.
How to find the right CPC class in 4 steps:
- Identify 2–3 patents you already know are relevant.
- Read their assigned CPC symbols on the front page.
- Look up each symbol's definition in the USPTO CPC scheme or Espacenet.
- Expand to sibling and parent classes to capture the full concept.
Decompose a symbol before you trust it. In G06F 16/00: G (physics) → G06 (computing) → G06F (electric digital data processing) → 16/00 (information retrieval). Searching the parent G06F casts wide; the subgroup narrows.
What is the difference between CPC and IPC? CPC (Cooperative Patent Classification) is a joint USPTO/EPO scheme with roughly 250,000 finer subdivisions. IPC is the broader WIPO international standard with roughly 75,000 groups. Use CPC for granular US/EP art; use IPC for wider international coverage.
| Feature | CPC | IPC |
|---|---|---|
| Maintained by | USPTO + EPO | WIPO |
| Granularity | ~250,000 subgroups | ~75,000 groups |
| Best for | Granular US/EP art | Broad international sweeps |
Layer 2: Build Queries That Balance Recall and Precision
Every query trades recall against precision. Broad synonym rings raise recall; proximity operators restore precision. Steal this Boolean template and adapt the synonym rings:
(("machine learning" OR "neural network" OR "deep learning") NEAR5 (fraud OR anomaly OR outlier) AND (transaction* OR payment*)) AND CPC=/G06Q20/
The same intent in Espacenet Query Language (CQL):
ctxt = "machine learning" prox/distance<5 "fraud detection" AND cpc = "G06Q20"
Confirm CQL syntax against the current Espacenet interface before relying on it, since the classic and new interfaces differ.
Synonym rings and truncation: list every way an inventor might name the concept, then truncate stems (transaction* catches transaction, transactions, transactional). Wildcards inside words (optimi?e) bridge US/UK spelling. NEAR5 or prox/distance<5 requires terms within five words, killing the coincidental co-occurrence that plain AND allows.
Automating the search: a PatentsView API example. The PatentsView API is free (a key is required) and returns real, structured patent data you can script against:
# Query PatentsView for fraud-detection ML patents in G06Q20
import requests, json
query = {
"_and": [
{"cpc_subgroup_id": "G06Q20/40"},
{"_text_any": {"patent_abstract": "machine learning fraud"}}
]
}
fields = ["patent_id", "patent_title", "patent_date"]
r = requests.get(
"https://search.patentsview.org/api/v1/patent/",
params={"q": json.dumps(query), "f": json.dumps(fields)},
headers={"X-Api-Key": "YOUR_FREE_KEY"},
)
for p in r.json()["patents"]:
print(p["patent_id"], p["patent_date"], p["patent_title"])
Verify the current endpoint and parameters at run time, as the API version may change.
Can AI replace Boolean patent search? No. Embedding-based semantic search finds conceptually similar art regardless of vocabulary, which helps when terminology is unpredictable, but vector results are not reproducible enough to stand alone. Use them to widen the net, then confirm hits through classification and Boolean rigor.
Layer 3: Chase Citations to Find Hidden References
Citations surface art your queries never will, because they encode relationships a human examiner or applicant already identified.
What is the difference between forward and backward citation search? Backward citations are references cited by a patent (the prior art it built on). Forward citations are later patents that cite it (what built on it). Backward looks into the past; forward looks into the future.
- Backward citations: the applicant's and examiner's own map of the field. Start here for any known-relevant patent.
- Forward citations: who improved on this invention, often the closest competing art.
- Patent family expansion: use INPADOC families to catch foreign equivalents. A concept unfindable in English may be fully disclosed in a German or Japanese family member.
Depth heuristic: chain two hops out, then stop when new citations only return documents you've already seen. That repetition is a saturation signal.
Layer 4: Sweep the Non-Patent Literature (NPL)
For software and AI, NPL is often the decisive art. A public GitHub commit can anticipate a claim years before any patent issues.
Top NPL sources by category:
- Academic & preprints: arXiv, IEEE Xplore, ACM Digital Library.
- Standards bodies: IETF RFCs, IEEE, ISO, W3C specifications.
- Code & products: GitHub repositories, product manuals, release notes, datasheets.
- Archived web pages: the Wayback Machine for pages since removed.
Dating evidence: no timestamp, no prior art. Prior art must be publicly available before the priority date. Capture the archive timestamp, arXiv submission version, or commit date, and screenshot it. An undated disclosure is not usable art.
| Tech domain | Priority NPL sources |
|---|---|
| AI / ML | arXiv, GitHub, NeurIPS/ICML proceedings |
| Networking | IETF RFCs, IEEE Xplore |
| Consumer software | Product docs, Wayback Machine, release notes |
Layer 5: Validate, Check Saturation & Document
If you can't reproduce it, it didn't happen. Validation converts a search into a defensible record.
How do you know a prior art search is complete? When each layer reaches saturation: classification is exhausted, query variants return known hits, citation chains loop back, and NPL sources repeat. Overlapping repetition across independent methods is the strongest completeness signal.
Prior art search completeness checklist:
- [ ] CPC/IPC classes identified, expanded to siblings and parents
- [ ] Boolean strings logged with hit counts and dates
- [ ] Semantic/vector pass run and reconciled against classification
- [ ] Forward + backward citations chained on top references
- [ ] Patent families (INPADOC) reviewed for foreign art
- [ ] NPL sweep across academic, standards, code, and archived sources
- [ ] Publication dates captured for every NPL reference
- [ ] Full query log saved for reproducibility
What a reproducible search log records: every database, query string, date, and result count. That log is what lets a colleague, a reviewer, or a court reproduce your work exactly.
Worked Example: A Real Fraud-Detection Search, End to End
Say the invention is a machine-learning system that detects payment fraud in real time. Here is all five layers on one target.
-
Layer 1: anchor on
G06Q20/40(payment protocol/architecture) plusG06N20/00(machine learning); expand siblings. -
Layer 2: run the Boolean template above, then the PatentsView Python snippet to pull
G06Q20/40+ "machine learning fraud" hits. - Layer 3: chain citations on the two closest hits, two hops out; expand INPADOC families.
- Layer 4: sweep arXiv and GitHub for real-time fraud-detection models predating the priority date.
- Layer 5: log every query, confirm saturation, write the report.
| Layer | Tool | Output |
|---|---|---|
| 1 | Espacenet / Patent Public Search | CPC anchor set |
| 2 | PatentsView API / CQL | Ranked candidate art |
| 3 | INPADOC / citation view | Hidden + foreign references |
| 4 | arXiv / GitHub / Wayback | Decisive NPL |
| 5 | Search log | Reproducible record |
Run the Python snippet yourself against G06Q20/40 and you'll retrieve live, dated patent records you can open and read; that is the reproducibility payoff. Because IDs and dates shift as the corpus updates, pull your own list at run time rather than trusting a copied one, then verify each hit on Espacenet or Patent Public Search before treating it as art.
Where Tooling Fits (and Where It Doesn't)
Running all five layers by hand is thorough but slow. This section is authored by and for PatentScan, so treat it as a disclosed note, not neutral advice: concept-based platforms compress the method into a single pass by taking a plain-language invention description and returning classification-aware, semantically ranked art, so you spend your time judging references instead of assembling queries. Use it to accelerate the workflow, not to skip the validation discipline that makes a search complete.
References & External Sources
- USPTO Cooperative Patent Classification - Official CPC scheme definitions used to anchor Layer 1 classification.
- Espacenet Patent Search - EPO's free worldwide database for classification lookup, CQL queries, and INPADOC families.
- PatentsView API - Free, key-based USPTO-backed API that makes the Layer 2 Python example runnable.
- WIPO International Patent Classification (IPC) - The broader international classification standard referenced in the CPC vs. IPC comparison.
- arXiv - Primary preprint repository for dating software/AI non-patent prior art.
Experience modern patent search yourself. Paste any invention or concept description into PatentScan and see what advanced concept-based discovery finds in seconds.
Top comments (0)