# Patent Search Tracker (`gochujang/patent-search-tracker`) Actor

Search US patents using PatentsView API: keyword search, inventor, assignee, CPC classification, and date range. Returns title, abstract, inventors, assignees, citations, filing date, grant date, and claims count. Free public API, no key required.

- **URL**: https://apify.com/gochujang/patent-search-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Education
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Patent Search Tracker do?

**Patent Search Tracker** searches US patents via the free PatentsView API (powered by the USPTO) and returns structured records enriched with **impact scores, patent age, years until expiry, citation density, and inventor analytics** — no API key or subscription required. Search by keyword, assignee company, inventor name, or date range, and sort by grant date or citation count to surface the most influential patents in any technology domain. Schedule runs on Apify to continuously monitor new filings from competitors or track the evolution of a technology landscape over time.

### Why use Patent Search Tracker?

- **Free public USPTO data with zero setup** — the Actor queries PatentsView, a publicly funded API maintained by the US Department of Commerce, so there is no API key to register for, no rate-limit fees, and no scraping involved.
- **Rich computed analytics per patent** — beyond raw metadata, each record includes a composite **impact score** (0–100 from citation count and claims breadth), **patent age in years**, **estimated years until expiry**, and a **citation density per claim** metric for normalised influence measurement.
- **Multi-dimensional search in one run** — combine keyword search across titles and abstracts with assignee organisation filtering and inventor name lookup in a single query; add date ranges to isolate recent filings or expired prior art.
- **Competitive IP intelligence** — look up every patent filed by Apple, Google, or any competitor in a specific technology area; the `assignee_country_count` field reveals the geographic spread of their IP portfolio.
- **Flexible sorting for different research goals** — sort by `date_desc` for the latest grants, `date_asc` for historical context, or `citations_desc` to find the most-cited (most influential) patents in a domain.

### How to use Patent Search Tracker

1. Go to the [Apify Store](https://apify.com/store) and find **Patent Search Tracker**.
2. Click **Try for free** to open the input configuration form.
3. Enter at least one of: a **Keyword** (searched in patent title and abstract), an **Assignee** company name, or an **Inventor** last name.
4. Optionally set **Date From** and **Date To** in `YYYY-MM-DD` format to filter by grant date range.
5. Set **Max Results** (1–200) and choose a **Sort By** order.
6. Click **Start** — results typically arrive within a few seconds to a minute depending on result count.
7. Download the dataset as JSON, CSV, or Excel, or integrate via the Apify API.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keyword` | string | — | Search term matched against patent title and abstract |
| `assignee` | string | — | Assignee organisation name (e.g. `Apple Inc`, `Google LLC`) |
| `inventor` | string | — | Inventor last name to search for |
| `dateFrom` | string | — | Grant date lower bound in `YYYY-MM-DD` format |
| `dateTo` | string | — | Grant date upper bound in `YYYY-MM-DD` format |
| `maxResults` | integer | 25 | Maximum patents to return (1–200) |
| `sortBy` | string | `date_desc` | Sort order: `date_desc`, `date_asc`, `citations_desc` |

### Output

```json
[
  {
    "patent_number": "11987654",
    "title": "Transformer-based neural network for on-device image recognition",
    "abstract": "A neural network architecture employing multi-head self-attention mechanisms optimised for inference on low-power edge devices...",
    "grant_date": "2024-03-12",
    "patent_year": 2024,
    "patent_type": "utility",
    "inventors": [
      { "first_name": "Sarah", "last_name": "Chen" },
      { "first_name": "Raj", "last_name": "Patel" }
    ],
    "assignees": [
      { "organization": "Apple Inc", "country": "US" }
    ],
    "citations_count": 14,
    "claims_count": 22,
    "processing_time_days": 1248,
    "patent_age_years": 2.5,
    "years_until_expiry": 17.5,
    "age_tier": "very_recent",
    "impact_score": 62.4,
    "inventor_count": 2,
    "assignee_country_count": 1,
    "claims_per_inventor": 11.0,
    "citation_density_per_claim": 0.6364
  },
  {
    "patent_number": "10543210",
    "title": "Method and apparatus for real-time supply chain visibility using distributed ledger",
    "abstract": "Systems and methods for tracking goods across global supply chains using a permissioned blockchain network...",
    "grant_date": "2020-01-28",
    "patent_year": 2020,
    "patent_type": "utility",
    "inventors": [
      { "first_name": "James", "last_name": "Morrison" }
    ],
    "assignees": [
      { "organization": "IBM Corp", "country": "US" }
    ],
    "citations_count": 83,
    "claims_count": 30,
    "processing_time_days": 1102,
    "patent_age_years": 6.6,
    "years_until_expiry": 13.4,
    "age_tier": "mature",
    "impact_score": 80.25,
    "inventor_count": 1,
    "assignee_country_count": 1,
    "claims_per_inventor": 30.0,
    "citation_density_per_claim": 2.7667
  }
]
```

### Data fields

| Field | Description |
|-------|-------------|
| `patent_number` | USPTO patent number |
| `title` | Patent title |
| `abstract` | Patent abstract (up to 1,000 characters) |
| `grant_date` | Date the patent was granted (YYYY-MM-DD) |
| `patent_year` | Year of grant |
| `patent_type` | Patent type (e.g. `utility`, `design`, `plant`) |
| `inventors` | List of `{first_name, last_name}` objects for each inventor |
| `assignees` | List of `{organization, country}` objects for each assignee |
| `citations_count` | Number of times this patent has been cited by later patents |
| `claims_count` | Total number of patent claims — proxy for scope of protection |
| `processing_time_days` | Days from filing to grant |
| `patent_age_years` | How many years have elapsed since the grant date |
| `years_until_expiry` | Estimated years remaining before 20-year term expiry (negative if expired) |
| `age_tier` | `very_recent`, `recent`, `mature`, `aging`, `near_expiry_or_expired` |
| `impact_score` | 0–100 composite of log-scaled citations (70 pts) + claims breadth (30 pts) |
| `inventor_count` | Number of named inventors — proxy for team size |
| `assignee_country_count` | Distinct countries among assignees — geographic IP diversity |
| `claims_per_inventor` | Average claims per inventor — individual productivity metric |
| `citation_density_per_claim` | Citations divided by claims — normalised influence score |

### Cost estimation

Pricing is **Pay-Per-Event** at **$0.002 per patent fetched**.

| Scenario | Patents | Estimated cost |
|----------|---------|----------------|
| Small — 25 patents (default) | 25 | $0.05 |
| Medium — 100 patents | 100 | $0.20 |
| Large — 200 patents | 200 | $0.40 |

A comprehensive technology landscape study covering 200 patents costs under $0.50. The PatentsView API is fully free and publicly funded, so there are no upstream data costs.

### FAQ

**Q: Does this cover international patents (EPO, WIPO, JPO)?**
A: The Actor currently queries PatentsView which covers USPTO-granted US patents only. For international patent coverage, you would need to use additional data sources. US patents are the most commonly analysed for competitive intelligence given the size and transparency of the USPTO dataset.

**Q: How current is the patent data?**
A: PatentsView updates weekly with newly granted patents from the USPTO. The most recently granted patents typically appear within one to two weeks of their official grant date. Use `sortBy: date_desc` and set `dateFrom` to the prior week to fetch only the newest filings in a scheduled run.

**Q: What is the impact score and how should I interpret it?**
A: The impact score is a 0–100 composite designed to surface influential patents. It weights citation count on a logarithmic scale (up to 70 points) to prevent a single highly-cited outlier from dominating, and adds up to 30 points for broad claim scope. A score above 60 generally indicates a widely-cited patent with substantial claim coverage; below 20 suggests a narrowly scoped or rarely cited patent.

This Actor queries the PatentsView public API, which is operated by the US Department of Commerce and funded by the USPTO. Patent data is in the public domain. The Actor does not access any private patent filing information or confidential prosecution history. Patent term calculations use a simplified 20-year-from-grant rule and do not account for maintenance fees, terminal disclaimers, or patent term adjustments; consult a patent attorney for legal expiry determinations.

Keywords: US patent search API, patent database scraper, USPTO patent tracker, PatentsView API, patent competitive intelligence, IP landscape analysis, patent citation analysis, inventor search tool, assignee patent lookup, patent expiry tracker

***

### Related actors

- [Semantic Scholar Papers](https://apify.com/gochujang/semantic-scholar-papers) — Academic papers cited in patents to understand the research foundations
- [GitHub Repo Analytics](https://apify.com/gochujang/github-repo-analytics) — Open source implementations related to patented technologies
- [AI Model Benchmark Tracker](https://apify.com/gochujang/ai-model-benchmark-tracker) — AI patent landscape alongside actual model performance benchmarks

### Feedback

If this actor powers your IP research, a review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/patent-search-tracker#reviews)

# Actor input Schema

## `keyword` (type: `string`):

Search keywords in patent title and abstract

## `assignee` (type: `string`):

Company or organization that owns the patent (e.g. 'Apple Inc', 'Google LLC')

## `inventor` (type: `string`):

Inventor last name to search for

## `dateFrom` (type: `string`):

Only return patents granted after this date (YYYY-MM-DD)

## `dateTo` (type: `string`):

Only return patents granted before this date (YYYY-MM-DD)

## `maxResults` (type: `integer`):

Maximum number of patents to return

## `sortBy` (type: `string`):

How to sort results

## Actor input object example

```json
{
  "maxResults": 25,
  "sortBy": "date_desc"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/patent-search-tracker").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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/patent-search-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call gochujang/patent-search-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/patent-search-tracker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/LJJc7ikbauWJ2XhQS/builds/9hYruYefY6UCoXEME/openapi.json