Advanced USPTO Platform

Search, retrieve, and analyze United States patent data from the USPTO (United States Patent and Trademark Office) databases. This skill covers patent full-text search, classification browsing, patent family analysis, citation network exploration, and bulk data processing for intellectual property research.

When to Use This Skill

Choose Advanced USPTO Platform when you need to:

• Search for patents by keyword, inventor, assignee, classification, or date range
• Analyze patent landscapes and technology trends in specific domains
• Extract structured data from patent documents (claims, abstracts, citations)
• Build patent portfolios and conduct freedom-to-operate assessments

Consider alternatives when:

• You need international patent data (use EPO Open Patent Services or WIPO)
• You need trademark search (use USPTO TESS directly)
• You need patent valuation or licensing analytics (use commercial platforms)

Quick Start

Copy
pip install requests pandas beautifulsoup4

Copy
import requests
import pandas as pd
from datetime import datetime

USPTO_API = "https://api.patentsview.org/patents/query"

def search_patents(query_params, fields=None, per_page=25):
    """Search PatentsView API for US patents."""
    if fields is None:
        fields = ["patent_number", "patent_title", "patent_date",
                  "patent_abstract", "assignee_organization",
                  "inventor_first_name", "inventor_last_name"]

    payload = {
        "q": query_params,
        "f": fields,
        "o": {"per_page": per_page},
        "s": [{"patent_date": "desc"}]
    }

    response = requests.post(USPTO_API, json=payload)
    response.raise_for_status()
    data = response.json()

    patents = data.get("patents", [])
    print(f"Found {data.get('total_patent_count', 0)} patents total, "
          f"showing {len(patents)}")
    return patents

# Search for AI-related patents
patents = search_patents(
    {"_and": [
        {"_text_any": {"patent_abstract": "machine learning neural network"}},
        {"_gte": {"patent_date": "2023-01-01"}},
    ]},
    per_page=10
)

for p in patents:
    title = p.get("patent_title", "N/A")
    number = p.get("patent_number", "N/A")
    date = p.get("patent_date", "N/A")
    assignee = (p.get("assignees", [{}]) or [{}])[0].get(
        "assignee_organization", "Individual"
    )
    print(f"US{number} ({date}) [{assignee}]")
    print(f"  {title[:100]}")

Core Concepts

PatentsView Query Operators

Operator	Description	Example
_text_any	Full-text search (any word)	{"_text_any": {"patent_abstract": "CRISPR gene editing"}}
_text_all	Full-text search (all words)	{"_text_all": {"patent_title": "solar cell"}}
_eq	Exact match	{"_eq": {"assignee_organization": "Google LLC"}}
_gte / _lte	Range (dates, numbers)	{"_gte": {"patent_date": "2024-01-01"}}
_contains	Substring match	{"_contains": {"inventor_last_name": "Smith"}}
_and / _or	Boolean combination	{"_and": [query1, query2]}
_not	Negation	{"_not": {"_eq": {"patent_type": "design"}}}

Patent Landscape Analysis

Copy
import requests
import pandas as pd
from collections import Counter

def patent_landscape(search_term, years=5, per_page=100):
    """Analyze patent filing trends for a technology area."""
    from datetime import datetime, timedelta

    start_date = (datetime.now() - timedelta(days=365*years)).strftime("%Y-%m-%d")

    payload = {
        "q": {"_and": [
            {"_text_any": {"patent_abstract": search_term}},
            {"_gte": {"patent_date": start_date}},
        ]},
        "f": ["patent_number", "patent_date", "assignee_organization",
              "cpc_group_id", "patent_type"],
        "o": {"per_page": per_page},
        "s": [{"patent_date": "desc"}]
    }

    response = requests.post(
        "https://api.patentsview.org/patents/query", json=payload
    )
    data = response.json()
    patents = data.get("patents", [])

    # Year trend
    years_list = [p["patent_date"][:4] for p in patents if p.get("patent_date")]
    year_counts = Counter(years_list)
    print("Filing Trend:")
    for year in sorted(year_counts):
        bar = "█" * (year_counts[year] // 2)
        print(f"  {year}: {year_counts[year]:3d} {bar}")

    # Top assignees
    assignees = []
    for p in patents:
        for a in (p.get("assignees") or []):
            org = a.get("assignee_organization")
            if org:
                assignees.append(org)
    top_assignees = Counter(assignees).most_common(10)
    print("\nTop Assignees:")
    for org, count in top_assignees:
        print(f"  {org}: {count}")

    return patents

landscape = patent_landscape("quantum computing", years=5)

Configuration

Parameter	Description	Default
api_url	PatentsView API endpoint	"https://api.patentsview.org"
per_page	Results per page (max 10000)	25
sort_field	Sort results by field	"patent_date"
sort_order	Sort direction (asc, desc)	"desc"
patent_type	Filter by type (utility, design, plant, reissue)	All
date_range	Filter by grant date range	None
cpc_section	CPC classification section filter	None
include_citations	Return citation data	false

Best Practices

1. Use CPC classifications for precise technology searching — Keyword searches return noisy results because patent language is intentionally broad. Combine keyword queries with CPC (Cooperative Patent Classification) codes to focus on specific technology areas. Find relevant CPC codes at the USPTO CPC scheme browser.

2. Search both claims and abstract for comprehensive coverage — The abstract summarizes the invention, but the claims define legal scope. Important prior art may appear only in claims. Use _text_any on both patent_abstract and patent_claim fields with _or for thorough searches.

3. Track patent families, not individual patents — A single invention may have multiple patent applications (continuations, divisionals, foreign filings). Use the patent_family_id field to group related patents and avoid double-counting in landscape analyses.

4. Implement pagination for large result sets — PatentsView limits responses to 10,000 records per query. For larger datasets, paginate with page and per_page parameters, or split queries by date range and merge results.

5. Validate search results by reviewing a sample — Patent search is inherently imprecise. After running a landscape query, manually review 20-30 results to estimate precision and recall. Refine your query iteratively until the relevance rate exceeds 70%.

Common Issues

PatentsView API returns empty results for recent patents — PatentsView data has a lag of several months from the USPTO grant date. For the most recent patents, use the USPTO Full-Text and Image Database (PatFT) directly or the Bulk Data Storage System for weekly updates.

Search returns too many irrelevant results — Patent abstracts use broad, generic language. Combine multiple specific terms with _text_all instead of _text_any, add CPC classification filters, and exclude design patents with {"_not": {"_eq": {"patent_type": "design"}}}.

Query syntax errors are hard to debug — PatentsView returns generic error messages. Validate your JSON payload structure before sending. Common issues: missing _and/_or wrappers around multiple conditions, wrong field names (check the API documentation for exact field identifiers), and unquoted date strings.