USPTO APIuspto.gov ↗
Search US patent grants and applications by assignee and date, and retrieve full text including claims, abstract, and bibliographic data via the USPTO API.
What is the USPTO API?
This API exposes two endpoints against the USPTO patent corpus, covering both granted patents and pre-grant publications. The search_patents endpoint returns paginated document summaries filtered by assignee name and publication date window, while get_patent_document delivers the full record for a single document — including claims, abstract, inventor list, CPC codes, and page count — identified by its canonical document ID.
curl -X GET 'https://api.parse.bot/scraper/3d7eddbd-2da3-4c40-b259-a22cd5bdd60e/search_patents?assignee=Xiaomi&document_type=all' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace uspto-gov-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: USPTO Patent Public Search — search by assignee, drill into full text."""
from parse_apis.uspto_gov_api import Uspto, DocumentType, NotFound
client = Uspto()
# Search recent patent applications for a well-known assignee.
for summary in client.patent_summaries.search(
assignee="Xiaomi",
document_type=DocumentType.APPLICATION,
limit=5,
):
print(summary.title, summary.date_published, summary.kind_code)
# Drill down: take the first hit and fetch its full document.
hit = client.patent_summaries.search(assignee="Xiaomi", limit=1).first()
if hit is not None:
patent = hit.details()
print(patent.title)
print("Inventors:", patent.inventors)
print("Abstract:", patent.abstract_html[:200])
print("Claims pages:", patent.page_count)
# Direct point lookup by a known document id.
try:
doc = client.patents.get(document_id="US-20260261829-A1")
print(doc.title, doc.assignees, doc.date_published)
except NotFound:
print("Document not found")
print("exercised: patent_summaries.search / PatentSummary.details / patents.get")
Lists US patent documents (granted patents and published applications) whose assignee name matches the given term and whose publication date falls inside a date window. With no dates supplied the window is the 14 days ending today (computed at call time). One family representative is returned per patent family, newest publication first. Results are paged with an offset: `start` is the zero-based offset into the result list, `limit` is the page size (at most 100, larger values are clamped); `total` is the site's full match count and `has_more` tells whether a further page exists. Each item carries a `document_id` (e.g. one shape: US-20260261829-A1) that get_patent_document accepts unchanged. An empty `items` list with `total` 0 is a valid result when nothing was published in the window. Costs three upstream requests per call.
| Param | Type | Description |
|---|---|---|
| limit | integer | Page size; values above 100 are clamped to 100. |
| start | integer | Zero-based offset of the first item to return. |
| assigneerequired | string | Assignee (patent owner) name term to match, e.g. a company name. Letters, digits, spaces and . , & - only; matched as a phrase against the assignee-name field, so a single distinctive word (a brand) matches all corporate variants of that name. |
| published_to | string | Latest publication date, ISO YYYY-MM-DD, inclusive; must not precede published_from. Omitted: today. |
| document_type | string | Restrict to granted patents, published applications, or both. |
| published_from | string | Earliest publication date, ISO YYYY-MM-DD, inclusive. Omitted: 14 days before today. |
{
"type": "object",
"fields": {
"count": "integer, number of items in this page",
"items": "array of document summaries: document_id (canonical id accepted by get_patent_document), document_number, document_id_display, document_type (grant|application), kind_code, title, date_published (ISO), application_number, application_filing_date (ISO), assignees, applicants, inventors_short, cpc_inventive / cpc_additional / ipc (arrays of classification codes), primary_examiner (null on applications), page_count, family_id",
"query": "object echoing the resolved search controls: assignee, published_from, published_to (ISO dates actually applied), document_type",
"start": "integer offset of this page",
"total": "integer, total number of matching family representatives reported by the site for the whole window",
"has_more": "boolean, true when start+count < total"
},
"sample": {
"data": {
"count": 3,
"items": [
{
"ipc": [
"H04W4/40",
"H04W4/024"
],
"title": "INFORMATION TRANSMISSION METHOD AND APPARATUS, AND STORAGE MEDIUM",
"assignees": [
"Beijing Xiaomi Mobile Software Co., Ltd."
],
"family_id": 83066352,
"kind_code": "A1",
"applicants": [
"Beijing Xiaomi Mobile Software Co., Ltd."
],
"page_count": 19,
"document_id": "US-20260261829-A1",
"cpc_inventive": [
"H04W4/40",
"H04W4/024",
"H04W76/20"
],
"document_type": "application",
"cpc_additional": [],
"date_published": "2026-09-03",
"document_number": "20260261829",
"inventors_short": "HONG; Wei et al.",
"primary_examiner": null,
"application_number": "18/858216",
"document_id_display": "US 20260261829 A1",
"application_filing_date": "2022-04-19"
}
],
"query": {
"assignee": "Xiaomi",
"published_to": "2026-09-06",
"document_type": "all",
"published_from": "2026-08-23"
},
"start": 0,
"total": 57,
"has_more": true
},
"status": "success"
}
}About the USPTO API
Searching by Assignee and Date
The search_patents endpoint accepts a required assignee string and optional published_from / published_to date parameters in ISO YYYY-MM-DD format. When dates are omitted, the window defaults to the 14 days ending at call time. Results are paginated via start (zero-based offset) and limit (capped at 100); the response includes a total count and a has_more boolean so you can walk through large result sets. The document_type parameter lets you restrict results to granted patents, published applications, or both. Each item in the items array carries a document_id — the canonical identifier you pass to the second endpoint.
Full Document Records
The get_patent_document endpoint takes a single document_id (e.g. US-20260261829-A1 or US-12726983) and returns the complete document record. This includes abstract_html and claims_html as HTML fragments, the title, assignees, inventors (formatted as LAST; First with city and country), applicants, kind_code, page_count, cpc_inventive classification codes, and bibliographic metadata covering priority and related applications. The HTML fragments may contain inline markup — plan to strip or render them depending on your use case.
Coverage and Identifiers
The corpus covers US patent grants (kind codes like B2) and published applications (kind codes like A1). Document IDs follow the US-{number}-{kind_code} pattern for applications and US-{number} for grants. The query object in search responses echoes the resolved parameter values actually applied, including the computed date bounds when defaults are used — useful for audit trails or caching logic.
The USPTO API is a managed, monitored endpoint for uspto.gov — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when uspto.gov changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official uspto.gov API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Track newly published patent applications for a competitor by polling
search_patentswith their assignee name over a rolling date window - Build a patent landscape report by collecting
cpc_inventivecodes across all documents returned for a technology-area assignee - Extract and index full
claims_htmltext for a document set to power a prior-art search tool - Monitor assignee name changes by comparing
assigneesfields across documents with the same base document number - Compile inventor rosters with city and country data from
get_patent_documentfor geographic IP analysis - Ingest
page_countandkind_codefields to estimate prosecution stage and document complexity across a portfolio
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does USPTO offer an official developer API?+
What does `search_patents` return for each item, and how is pagination handled?+
items array includes document_id, document_number, document_id_display, and summary fields. The response also carries total (full match count), count (items on this page), start (current offset), and has_more (boolean). Use start and limit to page through results; limit is clamped to 100 per call.Are citation data or forward references included in `get_patent_document`?+
Can I search by inventor name, CPC code, or keyword rather than assignee?+
search_patents endpoint filters by assignee name and publication date only. Inventor-name, CPC-code, and full-text keyword search are not exposed. You can fork this API on Parse and revise it to add those search axes.How fresh is the data, and does the date window have any hard limits?+
published_from / published_to range in ISO format, with the constraint that published_to must not precede published_from. Freshness depends on when USPTO publishes documents — USPTO typically publishes grants on Tuesdays and applications on Thursdays.