# Patent Signals — Velocity, Entrants & Expiry Intel (`businessquik/patent-signals`) Actor

Competitive intelligence from official USPTO data: who is filing in a technology area, how fast it's accelerating, who just showed up, how concentrated the space is, and what expires when.

- **URL**: https://apify.com/businessquik/patent-signals.md
- **Developed by:** [Carlos Garcia](https://apify.com/businessquik) (community)
- **Categories:** AI, Agents, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1,500.00 / 1,000 signal report generateds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Patent Signals

Raw patent search is a commodity — every free tool does it. This Actor sells the **answers**: for any technology area, applicant, or keyword, one run returns a structured intelligence report built from official USPTO Open Data Portal records.

### The four signals

1. **Filing velocity** — filings per quarter, with a momentum read (last 4 complete quarters vs the prior 4): `accelerating`, `steady`, or `cooling`.
2. **New entrants** — applicants whose *first-ever* filing in this space landed in the last 12 months, ranked by how hard they're filing. This is the "who just showed up" list.
3. **Concentration** — top applicants by share plus a normalized HHI: is this a locked-up incumbent space or an open field?
4. **Expiry calendar** — granted patents whose ~20-year term ends within 5 years, sorted by date. Freedom-to-operate planning starts here.

### Input

| Field | Description |
|---|---|
| `apiKey` | **Required.** Free USPTO Open Data Portal key — data.uspto.gov → sign in → My API keys |
| `query` | CPC code (`G06N` = machine learning, `A61K` = pharma prep…), keyword, or applicant name |
| `queryType` | `cpc`, `keyword`, or `applicant` |
| `yearsBack` | Analysis window (default 4) |
| `maxRecords` | Fetch cap (default 2,000) |

### Output

One report record per run:

```json
{
  "query": "G06N",
  "records_analysed": 2000,
  "velocity": { "trend": "accelerating", "momentum_pct": 34.2, "series": [ ... ] },
  "new_entrants_12mo": [ { "applicant": "Beta AI Inc", "filings": 12, "first_filing": "2026-02-11" } ],
  "concentration": { "hhi": 0.19, "reading": "concentrated — incumbents dominate", "top_applicants": [ ... ] },
  "expiry_calendar_5y": [ { "applicant": "…", "approx_expiry": "2030-03-10" } ],
  "caveats": [ ... ]
}
```

### Who this is for

- **Competitive intelligence & strategy** — quarterly technology-space scans
- **VC / PE diligence** — is the target filing? Is the space defensible? Who else is moving in?
- **IP consultants & tech-transfer offices** — client-ready signals without a patent-analytics subscription
- **R\&D leadership** — watch your own field's momentum

### Honest caveats (also embedded in every report)

- Expiry dates approximate 20-years-from-filing; patent term adjustments (PTA/PTE) and maintenance-fee lapses are not applied.
- Applicant names appear as filed — one company can appear under name variants.
- Patent records are US federal public-domain data; inventor/applicant names are part of the public record.

### Pricing

| Event | Price |
|---|---|
| Run start | $0.05 |
| Per signal report | $1.50 |

One report: **$1.55** — versus $99+/month patent-analytics platforms or an afternoon of manual searching.

### FAQ

**Do I need my own USPTO API key?**
Yes, for live analysis — a free key from data.uspto.gov (requires a USPTO.gov account). Without a key, the Actor returns a clearly-labeled demo report so you can see the output shape first.

**Why does it return a report instead of raw patent records?**
Raw patent search is free everywhere. This Actor sells the aggregation: filing velocity with momentum, first-time entrants, market concentration (HHI), and an expiry calendar — the analysis layer you'd otherwise build in a spreadsheet.

**How accurate are the expiry dates?**
They approximate 20-years-from-filing. Patent term adjustments (PTA/PTE) and maintenance-fee lapses are not applied — every report embeds this caveat. Use the calendar for planning, verify individual patents before acting.

**What's a CPC code and where do I find mine?**
The Cooperative Patent Classification system — e.g. G06N is machine learning, A61K is pharma preparations. Search "CPC scheme" + your technology to find your class.

**Can I analyze a competitor instead of a technology?**
Yes — set `queryType` to `applicant` and pass the company name.

### Changelog

- **2026-08-22** — Live USPTO Open Data Portal verification; applicant names now resolved from `applicantBag` when the primary field is empty; no-key demo mode.
- **2026-08-20** — Launch: velocity, entrants, concentration, and expiry-calendar reports.

***

### More tools by Businessquik

Verified data tools built on official and public-mandate sources — no logins, no gray areas, no fragile scrapers:

- [Bank Statement Extractor — PDF statements to reconciled CSV/JSON](https://apify.com/businessquik/bank-statement-extractor)
- [Hospital Price File Normalizer — comparable hospital prices from CMS MRFs](https://apify.com/businessquik/hospital-mrf-normalizer)
- [FDA Recall Monitor — new-recalls-only alerts for drugs, devices & food](https://apify.com/businessquik/fda-recall-monitor)
- [US Location Profile — economy, labor & weather in one call](https://apify.com/businessquik/location-profile)

**Support:** open an issue on this Actor's Issues tab — layout/format reports are usually fixed within days. Describe the *shape* of your file or query; never post real bank statements or sensitive data.

# Actor input Schema

## `apiKey` (type: `string`):

Free key from data.uspto.gov (My API keys). Required — USPTO's API needs it.

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

USPTO search query — a CPC class (e.g. cpc=G06N for machine learning), keyword, or applicant name.

## `queryType` (type: `string`):

How to interpret the query: CPC classification code, keyword in the invention title, or applicant/assignee name.

## `yearsBack` (type: `integer`):

How many years of filings to analyse.

## `maxRecords` (type: `integer`):

Cap on applications pulled from USPTO (cost + runtime control).

## Actor input object example

```json
{
  "query": "G06N",
  "queryType": "cpc",
  "yearsBack": 4,
  "maxRecords": 2000
}
```

# 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 = {
    "query": "G06N"
};

// Run the Actor and wait for it to finish
const run = await client.actor("businessquik/patent-signals").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 = { "query": "G06N" }

# Run the Actor and wait for it to finish
run = client.actor("businessquik/patent-signals").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 '{
  "query": "G06N"
}' |
apify call businessquik/patent-signals --silent --output-dataset

```

## MCP server setup

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

```

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/VR3XJC1VnBmG3cxt4/builds/TaefrAHktaxyU87C0/openapi.json