USPTO Patent API Free: PatentsView, TSDR, and What Actually Works

The phrase "USPTO patent API free" gets searched ~3K times a month and almost every blog post answering it is either out of date or trying to sell you Patsnap. The actual answer is more nuanced: there are three serious free USPTO patent APIs, two of them keyless, and they cover different parts of the workflow. None of them, on their own, is enough for production R&D intelligence - which is the gap I'll walk through and show how to close.

I've wired this stack for IP law firms, two corp-dev teams, and a pharma generics watcher as part of my Apify actor portfolio. This post is the honest field guide: which free USPTO API to use for which job, what their rate limits and data quality actually look like in 2026, and the patterns the official docs gloss over.

The free USPTO patent API landscape

The most common mistake I see: people land on the USPTO main site, click "API," get sent to the developer hub, and never find PatentsView because it's hosted by the IP Data Analytics Workshop and lives on a separate domain. PatentsView is the real workhorse for analytics. TSDR is the real answer for trademarks.

Why the free APIs alone aren't enough

The free USPTO APIs give you raw records. The actual jobs IP teams need to do are relational:

• "Who is this assignee co-filing with?" Requires joining co-assignee pairs across an assignee's full filing history, summing joint patent counts, surfacing the relationship graph.
• "What CPC tech clusters are accelerating?" Requires year-over-year filing growth per CPC code, top assignees per cluster, top inventors per cluster.
• "Where did this inventor work?" Requires inventor disambiguation (the PatentsView feature that earns its keep), then chronological assignee history with date ranges.
• "What patents expire next quarter?" Requires computing 20-year terms from earliest-priority-date with USPTO term-adjustment factors.
• "What's the patent family for this filing?" Requires walking continuations, divisionals, CIPs, foreign equivalents, reissues, and PCT entries.
• "Are there forward citations on this patent?" Requires reverse-citation lookup (PatentsView gives you backward; you have to reverse-index for forward).

None of this is hard. All of it is "you have to write it." For a one-time landscape brief, write it. For ongoing monitoring across a 50-assignee watchlist, you want it pre-baked.

The walkthrough: PatentsView in 5 minutes

Get a free PatentsView API key at patentsview.org/apis/keyrequest - issued in under 5 minutes by email.

import os
import httpx

PATENTSVIEW_KEY = os.environ["PATENTSVIEW_KEY"]
BASE = "https://search.patentsview.org/api/v1/patent/"

# Recent patents assigned to NVIDIA in CPC G06N (machine learning), past year
q = {
    "q": {
        "_and": [
            {"_eq": {"assignees.assignee_organization": "NVIDIA CORPORATION"}},
            {"_text_phrase": {"cpc_current.cpc_subgroup_id": "G06N"}},
            {"_gte": {"patent_date": "2025-05-17"}},
        ]
    },
    "f": [
        "patent_id", "patent_title", "patent_date",
        "assignees.assignee_organization",
        "inventors.inventor_name_first", "inventors.inventor_name_last",
        "cpc_current.cpc_subgroup_id",
    ],
    "o": {"size": 100},
}

r = httpx.post(BASE, json=q, headers={"X-Api-Key": PATENTSVIEW_KEY}, timeout=30)
r.raise_for_status()

for pat in r.json().get("patents", []):
    inventors = ", ".join(
        f"{i['inventor_name_first']} {i['inventor_name_last']}"
        for i in pat.get("inventors", [])
    )
    print(f"{pat['patent_id']} | {pat['patent_date']} | {pat['patent_title'][:60]}")
    print(f"  inventors: {inventors}")

PatentsView's POST query syntax is clunky (a nested boolean tree) but well documented. The hard caps:

• 45 requests per minute per API key.
• 100,000 records per query result set. Wider queries get truncated - split by date window or assignee.
• Weekly data refresh aligned with USPTO grant publications.

The walkthrough: TSDR in 2 minutes

TSDR (Trademark Status & Document Retrieval) is keyless and instant.

import httpx

# Trademark status for serial number 88123456
serial = "88123456"
r = httpx.get(f"https://tsdr.uspto.gov/ts/cd/casestatus/sn{serial}/info.xml", timeout=15)
# Returns XML - parse with lxml or xmltodict
print(r.text[:500])

For trademark search (vs status lookup) you need to scrape USPTO's TESS system or use the USPTO Open Data Portal trademark endpoints. TESS is being deprecated in favor of the Trademark Search system; expect more churn through 2026.

The build vs buy point

                    +-----------+
                    | Your code |
                    +-----+-----+
                          |
        +-----------------+-----------------+
        |                 |                 |
        v                 v                 v
+------------+    +-------------+    +-------------+
| PatentsView|    | USPTO TSDR  |    | USPTO PEDS  |
|  + free key|    |  keyless    |    |  keyless    |
| 45 req/min |    |  XML        |    |  JSON       |
+------------+    +-------------+    +-------------+
        |                 |                 |
        +-----------------+-----------------+
                          |
                          v
                +-------------------+
                | YOUR ANALYTICS    |
                | LAYER (co-assignee|
                | maps, inventor    |
                | mobility, etc)    |
                +-------------------+
                          ^
                          |
                  THIS is the work

For a one-time prior-art brief or freedom-to-operate analysis, write it yourself. For ongoing monitoring (weekly cron across a watchlist, daily trademark alerts), use a prebuilt actor.

I packaged this stack as seibs.co/uspto-patent-intel with eight purpose-built modes: patent search, trademark search, co-assignee mapping, CPC tech-cluster analysis, inventor mobility, expiration calendar, family lookup, citation analysis. There are a couple of other USPTO actors on the Apify Store - shop around. The differentiation here is the pre-computed analytics layer (co-assignee graphs, inventor mobility timelines, YoY CPC growth) that you'd otherwise write yourself.

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

# Co-assignee mapping for NVIDIA - find every joint-filing partner
run = client.actor("seibs.co/uspto-patent-intel").call(run_input={
    "mode": "co_assignee_mapping",
    "assignees": ["NVIDIA CORPORATION"],
    "patentsview_api_key": "YOUR_PATENTSVIEW_KEY",
    "lookback_years": 5,
    "min_joint_patents": 2,
})

for partner in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{partner['co_assignee']:40s} | {partner['joint_patent_count']:>4} patents")
    for sample in partner.get("sample_patents", [])[:3]:
        print(f"    {sample['patent_id']} {sample['patent_title'][:60]}")

Sample output:

MICROSOFT TECHNOLOGY LICENSING, LLC      |    7 patents
    11823456 Distributed inference cache for transformer models
    11891234 Adaptive batching for multi-tenant model serving
    11912345 Quantization-aware training using mixed precision

Co-assignee mapping is one of the highest-signal M&A predictors in the IP world - companies that file jointly tend to do JVs or acquisitions within 18-36 months. It's also a feature you can't get out-of-box from raw PatentsView - the join is on you.

What you can do with this data

The output ships flat enough to drop into HubSpot, Salesforce, or your IP-management system (Anaqua, CPA Global, Patsnap) via webhook.

Honest limitations

The non-glamorous truth about USPTO patent intelligence.

PatentsView is granted patents only. Pending applications are not in PatentsView. For application-stage intelligence you need USPTO PEDS or the weekly XML bulk dumps. The actor covers grants primarily and falls back to PEDS for application status when explicitly requested.

Disambiguation is imperfect. PatentsView's inventor disambiguation is among the best public datasets but it still gets common names wrong (John Smith may collapse two distinct inventors). For high-stakes inventor-mobility analysis on common-named inventors, hand-verify.

Assignee names are noisy. "MICROSOFT CORPORATION" and "MICROSOFT TECHNOLOGY LICENSING, LLC" are distinct strings in PatentsView. The actor normalizes the common forms but holding-company structures still cause split counts. Use assignee_id (the disambiguated entity) rather than raw string when possible.

CPC tech-cluster YoY growth is sensitive to date window. Recent quarters have lower counts because the grant-to-publication lag is 18-36 months. Compare like windows (full calendar years, not trailing-90-day).

Trademark TSDR data is real-time but search interfaces are in transition. TESS is being deprecated for the new Trademark Search system. Expect API/scraper churn through 2026.

Patent family completeness depends on USPTO PEDS. PCT family members and foreign equivalents from non-USPTO offices require additional sources (EPO OPS API, INPADOC). The actor covers US family members reliably; foreign coverage is partial.

Expiration calendar requires term-adjustment math. A patent's nominal expiration is 20 years from earliest US priority date, but USPTO term adjustments (PTA) and terminal disclaimers move the real date. The actor applies these; if you build it yourself, account for both.

No litigation data. USPTO doesn't publish patent infringement cases - those are in PACER. Pair with court-records-intel for E.D. Tex., D. Del., N.D. Cal. litigation lookups by assignee.

Free tier limits. PatentsView's 45 req/min is enough for most analytics but trips on very wide queries. The actor self-throttles; if you call PatentsView direct, implement a token bucket.

FAQ

Q: Is the PatentsView API really free? A: Yes - the API key is free, signup takes about 5 minutes, and there's no per-call charge. Rate limit is 45 requests per minute per key. No payment method, no billing surprise.

Q: What is the best free USPTO patent API in 2026? A: PatentsView for analytics (granted patents, assignees, inventors, CPC). TSDR for trademark status. USPTO PEDS for prosecution data. Google Patents BigQuery for global coverage. Use them together - none is sufficient alone.

Q: How do I search patents by CPC code for free? A: Use PatentsView's POST query with {"_text_phrase": {"cpc_current.cpc_subgroup_id": "G06N"}}. The cpc_subgroup_id is the most specific level; you can also filter on cpc_section_id, cpc_class_id, or cpc_subclass_id for broader cuts.

Q: Does the USPTO have a free trademark search API? A: TSDR (tsdr.uspto.gov) is free and keyless for status lookups by serial number. For trademark search by keyword or Nice class, use the USPTO Open Data Portal trademark endpoints (also free) or scrape the new Trademark Search system. TESS is being deprecated.

Q: How fresh is PatentsView data? A: PatentsView refreshes weekly aligned with USPTO Tuesday grant publications. So a patent granted Tuesday morning lands in PatentsView by the following Tuesday's refresh - typically 7-day lag at the outside.

Q: Can I get pending patent applications from PatentsView? A: No - PatentsView covers granted patents only. For pending applications, use USPTO PEDS (ped.uspto.gov) or the weekly XML bulk dumps. Application publications appear 18 months after filing.

Q: How do I track when a competitor's patents expire? A: Pull the assignee's portfolio from PatentsView, compute the 20-year term from patent_earliest_application_date, then apply USPTO term adjustments (PTA) and terminal disclaimers from PEDS. The actor's expiration_calendar mode does this in one call.

Q: Can I get forward citations on a patent? A: PatentsView gives you backward citations (what this patent cites) natively. Forward citations (what cites this patent) require querying for patents where cited_patent_id equals your target patent number. The actor's citation_analysis mode does both sides.

Q: How do I monitor new patent filings by a specific assignee on cron? A: Schedule the actor's patent_search mode daily with the assignee in input, dedupe downstream on patent_id. PatentsView's weekly refresh means daily polling is overkill; weekly is sufficient.

Q: What's the difference between PatentsView and Google Patents BigQuery? A: PatentsView is US-focused, with strong assignee + inventor disambiguation and free REST API. Google Patents BigQuery has global coverage (120M+ patents from 100+ patent offices), full-text in many languages, and costs BigQuery rates (cheap for small queries, expensive for full-corpus scans). Use PatentsView for US analytics, BigQuery for global FTO.

Q: Will this work for design patents and plant patents too? A: Yes - PatentsView covers utility (D-numbers are design, PP-numbers are plant). Most analytics use cases focus on utility patents but the data is in there. Filter by patent_type if you want only one.

Try it free

Run uspto-patent-intel on Apify - free plan covers ~500 patents per month. Bring your free PatentsView API key (instant signup at patentsview.org/apis/keyrequest).

Related actors in the portfolio:

• sec-edgar-intel - cross-reference patent assignees against SEC 8-K M&A and 13F position changes to spot IP-driven acquisitions.
• court-records-intel - pull every patent litigation case (E.D. Tex., D. Del., N.D. Cal.) for a given assignee.
• b2b-sales-triggers - convert new patent filings, trademark registrations, and inventor moves into outbound sales triggers.

About the author

I'm a solo MSP operator who builds B2B web-scraping actors at apify.com/seibs.co when I'm not running incident calls. The portfolio has 30+ live actors covering lead generation, intent data, SEC/USPTO/court records, and AI agent wrappers - all pay-per-event so you only pay for what's emitted. Find me at seibs.co.