canonical: https://jentic.com/apis/patentdata.ai/patentdata

# Patentdata Patent Status API

The Patent Status API returns the current status of US patent applications and granted patents from its own copy of USPTO bulk data, in compact JSON with stable field names. It covers prosecution timelines, office actions with text, ownership assignments, maintenance fees and expiration, PTAB challenges, and patent claims and citations. Company and inventor names resolve to entity ids with portfolio statistics, examiner and art-unit allowance rates are available, and monitors send webhooks when watched applications, patents, or entities change. Every object carries a source block naming the USPTO bulk file it came from plus as_of and stale freshness flags.

## For AI agents

Look up the live status, prosecution history, office actions, ownership, maintenance, and PTAB challenges of US patents and applications, resolve companies to patent portfolios, and set monitors that fire webhooks on new events.

## Scope

Does not file patent applications, cover non-US patent offices, or handle trademark records. Use for reading US patent and application status, prosecution, ownership, and PTAB data only.

## Capabilities

- Check the current status of a US application, granted patent, or pre-grant publication by its number
- Read an application's prosecution timeline and office actions, optionally with the examiner's rejection text via include_text
- Look up ownership assignments for a patent or application, or search assignments received by an assignee since a recorded_after date
- Confirm whether a patent is still alive from its maintenance fee record and expiration
- Resolve a company or inventor name to an entity id and pull its applications, granted patents, and portfolio stats
- Find PTAB proceedings against a patent or search them by petitioner, patent_owner, or status
- Watch applications, patents, or entities with a monitor that posts events to your webhook_url

## Use cases

### Agent patent status checks through Jentic

A legal or IP research agent finds the Patent Status operations through Jentic by intent, then calls GET `/v1/applications/{application_number}` or GET `/v1/patents/{patent_number}` for the current status, and follows up with transactions or office actions for detail. Each response includes the USPTO source file and a stale flag, so the agent can tell how fresh the answer is. Jentic injects the key at call time, so the agent never handles it.

Example prompt: Call GET `/v1/applications/16123456` to read its status, then GET `/v1/applications/16123456/transactions` with since '2026-01-01' to list new prosecution events

### Competitor portfolio research

Resolve a company name to an entity id with GET `/v1/entities/search`, then read GET `/v1/entities/{entity_id}/stats` for portfolio size, velocity, technology mix, examiners, PTAB exposure, and deals. GET `/v1/entities/{entity_id}/applications` with a status filter lists the pending pipeline, and GET `/v1/entities/{entity_id}/patents` lists granted patents, giving an analyst a portfolio picture without bulk-file processing.

Example prompt: Call GET `/v1/entities/search` with q 'Acme Robotics' and type company, take the top entity id, then GET `/v1/entities/{entity_id}/applications` with status 'pending'

### Freedom-to-operate and validity checks

Before relying on or challenging a patent, confirm whether it is alive with GET `/v1/patents/{patent_number}/maintenance`, read its claims and CPC classes from GET `/v1/patents/{patent_number}/claims`, check PTAB challenges with GET `/v1/patents/{patent_number}/ptab`, and trace its citations in either direction. Ownership records from the assignments endpoint show who currently holds it.

Example prompt: For patent 10123456 call GET `/v1/patents/10123456/maintenance`, GET `/v1/patents/10123456/ptab`, and GET `/v1/patents/10123456/assignments`, then summarise whether it is in force, challenged, and who owns it

### Docket monitoring with webhooks

Docketing teams create a monitor with POST `/v1/monitors`, passing the targets to watch and a webhook_url, plus optional event types and a signing secret. Matched events and their delivery status are readable from GET `/v1/monitors/{monitor_id}/events`, and GET `/v1/events` offers a pollable feed filtered by application_numbers, patent_numbers, or entity_ids for teams that prefer polling.

Example prompt: POST `/v1/monitors` with targets for applications 16123456 and 17234567 and webhook_url 'https://example.com/hooks/patents', then read GET `/v1/monitors/{monitor_id}/events` to confirm deliveries

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/v1/applications/{application_number}` | Current status of one application |
| POST | `/v1/applications/status` | Status of many applications in one call |
| GET | `/v1/applications/{application_number}/office-actions` | Office actions with text |
| GET | `/v1/patents/{patent_number}/maintenance` | Maintenance fees and expiration |
| GET | `/v1/entities/search` | Resolve a company or inventor name to an entity id |
| GET | `/v1/search` | Find patents and applications by keyword, CPC, date, and owner |
| POST | `/v1/monitors` | Create a monitor with webhooks |

## Key resources

- **Applications** — Current status, batch status, prosecution transactions, office actions, and assignments of US applications
- **Patents** — Status, claims, citations, assignments, maintenance fees, and PTAB challenges of granted patents
- **Entities** — Resolve company or inventor names to entity ids with portfolio applications, patents, and stats
- **PTAB** — Search PTAB proceedings and read one proceeding with its decisions
- **Monitors and events** — Watch targets with webhook monitors or poll the events feed

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 66 / 100
- **Maturity:** AI-Aware
- **Dimensions:**
  - Foundational Compliance: 93 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 50 / 100
  - Agent Usability: 94 / 100
  - Security: 55 / 100
  - AI Discoverability: 76 / 100
- **View full report:** https://jentic.com/apis/patentdata.ai/patentdata/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring the Patent Status API by hand means choosing between its X-API-KEY header and bearer form, handling the credit-metered responses, and mapping USPTO number formats yourself. Through Jentic you install once, import the API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** The API puts the application number, patent number, and entity id in the URL path, so a rule can pin your agent to one application such as `/v1/applications/16123456` and the read operations you pick. You choose the operations it may call, so actions like minting keys, creating checkout links, or deleting monitors are not included unless you add them.
- **Credential handling:** Your Patent Status API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'check a patent application status' or 'find a company's patents', and Jentic returns the matching Patent Status operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **USPTO Bulk Data Storage System** — The USPTO's own bulk data product and file listings
- **Marker Trademark Search API** — Searches USPTO trademark records by name, owner, or serial number
- **TIPO Open Data API** — Taiwan patent and trademark open data from the Taiwan IP office

## FAQ

### What authentication does the Patent Status API use?

Per its OpenAPI spec, the Patent Status API accepts an API key in the `X-API-KEY` header or the same key as an HTTP bearer token in the Authorization header. Through Jentic the key is stored encrypted by your own Jentic One instance and injected at call time, so it never enters the agent's context.

### Can I check many patent applications at once?

Yes. POST `/v1/applications/status` takes an application_numbers list in the body and returns the status of each in one call. Application numbers are 8-digit strings. For ongoing tracking, a monitor created with POST `/v1/monitors` pushes events to your webhook instead of re-polling.

### How do I find a company's pending applications through Jentic?

Search Jentic for 'find a company's pending patent applications', call GET `/v1/entities/search` with the company name to get its entity id, then call GET `/v1/entities/{entity_id}/applications` with status set to pending. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### What are the rate limits for the Patent Status API?

The API description in the OpenAPI spec states there are no rate limits per key. Usage is metered in credits instead, and each response carries an `X-Credits-Charged` header with what it cost. See https://patentdata.ai for current pricing.

### How fresh is the patent data?

Every object carries a source block naming the USPTO bulk file and its file_date, an as_of date for the last ingest of that table, and a stale flag that is true when the copy is older than the product's update cadence. GET /health reports service and data freshness across tables.

### Is there a Patent Status MCP server?

You don't need an MCP server to give your agent the Patent Status API. Jentic connects it directly from the API Directory: import it, store your API key once, and your agent calls it. Operations are discovered on demand, so no extra tool definitions sit in the agent's context.

### Can I limit what my agent is allowed to do with the Patent Status API?

Yes. For example, allow only GET operations under `/v1/applications` and `/v1/patents`, so the agent can read status, office actions, and maintenance records but cannot mint keys, create checkout links, or create and delete monitors. Every call it makes is logged by your Jentic One instance.