USPTO Patent Search

Purpose

Search the USPTO patent database for granted patents (USPAT), pre-grant publications (US-PGPUB), and OCR'd legacy patents (USOCR) matching a query — by title, abstract, inventor, applicant/assignee, full specification, or claim text — and return the top results with patent number, title, abstract excerpt, assignee, inventor(s), application filing date, grant/publication date, and a link to the patent document. Read-only; does not file, edit, or pay anything.

When to Use

• Bulk literature / prior-art searches across U.S. patents and published applications.
• Tracking a specific inventor's, assignee's, or examiner's portfolio of grants.
• Looking up a single known patent number to fetch full bibliographic data + abstract.
• Anywhere you'd otherwise scrape PatFT/AppFT — those legacy databases were retired in late 2022 and the canonical replacement is Patent Public Search at ppubs.uspto.gov/pubwebapp.

Workflow

The USPTO has three relevant programmatic surfaces today (2026-05). They are not equivalent in coverage or cost — pick by what the user actually needs:

The recommended browser flow uses a published URL-param deep-link that the PPS application itself documents as its external-entry API. From the PPS source (ppubs.uspto.gov/pubwebapp/external.html):

DATA OBJECT:
  casenumber: string; default = ""
  db:         string; default = "USPAT,US-PGPUB"
  q:          string; default = ""
GET REQUEST
  EX: https://pasr.uspto.gov/webapp/external.html?q=("20150376584" | "9138715" | "8981250").PN.&casenumber=&db=

PPS resolves the same external.html on ppubs.uspto.gov — use that host (not pasr, which is the older Patent Application Search Result host) for current behavior.

Recommended path (browser, no auth)

1. Build the query string using PPS field-code syntax: <terms>.<CODE>. e.g., quantum.TI. for title contains "quantum", (machine ADJ learning).TI. for adjacent words, Apple.AS. for assignee. Operators are AND, OR, NOT (uppercase), ADJ (adjacent), SAME (same sentence), NEAR (within window). Wrap multi-word phrases in "..." and use () for grouping. Common codes (verified against the official searchable-indexes table):

   • TI / TTL — Title (preferred: TI accepts proximity operators)
   • AB / ABTX — Abstract text (full)
   • IN / INV — Inventor name
   • AANM — Applicant name (post-AIA, often the operating entity)
   • ASNM / AS — Assignee name (recorded at issuance)
   • INNM — Combined Applicant/Inventor name (use when the user can't distinguish)
   • PN — Patent number (9138715.PN. matches that grant; supports prefixes like D design, PP plant, RE reissue, T defensive pub)
   • PD — Patent grant/issue date ("20240101"->"20241231".PD. for ranges)
   • APD — Application filing date
   • SPEC — Description / specification body
   • CLM / ACLM — Claims text
   • APP — Application series + serial (e.g. 16/444401.APP.)
   • BIC — Title + Claims combined; handy single-shot "claim-or-title contains X" filter

   Combine via boolean: (neural ADJ network).TI. AND ("Google LLC".AS. OR Alphabet.AS.) AND 2023.PY.

2. Pick the database(s) with the db param. Values are comma-joined:

   • USPAT — granted U.S. patents (utility, design, plant, reissue, defensive publication)
   • US-PGPUB — published applications (since 2001-03; applications publish at 18-month mark unless requested non-publication)
   • USOCR — OCR'd pre-1976 grants (text quality is poor; only available for the AB, ACLM, SPEC composite fields)
   • Default if you omit db: USPAT,US-PGPUB. Add USOCR only when the user explicitly wants very old grants — it bloats result count with low-quality matches.

3. Open the deep-link directly (skip the landing page entirely):

   https://ppubs.uspto.gov/pubwebapp/external.html?q=<URL-ENCODED QUERY>&casenumber=&db=USPAT,US-PGPUB
   

   • The page is an Angular SPA. After load you'll see a terms-of-service modal first time per session ("Continue / Accept"). Click through it. The modal sets a session cookie via the AWS WAF challenge JS — see Site-Specific Gotchas.
   • Wait for the search-results panel to render — selector mat-tab-group becomes visible; the actual results grid is cdk-virtual-scroll-viewport.

4. Read the results grid. Each row contains: result number, patent/pub number, title, inventor, publication date, page count. The patent number is the canonical click target — clicking it opens the document in the right-hand "Reading" pane and updates the URL to ?...&docId=<docId>&docNumber=.... The reading-pane URL is the durable per-document link the agent should return.

   • For the agent: prefer browse get html body over browse snapshot for the grid — the virtualized scroller exposes only ~25 rows to the a11y tree at a time. Scroll the viewport to force virtualization to render more rows before extracting.
   • To extract abstract excerpt + assignee + inventor list per result, click the patent number → wait for the reading-pane iframe (#docPageContainer iframe) to load → extract from the bibliographic section. This costs ~1 turn per detail fetch — only do it for the top-K results the user wants.

5. Page through via the pagination bar at the bottom of the results grid (mat-paginator). PPS returns up to 500 results per query; for total_results > 500, refine the query — paginating past 500 is not supported.

6. Return JSON matching the schema in Expected Output. Always include the document_url field constructed from the durable PDF link: https://ppubs.uspto.gov/dirsearch-public/print/downloadPdf/<patent_number> (also works without a session for granted patents — verified independently by the PPS team).

Browser fallback for ambiguous queries

If the agent's query is a person/company name without a clear field hint, run two passes:

1. (<name>).INNM. — combined applicant+inventor (recall-heavy; finds the name in either role)
2. (<name>).AANM. OR (<name>).ASNM. — applicant + assignee separately (more precise; helps disambiguate inventor "John Smith" from assignee "Smith & Wesson")

Merge results and de-duplicate by patent number.

Alternative: Open Data Portal (ODP) API

If the user supplies an ODP API key (PATENT_CLIENT_ODP_API_KEY or X-API-KEY header) and they only need application-level data (no granted-only fields, nothing older than 2001), prefer the ODP API — it's ~50× cheaper in agent turns than browsing.

POST https://api.uspto.gov/api/v1/patent/applications/search
X-API-KEY: <user-supplied key>
Content-Type: application/json

{
  "q": "applicationMetaData.inventionTitle:\"quantum computing\"",
  "sort": "applicationMetaData.filingDate desc",
  "limit": 25,
  "offset": 0,
  "fields": [
    "applicationNumberText",
    "applicationMetaData.patentNumber",
    "applicationMetaData.inventionTitle",
    "applicationMetaData.filingDate",
    "applicationMetaData.grantDate",
    "applicationMetaData.applicantBag",
    "applicationMetaData.inventorBag",
    "applicationMetaData.firstApplicantName",
    "applicationMetaData.firstInventorName",
    "applicationMetaData.applicationTypeCode"
  ]
}

Response shape: { "totalNumFound": N, "patentFileWrapperDataBag": [...], "requestIdentifier": "..." }. The query language is Solr-like — field:value, boolean AND/OR/NOT, range [2020-01-01 TO 2024-01-01], wildcards */?, exact-phrase "...". The /applications/search endpoint covers BOTH granted patents (where applicationMetaData.patentNumber is populated) AND pending applications under one search — the user-facing distinction is just whether grantDate is set.

Do not mix ODP results with PPS results in the same response — they have different field shapes and ODP only covers post-2001. Either return ODP-shaped or PPS-shaped output, not both.

Site-Specific Gotchas

• PatFT and AppFT are dead. patft.uspto.gov and appft.uspto.gov were retired September 30, 2022 and now 301 to PPS. Don't waste time on /netacgi/nph-Parser legacy URLs — they're gone.
• api.patentsview.org is dead. Confirmed 2026-05-16: 301 → data.uspto.gov/support/transition-guide/patentsview. The 2024-and-earlier requests.post('https://api.patentsview.org/patents/query', json=...) recipe found in tutorials no longer works. Code samples still referencing it (including some 2026-03 blog posts) were not updated for the migration.
• search.patentsview.org (v2 PatentsView) returned 500 on every path tested during 2026-05-16 reconnaissance (/api/v1/patent, /api/v1/patent/?q=..., /docs/, root). The service exists, requires a separate API key per its docs, and may recover — but treat it as flaky. The patent_client Python wrapper (parkerhancock/patent_client) was archived 2026-04-24 when its maintainer hit one too many of these outages — that history is itself a strong "don't rely on PatentsView for production" signal.
• ODP API requires a key — silent 403 without one. api.uspto.gov/api/v1/patent/applications/search returns 403 {"message":"Forbidden"} (Amazon API Gateway ForbiddenException) with no body explanation if X-API-KEY is missing. Get keys at data.uspto.gov/key/myapikey (free). The same key works for the full ODP family (applications, file-wrapper documents, assignments, bulk).
• ODP only covers applications filed on or after 2001-01-01. Pre-2001 patents are queryable only via PPS or PEDS-extract bulk files. Don't promise the user "full historic search" via ODP.
• PPS is behind AWS WAF + reCAPTCHA + a session-bootstrap challenge. The page loads https://0dd6fc7fe1e2.edge.sdk.awswaf.com/.../challenge.js on every fresh session — a browse cloud sessions create --verified session passes it transparently; a plain (non-Verified) session occasionally triggers a CAPTCHA modal. Use --verified flag every time. --proxies is helpful but not strictly required for PPS — the WAF is per-fingerprint, not per-IP.
• Terms-of-service modal on first navigation. PPS shows a "Patent Public Search Terms of Use" modal once per session (cookie-gated). The Continue button is button[data-mat-button][aria-label="Continue"] or the only enabled mat-dialog-container button. Snapshot will show it as the only focusable target — clicking it dismisses and starts the search.
• The PPS results grid is a virtualized CDK scroller (cdk-virtual-scroll-viewport). At most ~25 rows are in the DOM at any time; to harvest more, scroll the viewport (browse scroll <x> <y> 0 800 inside the grid) and re-extract. The "results" counter at the top of the panel gives total_results reliably — read it before scrolling.
• Field codes are positional suffixes, not query keys. Beginners write TI:quantum (Solr style) — PPS will silently treat that as a literal-string search and return 0 results. The correct syntax is quantum.TI. (term, dot, code, dot). The PPS query bar accepts both classic CCL (SS 1-style numbered set logic) and a simplified expression mode; the deep-link q= param uses simplified mode by default.
• PN field accepts prefixes that change the patent class: bare digits (9138715.PN.) match utility; D475502.PN. matches design; PP12345.PN. matches plant; RE38134.PN. matches reissue; T123456.PN. matches statutory invention registration / defensive publication. Pre-grant publication numbers (e.g. 20150376584) only match in the US-PGPUB database — make sure db= includes it.
• AS (assignee at issuance) ≠ AANM (applicant at filing) ≠ current owner. AIA assignees often refile through holding entities; "Google LLC" patents from 2015 may be ASNM:Google Inc. (the pre-2017 name). Try a name + OR variant set: (Google OR "Google LLC" OR "Google Inc." OR Alphabet).ASNM.
• PPS deep-link casenumber= param is for internal pasr.uspto.gov USPTO-employee bookmarks ("examiner case number"). Leave it empty.
• document_url durable form: https://ppubs.uspto.gov/dirsearch-public/print/downloadPdf/<patent_number> returns the full PDF without requiring a session. For the HTML / structured view, use https://image-ppubs.uspto.gov/dirsearch-public/print/downloadPdf/<patent_number> (mirror host). Do not return the SPA URL with ?q=...&docId=... as the document_url — those are session-scoped and break for downstream consumers.
• PPS undocumented backend endpoints (/dirsearch-public/searches/searchWithBeFamily, /dirsearch-public/users/me/session) are actively blocked. Direct POST attempts return 404 / 403 today. The patent_client maintainer's archive note in April 2026 explicitly cites this. Don't try to reverse-engineer the JSON API — every recipe published before mid-2024 has been broken by USPTO. Stay on the documented UI deep-link.
• Rate limit (informal): USPTO doesn't publish one for PPS, but observed behavior is throttling beyond ~10 queries/min from a single fingerprint; sustained scraping triggers the WAF challenge to escalate to a full CAPTCHA. Cap at 6 queries/min per session.

Expected Output

{
  "query": "quantum computing",
  "query_field": "TI",
  "constructed_query": "(\"quantum computing\").TI.",
  "databases": ["USPAT", "US-PGPUB"],
  "total_results": 1284,
  "page_size": 5,
  "page": 1,
  "results": [
    {
      "patent_number": "US 11,989,628 B2",
      "kind_code": "B2",
      "document_type": "granted_patent",
      "title": "Quantum computing apparatus and methods for fault-tolerant operation",
      "abstract_excerpt": "A quantum computing system that implements a surface-code fault-tolerant architecture using superconducting transmon qubits. The disclosed methods include syndrome extraction without measurement disturbance...",
      "assignee": "International Business Machines Corporation",
      "inventors": ["John A. Doe", "Jane B. Smith", "Wei C. Chen"],
      "filing_date": "2020-01-15",
      "grant_date": "2024-05-21",
      "publication_date": "2021-07-22",
      "application_number": "16/744123",
      "publication_number": "US 2021-0224656 A1",
      "classification_cpc_primary": "G06N 10/00",
      "page_count": 47,
      "document_url": "https://ppubs.uspto.gov/dirsearch-public/print/downloadPdf/11989628"
    }
  ],
  "source": "ppubs.uspto.gov",
  "retrieved_at": "2026-05-16T05:30:00Z"
}

For pre-grant publications (US-PGPUB), document_type is "published_application", grant_date is null, and patent_number is the 11-digit publication number formatted US 2021-0224656 A1.

For multi-outcome responses:

// No results
{ "query": "...", "constructed_query": "...", "total_results": 0, "results": [], "source": "ppubs.uspto.gov" }

// WAF block (rare — only if --verified was not used)
{ "query": "...", "error": "waf_challenge", "error_reasoning": "PPS returned an AWS WAF CAPTCHA challenge that the session could not solve. Retry with browse cloud sessions create --verified --solve-captchas.", "results": [] }

// Query syntax error
{ "query": "...", "error": "query_syntax", "error_reasoning": "PPS returned 'No documents matched your query' with a syntax-help banner. The constructed query was '<...>' — likely a missing field-code suffix (write 'quantum.TI.' not 'TI:quantum').", "results": [] }