USPTO Patent Search Scraper: 19 Data Fields per Record (2026)

Each record carries 19 output fields covering titles, publication numbers, filing dates, assignees, inventors, and classification codes from the USPTO PPUBS system. Full abstracts and claims counts are included when detail fetching is enabled, costing $5.00 per 1,000 results on the free plan. It provides direct access to pre-grant applications and issued patents without requiring an API key. This is built for IP analysts, patent attorneys, and engineering leads tracking US filings. It is not for anyone who needs worldwide patent family records or citation trees, which this tool does not provide.

Try it: open USPTO Patent Search Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try USPTO Patent Search Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of USPTO Patent Search Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 25, so a first run returns at most 25 results and costs at most $0.125 in result charges. That is enough to see the real shape of the data before deciding anything.

USPTO Patent Search Scraper was last updated on 2026-06-02. It is one of 1,724 Actors CrawlerBros publishes on Apify, which together have 734,650 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run USPTO Patent Search Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The primary cost driver is maxItems, which directly controls the total number of records written to the dataset. Setting fetchDetails to true extracts richer metadata such as abstracts, but it does not increase the per-result bill. To validate whether search parameters match your criteria before spending, run an initial probe with maxItems capped at 25.

How do you run USPTO Patent Search Scraper from the API?

None of its 9 controls is strictly required, so the defaults below produce a valid run on their own. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for USPTO Patent Search Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~uspto-patent-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"artificial intelligence","patentType":"","sortBy":"date_publ desc","fetchDetails":false,"maxItems":25}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "searchQuery": "artificial intelligence",
  "patentType": "",
  "sortBy": "date_publ desc",
  "fetchDetails": False,
  "maxItems": 25
}

run = client.actor("crawlerbros~uspto-patent-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "searchQuery": "artificial intelligence",
  "patentType": "",
  "sortBy": "date_publ desc",
  "fetchDetails": false,
  "maxItems": 25
}

const run = await client.actor('crawlerbros~uspto-patent-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which USPTO Patent Search Scraper inputs matter, and which can you skip?

The input schema exposes 9 controls, and 0 are required. The controls that govern your result set are searchQuery, assigneeName, and the date filters. Most users should leave fetchDetails disabled on initial discovery runs to speed up execution, enabling it only when abstract text is needed.

• searchQuery (string): Keyword(s) to search in patent titles and abstracts. Example: 'artificial intelligence', 'CRISPR gene editing'.
• assigneeName (string): Filter by patent assignee (company or individual that owns the patent). Example: Google, Apple, IBM.
• inventorName (string): Filter by inventor name. Example: 'Elon Musk', 'James Dyson'.
• dateFrom (string): Only return patents published on or after this date (YYYY-MM-DD). Example: 2020-01-01
• dateTo (string): Only return patents published on or before this date (YYYY-MM-DD). Example: 2024-12-31
• patentType (string): Filter by patent type. Default: "".
• sortBy (string): Sort order for results. Default: "date_publ desc".
• fetchDetails (boolean): If enabled, fetches full patent details including abstract, claims, and CPC classifications for each result. Slower but returns more data. Default: false.
• maxItems (integer): Maximum number of patent records to return (1-1000). Default: 25.

Fixed-choice controls: patentType accepts "" (Any), utility (Utility Patent), design (Design Patent), plant (Plant Patent), reissue (Reissue Patent); sortBy accepts date_publ desc (Newest first), date_publ asc (Oldest first), score desc (Best match).

What does USPTO Patent Search Scraper return?

Returned records provide structured patent metadata including document numbers, application dates, inventor rosters, assignee names, and CPC classification codes. They are suitable for tracking filing timelines and technology categorization. They conspicuously do not contain full legal text claims or PDF document downloads.

• guid (e.g. US-20260147587-A1)
• publicationNumber (e.g. 20260147587)
• documentId (e.g. US 20260147587 A1)
• title (e.g. SYSTEM AND METHOD FOR AUTOMATED PLANNING ASSI...)
• kind (e.g. A1)
• documentType (e.g. US-PGPUB)
• publicationDate (e.g. 2026-05-28)
• filingDate (e.g. 2024-09-24)
• assignees
• inventors
• applicationNumber (e.g. 18/894868)
• cpcCodes
• ipcCodes
• abstract
• pageCount (e.g. 22)
• claimsPages (e.g. 2)
• sourceUrl (e.g. https://ppubs.uspto.gov/pubwebapp/external.ht...)
• scrapedAt (e.g. 2026-05-30T10:30:00+00:00)
• recordType (e.g. patent)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open USPTO Patent Search Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Run a test query setting searchQuery to your core technical terms and cap maxItems at 5 with fetchDetails turned off.
2. Inspect the dataset items to confirm documentType distinguishes between pre-grant applications (US-PGPUB) and issued grants (USPAT).
3. Enable fetchDetails to true and verify that the abstract field is populated on newly written items.
4. Add assigneeName or inventorName filters to constrain the collection scope to the target entities.
5. Define dateFrom and dateTo using YYYY-MM-DD formatting to isolate specific publication windows.
6. Set sortBy to date_publ desc for ongoing monitoring or score desc for relevance ranking.
7. Increase maxItems up to the needed volume (capped at 1000 per run) and trigger the full extraction.

How do you apply it? Three worked playbooks

These are USPTO Patent Search Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Patent research and prior art

Outcome: Patent research and prior art searches

Configure: Set searchQuery to specific technical keywords, fetchDetails to true, sortBy to score desc, and maxItems to 50.

Working method: Start with a single niche keyword phrase, evaluate relevance by checking the top abstract values, and iteratively expand search terms.

Deliverable: A structured dataset containing 50 highly relevant patents with abstracts, CPC codes, and publication details for clearance review.

Stop condition: Stop if the top five records do not match the intended technical domain or contain empty abstract fields.

Use case 2: Technology trend analysis

Outcome: Technology trend analysis by keyword or date range

Configure: Set searchQuery to the domain category, dateFrom to 2020-01-01, dateTo to 2024-12-31, sortBy to date_publ asc, fetchDetails to false, and maxItems to 500.

Working method: Execute across defined yearly boundaries, comparing publication volume and dominant assignee entries across each yearly cohort.

Deliverable: A chronological series of patent filings and grants covering the multi-year window, mapped by publicationDate and cpcCodes.

Stop condition: Stop if publicationDate values exceed the dateTo boundary or if result counts hit the 1000 maxItems ceiling without covering the time span.

Use case 3: Competitor portfolio analysis

Outcome: Competitor patent portfolio analysis

Configure: Set assigneeName to the target company name, sortBy to date_publ desc, fetchDetails to false, and maxItems to 200.

Working method: Begin by inspecting the most recent grants, cluster the records by cpcCodes, and identify lead inventors appearing across multiple records.

Deliverable: A portfolio report listing all recent filings by the target company with application dates, publication numbers, and inventors.

Stop condition: Stop if assignees in the returned records does not match the requested target company.

What breaks, and how do you design around it?

A single run caps output at 1000 items through the maxItems parameter. When collecting large volumes, divide your requests into narrower time windows using dateFrom and dateTo. If you require deep claim language or complete specifications rather than abstracts, use the sourceUrl field to retrieve full filings directly from USPTO servers.

When should you not use USPTO Patent Search Scraper?

Do not use this Actor if your analysis requires international coverage across European, Japanese, or Chinese patent offices, as it only queries USPTO domestic records. It is also unsuitable if you require automated citation tracking or legal status history. When you need international coverage, citation networks, and direct PDF downloads, use Google Patents Scraper instead. Furthermore, if you simply need occasional manual lookups of individual patent numbers, querying the public USPTO web interface directly is faster and incurs zero cost.

What should you check before trusting the output?

• Verify that publicationNumber and documentId are present; missing identifiers indicate malformed records.
• Check that abstract is non-empty whenever fetchDetails was set to true.
• Confirm assignees contains at least one non-empty string when filtering explicitly by assigneeName.
• Inspect publicationDate to ensure it matches the ISO YYYY-MM-DD format and falls within any requested dateFrom and dateTo limits.
• Ensure cpcCodes or ipcCodes exist on each record to maintain classification indexing.

None of this proves a record is correct. It gives a scheduled USPTO Patent Search Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the cost to run USPTO Patent Search Scraper?

Results cost $0.005 per item, which is $5.00 per 1,000 results on the free tier. Apify's free plan includes $5.00 of monthly usage with no credit card, covering up to 1,000 results before platform usage fees.

Do I need an official USPTO API key to search?

No API key is required. The Actor queries the public USPTO Public Patent Search interface directly without requiring authentication or account credentials.

What is the difference between US-PGPUB and USPAT in the output?

The documentType field indicates the record status. US-PGPUB represents published pre-grant patent applications, whereas USPAT indicates formally granted and issued US patents.

How do I ensure patent abstracts are included in the results?

Set the fetchDetails control to true. When disabled, the scraper extracts tabular listing metadata; enabling it instructs the Actor to fetch full detail pages including the abstract text.

What is the maximum number of patents returned per run?

The maxItems parameter accepts a value up to 1000. For datasets requiring more than 1,000 records, split your search using dateFrom and dateTo filters.

Where to go next

When you are ready to run it, open USPTO Patent Search Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the USPTO Patent Search Scraper Actor page for the current input schema, pricing tier, and run history.

Other Actors we maintain for related data:

• Google Patents Scraper: Search Google Patents and pull full patent metadata: abstract, claims, classifications (CPC/IPC), inventors, assignees, priority/grant dates, family, citations, and PDFs.

Related guides:

• USPTO Trademark Search Scraper: 49 Data Fields per Record (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-04.

• Actor last updated by its maintainers on 2026-06-02.

• Run outcome figures cover the 30 day public window ending 2026-10-04.

• USPTO Patent Search Scraper on Apify