# 📜 USPTO Patent Grants Tracker — IP & Competitive Intelligence (`nexgendata/uspto-patent-grants`) Actor Track newly granted US patents from the USPTO with title, assignee, inventors, CPC classes, claims and citation counts, AI/software flags, PDF and Google Patents URLs. IP, legal, M\&A and competitive intelligence. Filter by keywords, assignee, CPC, date range, AI-only. - **URL**: https://apify.com/nexgendata/uspto-patent-grants.md - **Developed by:** [NexGenData](https://apify.com/nexgendata) (community) - **Categories:** Business, AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $100.00 / 1,000 uspto patent records This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## 📜 USPTO Patent Grants Tracker — IP, Legal & Competitive Intelligence **The institutional IP-monitoring desk on tap.** Track newly granted US patents from the USPTO with title, assignee, inventors, CPC classifications, claims count, citation count, full-text search, AI / software flags, PDF and Google Patents links. Built for IP law firms, patent attorneys, M&A diligence teams, competitive intelligence analysts, R&D directors, tech-trend researchers, and AI / biotech / hardware funds. This is the actor a single LexisNexis PatentSight seat costs $30k/yr to access. Pay-per-result on Apify — no seat, no contract, no minimum commitment. --- ### Why a dedicated patent-grants actor (and not just a generic web scraper) The USPTO publishes ~6,500 patent grants every Tuesday. The raw firehose is too noisy for any human workflow. A generic web scraper fails patent monitoring three ways: 1. **No semantic classification.** USPTO grants carry CPC (Cooperative Patent Classification) codes — the global classification standard maintained jointly by USPTO and EPO. A neural-net patent (`G06N3/08`), a CRISPR patent (`C12N15/11`), and a lithium-ion battery patent (`H01M10/0525`) live in completely different worlds. A generic scraper hands you all 6,500 grants in a single bucket; we hand you a CPC-typed, AI-flagged, software-flagged feed where every record is already routed to the right downstream consumer. 2. **No assignee-level filtering.** When the General Counsel of a hyperscaler asks "what did Google patent this week?" you can't grep raw HTML — you need normalized assignee names, fuzzy matching, country-of-record. Our `assignee_name` filter handles partial matches case-insensitively (`"Apple"` matches `"Apple Inc."`, `"Apple Computer, Inc."`, `"Apple Industries"`). 3. **No claims / citations count.** The two single most-valuable patent quality signals after the assignee are (a) how many independent claims the patent asserts and (b) how many subsequent patents cite it (the forward-citation count is the gold-standard impact metric in the patent-econometrics literature). A generic scraper gives you the title; we give you a record that already includes both. --- ### What you get A unified patent grant record stream, one row per granted USPTO patent: ```json { "patent_number": "US12438891B1", "patent_title": "Anomaly detection based on ensemble machine learning model", "grant_date": "2025-10-07", "priority_date": "2015-08-31", "filing_date": "2022-02-18", "inventors": ["Sudhakar Muddu", "Christos Tryfonas", "Joseph Auguste Zadeh"], "assignee_name": "Cisco Technology Inc", "assignee_country": "US", "cpc_classes": ["G06N20/00", "G06N3/08", "H04L63/1416", "G06F21/55"], "abstract_excerpt": "A security platform employs a variety techniques and mechanisms to detect security related anomalies and threats in a computer network environment. The security platform is big data driven and employs machine learning to perform security analytics...", "claims_count": 22, "citations_count": 3, "is_ai_related": true, "is_software": true, "pdf_url": "https://patentimages.storage.googleapis.com/pdfs/US12438891B1.pdf", "google_patents_url": "https://patents.google.com/patent/US12438891B1/en", "data_source": "google_patents" } ```` That single record gives you everything to: - Track a competitor's weekly grant velocity (`assignee_name` + `date_range: week`) - Build a quarterly AI-patent dashboard (`ai_only: true` + `date_range: quarter` — equivalent of running `date_range: month` three times) - Surface freedom-to-operate risks for an R\&D team's new feature (search by `keywords` of the contested feature) - Build an M\&A diligence patent-portfolio inventory (`assignee_name` of the target, `date_range: year`) - Power a litigation-watch dashboard — newly granted patents in a CPC class your client is being sued under - Run patent-econometrics studies (`claims_count`, `citations_count`, `cpc_classes`) - Feed a hedge fund's R\&D-momentum signal (which companies are filing the most software / AI patents and how is the cadence trending) *** ### Input filters | Input | Type | Description | |---|---|---| | `keywords` | string list | Free-text search across title + abstract. Multi-word entries treated as exact phrases. OR'd together. | | `assignee_name` | string | Partial match on the company / institution holding the grant. Case-insensitive. | | `date_range` | enum | `today` / `week` / `month` / `year` / `all` — grant-date window. | | `cpc_class` | string | CPC code at any level — `G` (section), `G06N` (class), `G06N3/08` (subgroup). | | `ai_only` | boolean | Filter to patents flagged AI / ML via keyword heuristic + `G06N*` CPC. | | `limit` | integer | Max records to emit (1-5000). | | `enrich_details` | boolean | If true, fetch each patent's detail page to populate `cpc_classes`, `claims_count`, `citations_count`, full abstract. Default true. | *** ### CPC class quick-reference (top sections for tech filers) | CPC | Coverage | Typical assignees | |---|---|---| | `G06N` | Computing arrangements based on specific computational models (AI / ML / neural nets) | Google, Meta, NVIDIA, OpenAI, Anthropic | | `G06F` | Electric digital data processing (general software) | Microsoft, Apple, Oracle, IBM | | `G06Q` | Data processing for business/finance/management (fintech, e-commerce, ad-tech) | Visa, Mastercard, Amazon, Salesforce | | `H04L` | Transmission of digital information (networking, comms, blockchain) | Cisco, Ericsson, Qualcomm | | `H04W` | Wireless networks (5G, WiFi) | Qualcomm, Samsung, Huawei, Apple | | `A61K` | Pharmaceutical compositions | Pfizer, Merck, Moderna, Genentech | | `C12N` | Microorganisms / biotech (CRISPR, gene editing) | Broad Institute, MIT, biotech startups | | `H01M` | Batteries / fuel cells / capacitors | Tesla, Panasonic, CATL, LG Chem | | `H01L` | Semiconductor devices | TSMC, Intel, Samsung, SK Hynix | | `B60W` | Vehicle systems (ADAS, autonomous driving) | Tesla, Waymo, GM, Mobileye | Combine `cpc_class: G06N` + `date_range: week` for a weekly AI grants feed. Combine `cpc_class: C12N` + `date_range: month` for monthly biotech grants. Combine `cpc_class: H01M` + `assignee_name: Tesla` for Tesla's latest battery patents. *** ### Use cases for the buyer pool #### IP law firms / patent prosecutors Daily fresh pull filtered by the client's CPC classes. Monitor competing assignees' filing cadence. Identify newly granted patents that may impact ongoing prosecution strategy. Replace your manual weekly USPTO bulk-download workflow with a JSON feed routed straight to your docketing system. #### Competitive intelligence / corporate IP departments Track every new grant by your top 20 competitors. Set up a daily scheduled task in Apify with `assignee_name: ` + `date_range: week`. The Wednesday-morning report lands in your Slack via the CI team's Apify-webhook integration before the legal team's standup. #### M\&A diligence teams Acquisition target's full patent portfolio in 30 seconds: `assignee_name: ` + `date_range: year` + `limit: 5000`. Cross-reference with the target's claimed innovation pipeline. Identify whether their stated AI / biotech / hardware moat is real or marketing fluff. Add the resulting JSON to your data-room workbook. #### AI / biotech / hardware venture capital Pre-vet a portfolio startup's claimed IP before lead-check signature. Confirm their team's named inventor history. Surface adjacent assignees in the same CPC subgroup to map the competitive landscape. Track AI-grant velocity industry-wide via `ai_only: true` to time fund deployments to AI-grant cycle peaks. #### Tech-trend researchers / industry analysts Quarterly AI-grants benchmark: pull `ai_only: true` + `date_range: quarter` for the trailing four quarters, plot the curve. The shape of that curve is one of the half-dozen most-watched leading indicators of where corporate R\&D dollars are flowing. Goldman, Morgan Stanley, Gartner, IDC, and CB Insights all publish reports based on substantially the same data — you can do it yourself for 1% of the cost. #### Litigation watch / patent troll early-warning Patent assertion entity (PAE) filings cluster in specific CPC subgroups. Monitor those subgroups weekly for newly granted patents being assigned to known PAE shell entities. Pre-position your defensive strategy 6-18 months before an infringement letter lands. #### R\&D / freedom-to-operate (FTO) Before shipping a new feature, run `keywords: [""]` + `date_range: year` to surface fresh patents in your space. Catch FTO risks before they catch you. Cross-reference each hit's CPC classes with your existing patent portfolio's CPC classes to map gaps. #### Pharma / biotech compound watch Drug development teams use `cpc_class: A61K` + `keywords: [""]` to watch for newly granted compositions, formulations, and method-of-use patents in their therapeutic area. Critical for both ANDA Paragraph IV strategy and originator IP exclusivity planning. *** ### Pricing — pay per patent record | Event | Cost | |---|---| | Actor start | **$0.01** | | Per patent record returned | **$0.10** | A 5-record smoke test costs **$0.51** total. A 100-record daily competitive-intel sweep costs **$10.01/day** or roughly **$3,600/year** — about 12% of a single LexisNexis PatentSight seat ($30k/yr), with full programmatic access and zero seat licensing. Patent records are priced at $0.10 each (5x our regional stock screeners at $0.02 and 2x our SEC Form 4 at $0.10) because each patent is a discrete, high-value, defensible asset. A single granted patent in a hot CPC subgroup can drive a 6-figure litigation outcome, a 7-figure licensing deal, or a 9-figure M\&A repricing. We anchor price to event value, not byte count. *** ### Data sources & methodology **Primary: Google Patents search index.** Google Patents indexes every newly granted USPTO patent within ~24 hours of publication via the USPTO Bulk Data Service feed. The Google Patents JSON XHR endpoint returns structured records with patent number, title, abstract snippet, primary inventor, primary assignee, grant date, priority date, filing date, and PDF link. We hit the search endpoint with your filters and paginate as needed. **Enrichment: per-patent detail pages.** When `enrich_details: true` (default), the actor fetches each patent's Google Patents detail page and extracts the full CPC class list, the claims count (via `id="CLM-NNNNN"` anchor count on the rendered claims block), the forward-citation count (`Cited by` marker), and the full abstract. Detail enrichment doubles run time but produces a far richer record. For high-volume scans where only the search-result fields are needed, set `enrich_details: false`. **Classification heuristics:** - `is_ai_related` fires if (a) the title or abstract contains any of ~30 AI / ML keywords (`machine learning`, `neural network`, `transformer`, `large language model`, `generative AI`, etc.) or (b) any CPC class starts with `G06N` (computing arrangements based on specific computational models — the canonical AI/ML CPC class). - `is_software` fires if the title / abstract contains software-specific terms (`computer-implemented`, `API`, `algorithm`, etc.) or any CPC class is `G06F`, `G06Q`, or `H04L`. **Underlying data validity.** Every record carries `google_patents_url` and `pdf_url` so you can audit the source patent in two clicks. Patent numbers are canonical USPTO publication numbers (e.g. `US12438891B1`) — paste them straight into PAIR (Patent Application Information Retrieval) or Public PAIR for the official wrapper. **Coverage scope.** US-issued utility patents and design patents are returned. We default to `country=US` and `status=GRANT` to exclude pre-grant publications (kind code A1) and non-USPTO grants. Set `date_range: all` to remove the time-window and pull arbitrary historical grants back to ~1976 (the start of USPTO's full-text database). *** ### How to run **Apify Console** — paste your filter inputs, hit Run, download the dataset as JSON or CSV. **Apify API** (Python): ```python from apify_client import ApifyClient client = ApifyClient("YOUR_TOKEN") run = client.actor("nexgendata/uspto-patent-grants").call(run_input={ "keywords": ["large language model", "transformer"], "assignee_name": "", "date_range": "month", "cpc_class": "G06N", "ai_only": True, "limit": 100, "enrich_details": True }) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item["patent_number"], "—", item["assignee_name"], "—", item["patent_title"][:80], "—", item["claims_count"], "claims") ``` **Schedule it** — Apify Scheduled Tasks. The USPTO publishes new grants every Tuesday morning ET, so a Tuesday 09:00 ET schedule captures the fresh weekly drop. For competitive-intel use cases, run nightly with `date_range: today` and pipe the diff into Slack / Notion / a Snowflake table. *** ### FAQ **How fresh is the data?** Google Patents typically indexes new USPTO grants within 12-24 hours of the official Tuesday publication. The actor pulls live from the Google Patents search index — no caching layer in between. **What about pending (not-yet-granted) applications?** This actor returns granted patents only (`status=GRANT`). For pre-grant publications (kind code A1 — applications published 18 months after filing, before grant), use our `uspto-patent-applications` actor (coming soon). For provisional applications, those are not published by USPTO until / unless they convert to a non-provisional filing. **Can I get the full claims text?** Currently `claims_count` is emitted but the full claims text is not — it would push payload size 10-50x and isn't reliably extractable from the search-result JSON. For the full claims, follow the `google_patents_url` or `pdf_url` in each record. **Does it cover design patents and plant patents?** Utility and design patents are returned (USPTO publication numbers starting with `US` plus 7-8 digits). Plant patents (`USPP` prefix) are included if they match your search. Reissue patents (`USRE` prefix) are included. Provisional applications are excluded (they're not published). **Does it work for non-US jurisdictions (EP, WO, CN)?** This actor restricts to US patents (`country=US`). For European patents use our roadmap EPO actor; for WIPO PCT applications use the WIPO Patentscope actor; for Chinese patents use CNIPA-direct via our China actor fleet. **Why CPC and not USPC?** USPTO retired its legacy US Patent Classification (USPC) system in 2015 and now classifies all new grants in CPC (Cooperative Patent Classification, the joint USPTO-EPO standard). All modern grants carry CPC codes; USPC is legacy-only. **How do I find the CPC code I want?** Search the CPC scheme at https://www.uspto.gov/web/patents/classification/cpc/html/cpc.html or use the Google Patents UI to find a representative patent in your area, note its CPC, and use that as your filter. **Can I monitor multiple assignees simultaneously?** Run the actor once per assignee in parallel via the Apify API; or use `keywords` to OR-search across assignee names embedded as keywords (less precise but faster). For systematic competitive-intel workflows we recommend the parallel-call pattern with a scheduled task per competitor. *** ### NexGenData vs. paid patent intelligence platforms | Tool | Annual cost | API access | USPTO coverage | AI classification | |------|-------------|------------|----------------|-------------------| | **LexisNexis PatentSight** | ~$30,000/seat | Paid add-on | Full | Manual taxonomy | | **Clarivate Derwent Innovation** | ~$25,000/seat | Paid add-on | Full | Editorial tagging | | **Patsnap** | ~$15,000/seat | Paid add-on | Full | AI-tagged | | **Questel Orbit Intelligence** | ~$20,000/seat | Paid add-on | Full | Topic clustering | | **NexGenData USPTO Patent Grants** | **Pay-per-result** | **Native (REST + MCP)** | **Full USPTO** | **CPC + keyword AI flag** | Run this actor at 100 records/day, 250 trading days/year, and your annual cost is approximately **$3,600** — an 85-93% discount vs. the major paid alternatives, with no seat licensing, no minimum commitment, and full programmatic access via Apify's REST API or any of 1,500+ MCP / no-code / Zapier / Make integrations. The trade-offs vs. the paid platforms: - ✅ **Same primary source data** (USPTO grants via Google Patents index — Google Patents is the same data underneath several of the paid platforms' UIs). - ✅ **Same CPC classification** — the global standard. - ✅ **Full programmatic access** — no rate limits, no per-seat licensing. - ❌ No proprietary "patent quality score" — but we emit `claims_count` + `citations_count`, the two raw signals the proprietary scores wrap. - ❌ No built-in family graph (related applications across jurisdictions) — for global patent families, layer this actor with our roadmap EPO + WIPO actors. - ❌ No litigation tagging / standards-essential-patent (SEP) flagging — we emit the raw patent record; pair with a litigation database for the overlay. For 80% of patent-monitoring workflows — competitive cadence tracking, FTO checks, M\&A diligence, R\&D trend research — this actor is functionally equivalent to the paid platforms at 7-15% of the cost. *** ### Built by NexGenData We build data infrastructure for global financial, legal, and IP intelligence desks. 220+ actors live on Apify covering global equities, IPOs, SEC filings, institutional holdings, M\&A, patents, B2B intelligence, and MCP servers for LLM integration. Patent data complements our broader IP-and-legal stack — combine this actor with our SEC filings trackers, IPO Tracker, and institutional-holdings actors to build a fully connected IP-through-public-markets data pipeline. *** ### Explore the NexGenData IP & Capital Markets Suite Patent data sits at the intersection of R\&D, capital markets, and corporate strategy. Pair the USPTO Patent Grants Tracker with NexGenData's IPO, institutional-holdings, activist, and startup-funding trackers to build a fully connected R\&D-through-public-markets pipeline: #### Institutional capital intelligence - 🔗 **[SEC Form 13F Holdings Tracker](https://apify.com/nexgendata/sec-form-13f-holdings-tracker)** — Quarterly hedge-fund and mutual-fund positions. Cross-reference patent-grant velocity with institutional accumulation. - 🔗 **[SEC Schedule 13D/G Activist Tracker](https://apify.com/nexgendata/sec-schedule-13dg-activist-tracker)** — 5%+ activist positions. Detect activists targeting patent-rich tech / biotech companies. #### Capital-markets lifecycle - 🔗 **[IPO Tracker](https://apify.com/nexgendata/ipo-tracker)** — Recent and upcoming IPOs. Combine with this actor to inventory the S-1 issuer's full patent portfolio at filing time. - 🔗 **[Startup Funding Tracker](https://apify.com/nexgendata/startup-funding-tracker)** — Pre-IPO funding rounds. Tie each round to the company's named inventor history. #### Developer / tech-trend leading indicators - 🔗 **[GitHub Trending Repos](https://apify.com/nexgendata/github-trending-repos)** — Daily GitHub-velocity ranking. Patent grants are a lagging IP signal; GitHub trends are a leading R\&D signal. Combine the two to map the full innovation pipeline. #### Multi-asset / specialty - 🔗 **[Finance MCP Server](https://apify.com/nexgendata/finance-mcp-server)** — Unified Model Context Protocol server exposing the full NexGenData IP and capital-markets fleet to Claude, Cursor, and any MCP-aware LLM client. #### Browse the full NexGenData catalog **[→ See all 220+ NexGenData actors at apify.com/nexgendata](https://apify.com/nexgendata?fpr=2ayu9b)** — IP intelligence, equity screeners across 25+ markets, IPO + pre-IPO trackers, SEC filings, institutional holdings, B2B intelligence, MCP servers, and more. *** *** ### Quick Comparison vs. Paid Incumbents How this actor stacks up against the platforms patent and competitive-intelligence teams pay six figures for: | Capability | NexGenData USPTO Patent Grants Tracker | Bloomberg Terminal | PitchBook | Crunchbase Pro | Refinitiv | |------------|:------------------------:|:------------------:|:---------:|:--------------:|:---------:| | Annual cost | **Pay-per-result (~$3,600 typical)** | $24k+/seat | $30–80k/seat | $24k+/seat | $22k+/seat | | Dedicated USPTO patent grants feed | **Yes — native, full history** | Indirect / news | Indirect / news | Indirect / news | Indirect / news | | CPC classification + AI flag emitted per row | **Yes** | No | No | No | No | | Programmatic API (REST + MCP) | **Yes — included** | Paid add-on | Paid add-on | Paid add-on | Paid add-on | | Seat license / annual minimum | **None** | $24k+ | $30k+ | $7k+ | $22k+ | | Self-service, no sales call | **Yes** | No | No | Partial | No | For 80% of patent-monitoring workflows — competitive cadence tracking, FTO checks, M\&A diligence, R\&D trend research — this actor delivers parity coverage at 5–15% of incumbent cost. *** ### Quick Comparison vs. Paid Incumbents How this actor stacks up against the platforms patent and competitive-intelligence teams pay six figures for: | Capability | NexGenData USPTO Patent Grants Tracker | Bloomberg Terminal | PitchBook | Crunchbase Pro | Refinitiv | |------------|:------------------------:|:------------------:|:---------:|:--------------:|:---------:| | Annual cost | **Pay-per-result (~$3,600 typical)** | $24k+/seat | $30–80k/seat | $24k+/seat | $22k+/seat | | Dedicated USPTO patent grants feed | **Yes — native, full history** | Indirect / news | Indirect / news | Indirect / news | Indirect / news | | CPC classification + AI flag emitted per row | **Yes** | No | No | No | No | | Programmatic API (REST + MCP) | **Yes — included** | Paid add-on | Paid add-on | Paid add-on | Paid add-on | | Seat license / annual minimum | **None** | $24k+ | $30k+ | $7k+ | $22k+ | | Self-service, no sales call | **Yes** | No | No | Partial | No | For 80% of patent-monitoring workflows — competitive cadence tracking, FTO checks, M\&A diligence, R\&D trend research — this actor delivers parity coverage at 5–15% of incumbent cost. ### 🚀 Apify affiliate program — Get free credits & save 30% Sign up to Apify via our referral link and you'll get: - **Free starter credits** to test this actor and the rest of our 220+ actor fleet - **30% off platform fees** for the life of your account **[→ Sign up here with NexGenData's affiliate link](https://apify.com/nexgendata?fpr=2ayu9b)** — same Apify, same actors, just cheaper for you and a small kickback that helps us keep building. *Built and maintained by NexGenData — institutional-grade IP, equity, IPO, SEC filings, and B2B data infrastructure on Apify.* # Actor input Schema ## `keywords` (type: `array`): Free-text keywords to search across patent title + abstract. Each keyword becomes an OR clause. Examples: \['machine learning'], \['neural network', 'transformer'], \['CRISPR', 'gene editing'], \['battery', 'lithium-ion']. Leave empty to pull all newly granted patents in the date window (use date\_range + cpc\_class to narrow). Multi-word phrases are treated as exact phrases. ## `assignee_name` (type: `string`): Restrict results to patents granted to a specific assignee (company / institution). Matches partial names, case-insensitive. Examples: 'Apple', 'Google', 'NVIDIA', 'IBM', 'MIT', 'Stanford'. Leave blank to include all assignees. Useful for competitive intelligence — monitor a specific competitor's filing cadence. ## `date_range` (type: `string`): Filter by USPTO grant date (the date the patent was officially issued, not the application or priority date). 'today' = patents granted today only (USPTO publishes grants every Tuesday); 'week' = trailing 7 days; 'month' = trailing 30 days; 'year' = trailing 365 days; 'all' = no date filter (search the full Google Patents index). ## `cpc_class` (type: `string`): Cooperative Patent Classification (CPC) symbol to filter by. Use either the 1-letter section (e.g. 'G' = Physics / G06 = Computing), the 4-character class (e.g. 'G06N' = AI/ML systems, 'H04L' = digital comms, 'A61K' = pharma compositions), or a full subgroup (e.g. 'G06N3/08' = neural-net learning methods). See cpc-tooltip below. Leave blank for any class. ## `ai_only` (type: `boolean`): If true, return only patents flagged as AI / ML related. We mark a patent AI-related when its title or abstract contains terms like 'machine learning', 'neural network', 'deep learning', 'transformer', 'reinforcement learning', 'LLM', 'large language model', 'generative AI', 'natural language processing', 'computer vision', or when its CPC code is G06N (Computing arrangements based on specific computational models). Useful for AI VCs, AI M\&A diligence, and competitive intelligence on AI labs. ## `limit` (type: `integer`): Maximum number of patent grant records to push to the dataset. The Google Patents result page returns up to 100 patents per page; we'll auto-paginate to satisfy your limit. Typical IP-monitoring workflows pull 50-500 records per refresh. For a full daily competitive-intel sweep set to 1000+. ## `enrich_details` (type: `boolean`): If true, fetches each patent's detail page after the search to populate claims\_count, full CPC class list, citations\_count and a longer abstract excerpt. Doubles run time (one extra HTTP request per patent) but produces a far richer record. Recommended for IP / legal due-diligence workflows. If false, only fields available from the search-results JSON are emitted. ## Actor input object example ```json { "keywords": [ "machine learning" ], "assignee_name": "", "date_range": "month", "cpc_class": "", "ai_only": false, "limit": 50, "enrich_details": true } ``` # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "keywords": [ "machine learning" ], "assignee_name": "", "date_range": "month", "cpc_class": "", "ai_only": false, "limit": 50, "enrich_details": true }; // Run the Actor and wait for it to finish const run = await client.actor("nexgendata/uspto-patent-grants").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "keywords": ["machine learning"], "assignee_name": "", "date_range": "month", "cpc_class": "", "ai_only": False, "limit": 50, "enrich_details": True, } # Run the Actor and wait for it to finish run = client.actor("nexgendata/uspto-patent-grants").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "keywords": [ "machine learning" ], "assignee_name": "", "date_range": "month", "cpc_class": "", "ai_only": false, "limit": 50, "enrich_details": true }' | apify call nexgendata/uspto-patent-grants --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=nexgendata/uspto-patent-grants", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "📜 USPTO Patent Grants Tracker — IP & Competitive Intelligence", "description": "Track newly granted US patents from the USPTO with title, assignee, inventors, CPC classes, claims and citation counts, AI/software flags, PDF and Google Patents URLs. IP, legal, M&A and competitive intelligence. Filter by keywords, assignee, CPC, date range, AI-only.", "version": "0.0", "x-build-id": "QPkSEm1kI1qkB5eZc" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/nexgendata~uspto-patent-grants/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-nexgendata-uspto-patent-grants", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/nexgendata~uspto-patent-grants/runs": { "post": { "operationId": "runs-sync-nexgendata-uspto-patent-grants", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/nexgendata~uspto-patent-grants/run-sync": { "post": { "operationId": "run-sync-nexgendata-uspto-patent-grants", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "keywords": { "title": "Keyword search terms", "type": "array", "description": "Free-text keywords to search across patent title + abstract. Each keyword becomes an OR clause. Examples: ['machine learning'], ['neural network', 'transformer'], ['CRISPR', 'gene editing'], ['battery', 'lithium-ion']. Leave empty to pull all newly granted patents in the date window (use date_range + cpc_class to narrow). Multi-word phrases are treated as exact phrases.", "default": [], "items": { "type": "string" } }, "assignee_name": { "title": "Assignee company filter (optional)", "type": "string", "description": "Restrict results to patents granted to a specific assignee (company / institution). Matches partial names, case-insensitive. Examples: 'Apple', 'Google', 'NVIDIA', 'IBM', 'MIT', 'Stanford'. Leave blank to include all assignees. Useful for competitive intelligence — monitor a specific competitor's filing cadence.", "default": "" }, "date_range": { "title": "Grant date range", "enum": [ "today", "week", "month", "year", "all" ], "type": "string", "description": "Filter by USPTO grant date (the date the patent was officially issued, not the application or priority date). 'today' = patents granted today only (USPTO publishes grants every Tuesday); 'week' = trailing 7 days; 'month' = trailing 30 days; 'year' = trailing 365 days; 'all' = no date filter (search the full Google Patents index).", "default": "month" }, "cpc_class": { "title": "CPC class filter (optional)", "type": "string", "description": "Cooperative Patent Classification (CPC) symbol to filter by. Use either the 1-letter section (e.g. 'G' = Physics / G06 = Computing), the 4-character class (e.g. 'G06N' = AI/ML systems, 'H04L' = digital comms, 'A61K' = pharma compositions), or a full subgroup (e.g. 'G06N3/08' = neural-net learning methods). See cpc-tooltip below. Leave blank for any class.", "default": "" }, "ai_only": { "title": "AI / machine-learning patents only", "type": "boolean", "description": "If true, return only patents flagged as AI / ML related. We mark a patent AI-related when its title or abstract contains terms like 'machine learning', 'neural network', 'deep learning', 'transformer', 'reinforcement learning', 'LLM', 'large language model', 'generative AI', 'natural language processing', 'computer vision', or when its CPC code is G06N (Computing arrangements based on specific computational models). Useful for AI VCs, AI M&A diligence, and competitive intelligence on AI labs.", "default": false }, "limit": { "title": "Max patent records to return", "minimum": 1, "maximum": 5000, "type": "integer", "description": "Maximum number of patent grant records to push to the dataset. The Google Patents result page returns up to 100 patents per page; we'll auto-paginate to satisfy your limit. Typical IP-monitoring workflows pull 50-500 records per refresh. For a full daily competitive-intel sweep set to 1000+.", "default": 50 }, "enrich_details": { "title": "Enrich with detail-page data (claims, CPC, citations)", "type": "boolean", "description": "If true, fetches each patent's detail page after the search to populate claims_count, full CPC class list, citations_count and a longer abstract excerpt. Doubles run time (one extra HTTP request per patent) but produces a far richer record. Recommended for IP / legal due-diligence workflows. If false, only fields available from the search-results JSON are emitted.", "default": true } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```