# Patent Landscape Tracker: Who Is Patenting What (`precious_bathmat/patent-landscape-tracker`) Actor

Search a technology area and see which companies are patenting in it, how many filings each has, and whether they are accelerating or backing away. Counted by priority date, so the trend reflects when the work was actually done. No API key.

- **URL**: https://apify.com/precious\_bathmat/patent-landscape-tracker.md
- **Developed by:** [Mariam Ahmed](https://apify.com/precious_bathmat) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 patent page reads

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

## Patent Landscape Tracker: Who Is Patenting What

Search a technology and see **which companies are filing patents in it, and who is accelerating**. Or name your competitors and get their filing history year by year.

No API key, no login, no proxy.

### What does this do?

A list of patents is not an answer to anything. The question people actually have is *who is investing in this area, and is anyone moving?* — and that needs the patents grouped by company, counted by the right date, and compared across years.

```mermaid
flowchart LR
    A[Technology search<br/>or company names] --> B[Google Patents]
    B --> C[Group by company]
    B --> D[Exact filings per year]
    C & D --> E[Ranked: who files here,<br/>and who is accelerating]
```

### Who is it for?

| You are | You use it to |
|---|---|
| **R\&D or product strategy** | See who else is working in your area before committing a roadmap |
| **Competitive intelligence** | Watch a rival's filing rate rise or fall, years before products ship |
| **An investor or scout** | Spot a company quietly building a position in a technology |
| **An IP attorney or analyst** | Get a landscape in one run instead of a week of searching |
| **A journalist** | Back a story about a company's direction with its own filings |

### What data do you get?

One row per company:

| Field | What it is |
|---|---|
| `assignee` | The company, with its separate legal entities folded together |
| `totalMatchingFiled` | How many patents match in total, as Google counts them |
| `patentsRead` | How many were actually read for the detail below |
| `trend`, `whyTrend` | Accelerating, growing, steady, slowing, withdrawing, or new entrant — with the numbers behind it |
| `filingsByPriorityYear` | Filings per year |
| `filingsCountedExactly` | Whether those year counts are exact or from the sample |
| `firstPriorityYear`, `latestPriorityYear` | When they started and last filed |
| `internationalSharePercent` | How much they file abroad, which is what companies do with work they are serious about |
| `grantedSharePercent` | How much has actually granted |
| `topInventors` | Who is named on the filings |
| `officeSpread` | Which patent offices they use |
| `recentPatents` | Their five newest filings, with links |

Switch **What to output** to get one row per patent instead, with numbers, titles, dates and PDF links.

### Example: solid state batteries, filings since 2015

| Company | Filings | Trend | Why |
|---|---|---|---|
| **CATL** (宁德时代) | 45 in sample | **accelerating** | 40 filings in 2022-24 against 5 in 2019-21 — 8x |
| GM Global Technology Operations | 15 | **withdrawing** | 0 in 2022-24 against 10 in 2019-21 |
| LG Energy Solution | 3 | too few to tell | Filings fall outside the comparison window |

CATL filing eight times faster while GM stopped is the entire story of that category in one table, and neither fact appears anywhere on a patent listing.

### Example: named companies, exact counts

Naming the companies changes the quality of the answer. These are complete counts, not a sample:

| Company | Patents matching | Trend | Filings 2022-24 vs 2019-21 |
|---|---|---|---|
| **BYD** | 110,265 | **growing** | 47,868 against 28,210 — 1.7x |
| Tesla | 8,323 | steady | 781 against 664 — 1.2x |

Worth noting what changed: reading a 50-patent *sample* for Tesla suggested it was **withdrawing**, because Google's relevance ranking happened to return older filings. The exact yearly counts show it is steady. That is the difference between counting what you were shown and counting what is there.

### How the numbers are made, and what they are not

- **Counted by priority date, not publication date.** A patent publishes about 18 months after it is filed. Counting by publication tells you what companies were doing two years ago and labels it today.
- **The last two years are always undercounted**, for the same reason, and every row says so. A naive reading of recent years looks like a collapse at every company simultaneously; it is just the publication lag.
- **Named companies get exact yearly counts.** When you name a company, each year is counted from the number of matches for that year, not by reading a sample. This matters: a 50-patent sample for Tesla came back spanning 2015-2020 and made a live company look like it had stopped filing — that was Google's relevance ranking, not Tesla.
- **A technology search reads the highest-ranked matches**, so its counts are of what was read, not of everything that exists. The row says which kind of count you are looking at.
- **Company names are merged carefully, and imperfectly.** Legal suffixes and regional arms are folded together, and when you name a company its separate entities are grouped under the name you asked for. A company filing under both an English and a local-language name may still appear twice; that limit is stated on every row rather than hidden.
- **It stops when Google says stop, and this is the real limit of the Actor.** The endpoint refuses a server that asks too often, and the refusal lasts longer than a run does — during development, repeated test runs got the server refused for several minutes at a time. Requests are paced well under the threshold and a refusal makes everything stand down, but **back-to-back runs will hit it**. When that happens the Actor says plainly that it was refused rather than reporting an empty result as "nothing matched". Leave a few minutes between large runs, or schedule them rather than firing them by hand.

### Popular patent reports

Ready-made runs you can open and start, or copy as a starting point:

- [Patent Landscape for a Technology](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/patent-landscape-by-technology)
- [Competitor Patent Tracking](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/competitor-patent-tracking)
- [AI and Machine Learning Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/ai-patent-landscape)
- [Battery Technology Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/battery-patent-landscape)
- [Semiconductor Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/semiconductor-patent-landscape)
- [Biotech and Pharma Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/biotech-patent-landscape)
- [Quantum Computing Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/quantum-computing-patents)
- [Robotics and Automation Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/robotics-patent-landscape)
- [EV and Charging Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/ev-charging-patents)
- [Medical Device Patent Landscape](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/medical-device-patents)
- [Who Is Patenting AI Chips](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/who-is-patenting-ai-chips)
- [US Patent Filings by Company](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/us-patent-filings-by-company)
- [Chinese Patent Filings by Company](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/chinese-patent-filings)
- [Granted Patents Only, by Company](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/granted-patents-only)
- [Patent List Export](https://apify.com/precious_bathmat/patent-landscape-tracker/examples/patent-list-export)

### Pricing

**$0.003 per page of patents read** (10 patents a page, and one page per year when counting a named company's history) and **$0.01 per company report**.

A technology landscape reading 200 patents costs about **$0.06 plus $0.01 per company found**. Tracking three named companies over ten years costs about **$0.15**.

### Input

| Setting | What it does |
|---|---|
| **Technology to search for** | The area, for example "solid state battery" or "mRNA vaccine" |
| **Companies to track** | Optional. Named companies get exact yearly counts; combine with a technology to see one company in one field |
| **Earliest priority year** | How far back to count |
| **Patent office** | Optional. Limit to US, EP, WO, CN, JP and others |
| **Granted patents only** | Off by default: pending applications are the better signal of current activity |
| **Maximum patents to read** | More detail, more cost |
| **What to output** | One row per company with the trend, or one row per patent |
| **Minimum patents per company** | Keeps one-off filers out of the table |

### Integrations

Runs on a schedule and connects to Google Sheets, Slack, Zapier, Make or your own code through the Apify API. A quarterly run over the same technology turns these snapshots into an early warning that a competitor has started filing.

# Actor input Schema

## `query` (type: `string`):

The technology area, for example "solid state battery" or "mRNA vaccine". Leave empty if you are tracking named companies instead.

## `assignees` (type: `array`):

Optional. Track these companies by name, for example "Samsung" or "Toyota". Combine with a technology to see what one company is doing in one field.

## `sinceYear` (type: `integer`):

Only count filings with a priority date from this year onwards. Priority date is when the work was filed, not when it published.

## `country` (type: `string`):

Optional. Limit to patents filed at one office. WO means an international application.

## `onlyGranted` (type: `boolean`):

Exclude applications that have not been granted. Off by default, because pending applications are the better signal of current activity.

## `maxPatents` (type: `integer`):

How many patent records to read. Each page of 10 costs $0.003. Google refuses a server that asks too often, so keep this modest unless you need depth.

## `outputMode` (type: `string`):

The company roll-up is the point of this Actor. Raw patents are there when you want the underlying rows.

## `minPatentsPerAssignee` (type: `integer`):

Skip companies with fewer filings than this in the set, so the table is not buried under one-offs.

## Actor input object example

```json
{
  "query": "solid state battery",
  "assignees": [],
  "sinceYear": 2015,
  "country": "",
  "onlyGranted": false,
  "maxPatents": 100,
  "outputMode": "assignees",
  "minPatentsPerAssignee": 2
}
```

# Actor output Schema

## `landscape` (type: `string`):

Every company found, most filings first.

## `summary` (type: `string`):

What was searched and how much was read.

# 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("precious_bathmat/patent-landscape-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("precious_bathmat/patent-landscape-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 precious_bathmat/patent-landscape-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,precious_bathmat/patent-landscape-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/NYB3ZSykljYhaCpFl/builds/pUNmTC4OrzgpmHS2C/openapi.json