uspto-database

USPTO provides specialized APIs for patent and trademark data. Search patents by keywords/inventors/assignees, retrieve examination history via PEDS, track assignments, analyze citations and office actions, access TSDR for trademarks, for IP analysis and prior art searches.

This skill should be used when:

• Patent Search: Finding patents by keywords, inventors, assignees, classifications, or dates
• Patent Details: Retrieving full patent data including claims, abstracts, citations
• Trademark Search: Looking up trademarks by serial or registration number
• Trademark Status: Checking trademark status, ownership, and prosecution history
• Examination History: Accessing patent prosecution data from PEDS (Patent Examination Data System)
• Office Actions: Retrieving office action text, citations, and rejections
• Assignments: Tracking patent/trademark ownership transfers
• Citations: Analyzing patent citations (forward and backward)
• Litigation: Accessing patent litigation records
• Portfolio Analysis: Analyzing patent/trademark portfolios for companies or inventors

The USPTO provides multiple specialized APIs for different data needs:

Core APIs

1. PatentSearch API - Modern ElasticSearch-based patent search (replaced legacy PatentsView in May 2025)

- Search patents by keywords, inventors, assignees, classifications, dates

- Access to patent data through June 30, 2025

- 45 requests/minute rate limit

- Base URL: https://search.patentsview.org/api/v1/

1. PEDS (Patent Examination Data System) - Patent examination history

- Application status and transaction history from 1981-present

- Office action dates and examination events

- Use uspto-opendata-python Python library

- Replaced: PAIR Bulk Data (PBD) - decommissioned

1. TSDR (Trademark Status & Document Retrieval) - Trademark data

- Trademark status, ownership, prosecution history

- Search by serial or registration number

- Base URL: https://tsdrapi.uspto.gov/ts/cd/

Additional APIs

1. Patent Assignment Search - Ownership records and transfers
2. Trademark Assignment Search - Trademark ownership changes
3. Enriched Citation API - Patent citation analysis
4. Office Action Text Retrieval - Full text of office actions
5. Office Action Citations - Citations from office actions
6. Office Action Rejection - Rejection reasons and types
7. PTAB API - Patent Trial and Appeal Board proceedings
8. Patent Litigation Cases - Federal district court litigation data
9. Cancer Moonshot Data Set - Cancer-related patents

API Key Registration

All USPTO APIs require an API key. Register at:

https://account.uspto.gov/api-manager/

Set the API key as an environment variable:

```bash

export USPTO_API_KEY="your_api_key_here"

```

Helper Scripts

This skill includes Python scripts for common operations:

• scripts/patent_search.py - PatentSearch API client for searching patents
• scripts/peds_client.py - PEDS client for examination history
• scripts/trademark_client.py - TSDR client for trademark data

Using the PatentSearch API

The PatentSearch API uses a JSON query language with various operators for flexible searching.

#### Basic Patent Search Examples

Search by keywords in abstract:

```python

from scripts.patent_search import PatentSearchClient

client = PatentSearchClient()

# Search for machine learning patents

results = client.search_patents({

"patent_abstract": {"_text_all": ["machine", "learning"]}

})

for patent in results['patents']:

print(f"{patent['patent_number']}: {patent['patent_title']}")

```

Search by inventor:

```python

results = client.search_by_inventor("John Smith")

```

Search by assignee/company:

```python

results = client.search_by_assignee("Google")

```

Search by date range:

```python

results = client.search_by_date_range("2024-01-01", "2024-12-31")

```

Search by CPC classification:

```python

results = client.search_by_classification("H04N") # Video/image tech

```

#### Advanced Patent Search

Combine multiple criteria with logical operators:

```python

results = client.advanced_search(

keywords=["artificial", "intelligence"],

assignee="Microsoft",

start_date="2023-01-01",

end_date="2024-12-31",

cpc_codes=["G06N", "G06F"] # AI and computing classifications

)

```

#### Direct API Usage

For complex queries, use the API directly:

```python

import requests

url = "https://search.patentsview.org/api/v1/patent"

headers = {

"X-Api-Key": "YOUR_API_KEY",

"Content-Type": "application/json"

}

query = {

"q": {

"_and": [

{"patent_date": {"_gte": "2024-01-01"}},

{"assignee_organization": {"_text_any": ["Google", "Alphabet"]}},

{"cpc_subclass_id": ["G06N", "H04N"]}

]

},

"f": ["patent_number", "patent_title", "patent_date", "inventor_name"],

"s": [{"patent_date": "desc"}],

"o": {"per_page": 100, "page": 1}

}

response = requests.post(url, headers=headers, json=query)

results = response.json()

```

Query Operators

• Equality: {"field": "value"} or {"field": {"_eq": "value"}}
• Comparison: _gt, _gte, _lt, _lte, _neq
• Text search: _text_all, _text_any, _text_phrase
• String matching: _begins, _contains
• Logical: _and, _or, _not

Best Practice: Use _text_* operators for text fields (more performant than _contains or _begins)

Available Patent Endpoints

• /patent - Granted patents
• /publication - Pregrant publications
• /inventor - Inventor information
• /assignee - Assignee information
• /cpc_subclass, /cpc_at_issue - CPC classifications
• /uspc - US Patent Classification
• /ipc - International Patent Classification
• /claims, /brief_summary_text, /detail_description_text - Text data (beta)

Reference Documentation

See references/patentsearch_api.md for complete PatentSearch API documentation including:

• All available endpoints
• Complete field reference
• Query syntax and examples
• Response formats
• Rate limits and best practices

Using PEDS (Patent Examination Data System)

PEDS provides comprehensive prosecution history including transaction events, status changes, and examination timeline.

#### Installation

```bash

uv pip install uspto-opendata-python

```

#### Basic PEDS Usage

Get application data:

```python

from scripts.peds_client import PEDSHelper

helper = PEDSHelper()

# By application number

app_data = helper.get_application("16123456")

print(f"Title: {app_data['title']}")

print(f"Status: {app_data['app_status']}")

# By patent number

patent_data = helper.get_patent("11234567")

```

Get transaction history:

```python

transactions = helper.get_transaction_history("16123456")

for trans in transactions:

print(f"{trans['date']}: {trans['code']} - {trans['description']}")

```

Get office actions:

```python

office_actions = helper.get_office_actions("16123456")

for oa in office_actions:

if oa['code'] == 'CTNF':

print(f"Non-final rejection: {oa['date']}")

elif oa['code'] == 'CTFR':

print(f"Final rejection: {oa['date']}")

elif oa['code'] == 'NOA':

print(f"Notice of allowance: {oa['date']}")

```

Get status summary:

```python

summary = helper.get_status_summary("16123456")

print(f"Current status: {summary['current_status']}")

print(f"Filing date: {summary['filing_date']}")

print(f"Pendency: {summary['pendency_days']} days")

if summary['is_patented']:

print(f"Patent number: {summary['patent_number']}")

print(f"Issue date: {summary['issue_date']}")

```

#### Prosecution Analysis

Analyze prosecution patterns:

```python

analysis = helper.analyze_prosecution("16123456")

print(f"Total office actions: {analysis['total_office_actions']}")

print(f"Non-final rejections: {analysis['non_final_rejections']}")

print(f"Final rejections: {analysis['final_rejections']}")

print(f"Allowed: {analysis['allowance']}")

print(f"Responses filed: {analysis['responses']}")

```

Common Transaction Codes

• CTNF - Non-final rejection mailed
• CTFR - Final rejection mailed
• NOA - Notice of allowance mailed
• WRIT - Response filed
• ISS.FEE - Issue fee payment
• ABND - Application abandoned
• AOPF - Office action mailed

Reference Documentation

See references/peds_api.md for complete PEDS documentation including:

• All available data fields
• Transaction code reference
• Python library usage
• Portfolio analysis examples

Using TSDR (Trademark Status & Document Retrieval)

Access trademark status, ownership, and prosecution history.

#### Basic Trademark Usage

Get trademark by serial number:

```python

from scripts.trademark_client import TrademarkClient

client = TrademarkClient()

# By serial number

tm_data = client.get_trademark_by_serial("87654321")

# By registration number

tm_data = client.get_trademark_by_registration("5678901")

```

Get trademark status:

```python

status = client.get_trademark_status("87654321")

print(f"Mark: {status['mark_text']}")

print(f"Status: {status['status']}")

print(f"Filing date: {status['filing_date']}")

if status['is_registered']:

print(f"Registration #: {status['registration_number']}")

print(f"Registration date: {status['registration_date']}")

```

Check trademark health:

```python

health = client.check_trademark_health("87654321")

print(f"Mark: {health['mark']}")

print(f"Status: {health['status']}")

for alert in health['alerts']:

print(alert)

if health['needs_attention']:

print("⚠️ This mark needs attention!")

```

#### Trademark Portfolio Monitoring

Monitor multiple trademarks:

```python

def monitor_portfolio(serial_numbers, api_key):

"""Monitor trademark portfolio health."""

client = TrademarkClient(api_key)

results = {

'active': [],

'pending': [],

'problems': []

}

for sn in serial_numbers:

health = client.check_trademark_health(sn)

if 'REGISTERED' in health['status']:

results['active'].append(health)

elif 'PENDING' in health['status'] or 'PUBLISHED' in health['status']:

results['pending'].append(health)

elif health['needs_attention']:

results['problems'].append(health)

return results

```

Common Trademark Statuses

• REGISTERED - Active registered mark
• PENDING - Under examination
• PUBLISHED FOR OPPOSITION - In opposition period
• ABANDONED - Application abandoned
• CANCELLED - Registration cancelled
• SUSPENDED - Examination suspended
• REGISTERED AND RENEWED - Registration renewed

Reference Documentation

See references/trademark_api.md for complete trademark API documentation including:

• TSDR API reference
• Trademark Assignment Search API
• All status codes
• Prosecution history access
• Ownership tracking

Patent and Trademark Assignments

Both patents and trademarks have Assignment Search APIs for tracking ownership changes.

#### Patent Assignment API

Base URL: https://assignment-api.uspto.gov/patent/v1.4/

Search by patent number:

```python

import requests

import xml.etree.ElementTree as ET

def get_patent_assignments(patent_number, api_key):

url = f"https://assignment-api.uspto.gov/patent/v1.4/assignment/patent/{patent_number}"

headers = {"X-Api-Key": api_key}

response = requests.get(url, headers=headers)

if response.status_code == 200:

return response.text # Returns XML

assignments_xml = get_patent_assignments("11234567", api_key)

root = ET.fromstring(assignments_xml)

for assignment in root.findall('.//assignment'):

recorded_date = assignment.find('recordedDate').text

assignor = assignment.find('.//assignor/name').text

assignee = assignment.find('.//assignee/name').text

conveyance = assignment.find('conveyanceText').text

print(f"{recorded_date}: {assignor} → {assignee}")

print(f" Type: {conveyance}\n")

```

Search by company name:

```python

def find_company_patents(company_name, api_key):

url = "https://assignment-api.uspto.gov/patent/v1.4/assignment/search"

headers = {"X-Api-Key": api_key}

data = {"criteria": {"assigneeName": company_name}}

response = requests.post(url, headers=headers, json=data)

return response.text

```

Common Assignment Types

• ASSIGNMENT OF ASSIGNORS INTEREST - Ownership transfer
• SECURITY AGREEMENT - Collateral/security interest
• MERGER - Corporate merger
• CHANGE OF NAME - Name change
• ASSIGNMENT OF PARTIAL INTEREST - Partial ownership

Office Actions, Citations, and Litigation

Multiple specialized APIs provide additional patent data.

#### Office Action Text Retrieval

Retrieve full text of office actions using application number. Integrate with PEDS to identify which office actions exist, then retrieve full text.

#### Enriched Citation API

Analyze patent citations:

• Forward citations (patents citing this patent)
• Backward citations (prior art cited)
• Examiner vs. applicant citations
• Citation context

#### Patent Litigation Cases API

Access federal district court patent litigation records:

• 74,623+ litigation records
• Patents asserted
• Parties and venues
• Case outcomes

#### PTAB API

Patent Trial and Appeal Board proceedings:

• Inter partes review (IPR)
• Post-grant review (PGR)
• Appeal decisions

Reference Documentation

See references/additional_apis.md for comprehensive documentation on:

• Enriched Citation API
• Office Action APIs (Text, Citations, Rejections)
• Patent Litigation Cases API
• PTAB API
• Cancer Moonshot Data Set
• OCE Status/Event Codes

Comprehensive Patent Analysis

Combine multiple APIs for complete patent intelligence:

```python

def comprehensive_patent_analysis(patent_number, api_key):

"""

Full patent analysis using multiple USPTO APIs.

"""

from scripts.patent_search import PatentSearchClient

from scripts.peds_client import PEDSHelper

results = {}

# 1. Get patent details

patent_client = PatentSearchClient(api_key)

patent_data = patent_client.get_patent(patent_number)

results['patent'] = patent_data

# 2. Get examination history

peds = PEDSHelper()

results['prosecution'] = peds.analyze_prosecution(patent_number)

results['status'] = peds.get_status_summary(patent_number)

# 3. Get assignment history

import requests

assign_url = f"https://assignment-api.uspto.gov/patent/v1.4/assignment/patent/{patent_number}"

assign_resp = requests.get(assign_url, headers={"X-Api-Key": api_key})

results['assignments'] = assign_resp.text if assign_resp.status_code == 200 else None

# 4. Analyze results

print(f"\n=== Patent {patent_number} Analysis ===\n")

print(f"Title: {patent_data['patent_title']}")

print(f"Assignee: {', '.join(patent_data.get('assignee_organization', []))}")

print(f"Issue Date: {patent_data['patent_date']}")

print(f"\nProsecution:")

print(f" Office Actions: {results['prosecution']['total_office_actions']}")

print(f" Rejections: {results['prosecution']['non_final_rejections']} non-final, {results['prosecution']['final_rejections']} final")

print(f" Pendency: {results['prosecution']['pendency_days']} days")

# Analyze citations

if 'cited_patent_number' in patent_data:

print(f"\nCitations:")

print(f" Cites: {len(patent_data['cited_patent_number'])} patents")

if 'citedby_patent_number' in patent_data:

print(f" Cited by: {len(patent_data['citedby_patent_number'])} patents")

return results

```

1. API Key Management

- Store API key in environment variables

- Never commit keys to version control

- Use same key across all USPTO APIs

1. Rate Limiting

- PatentSearch: 45 requests/minute

- Implement exponential backoff for rate limit errors

- Cache responses when possible

1. Query Optimization

- Use _text_* operators for text fields (more performant)

- Request only needed fields to reduce response size

- Use date ranges to narrow searches

1. Data Handling

- Not all fields populated for all patents/trademarks

- Handle missing data gracefully

- Parse dates consistently

1. Combining APIs

- Use PatentSearch for discovery

- Use PEDS for prosecution details

- Use Assignment APIs for ownership tracking

- Combine data for comprehensive analysis

• Legacy API Sunset: PatentsView legacy API discontinued May 1, 2025 - use PatentSearch API
• PAIR Bulk Data Decommissioned: Use PEDS instead
• Data Coverage: PatentSearch has data through June 30, 2025; PEDS from 1981-present
• Text Endpoints: Claims and description endpoints are in beta with ongoing backfilling
• Rate Limits: Respect rate limits to avoid service disruptions

API Documentation

• PatentSearch API: https://search.patentsview.org/docs/
• USPTO Developer Portal: https://developer.uspto.gov/
• USPTO Open Data Portal: https://data.uspto.gov/
• API Key Registration: https://account.uspto.gov/api-manager/

Python Libraries

• uspto-opendata-python: https://pypi.org/project/uspto-opendata-python/
• USPTO Docs: https://docs.ip-tools.org/uspto-opendata-python/

Reference Files

• references/patentsearch_api.md - Complete PatentSearch API reference
• references/peds_api.md - PEDS API and library documentation
• references/trademark_api.md - Trademark APIs (TSDR and Assignment)
• references/additional_apis.md - Citations, Office Actions, Litigation, PTAB

Scripts

• scripts/patent_search.py - PatentSearch API client
• scripts/peds_client.py - PEDS examination data client
• scripts/trademark_client.py - Trademark search client