Patents & Trademarks MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Patents & Trademarks MCP Which IPRs have been filed against patent 10,169,987, and how did they end?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Patents & Trademarks MCP
Ask your AI assistant real questions about U.S. patents and trademarks — and get answers grounded in the official USPTO APIs.
Documentation: uspto.mcp.blenlabs.com/docs has connect buttons for Claude Desktop, Cursor and VS Code, key setup, recipes, and the SDK reference.
This is a Model Context Protocol server that connects any MCP client (Claude Desktop and others) to the U.S. Patent and Trademark Office's public APIs:
USPTO Open Data Portal (ODP) —
api.uspto.gov: the Patent File Wrapper (bibliographic data, status, continuity, assignments, patent term adjustment, attorneys, transactions, document lists), PTAB trials, appeals and interferences, petition decisions, office actions (full text, rejections, citations), and the bulk-dataset catalog.developer.uspto.govnow redirects here.TSDR — Trademark Status & Document Retrieval: trademark case status and document lists.
Instead of bolting on dozens of rigid, narrow tools, it hands the model a small, well-documented SDK and lets it write the exact query it needs in JavaScript — then runs that code in a locked-down sandbox. This is the code-mode pattern, and it makes wide government APIs usable without overwhelming the model with tool definitions.
Independent open-source project. It calls public USPTO APIs and is not affiliated with or endorsed by the USPTO or the U.S. government.
API keys
Both sources need a free, personal API key. USPTO issues one key per account and says: "Do not share it with others. It is an identifier unique to you" (Getting Started). The keys are held host-side and never reach the sandbox.
Source | Key | How to get it | Env var |
| ODP API key, sent as | A USPTO.gov account with multi-factor authentication (required for all ODP use since June 18, 2026), linked once to a verified ID.me identity; then sign in at data.uspto.gov/myodp and use Manage API Key. See Register for ODP access. |
|
| TSDR key, sent as |
|
USPTO says a key "shouldn't expire if it is used at least one time per year". Since August 18, 2026, USPTO.gov profiles must include four additional fields; keys of accounts that had not completed them by October 8, 2026 were deactivated (every call returns 403). To reactivate, complete the fields under Open Data Portal in your USPTO.gov account settings, then click Activate API Key on the ODP Manage API Key page.
Without a key, that source is disabled: its global still exists in the sandbox, but calls return a SourceUnavailable error that says how to get one, while the other source keeps working.
Related MCP server: Priorbit
Quickstart (Claude Desktop)
Add the server to your Claude Desktop config (Settings → Developer → Edit Config):
{
"mcpServers": {
"uspto": {
"command": "npx",
"args": ["-y", "@blen/uspto-mcp-server"],
"env": {
"USPTO_API_KEY": "your-odp-key",
"USPTO_TSDR_API_KEY": "your-tsdr-key"
}
}
}
}Restart Claude Desktop, then ask in plain language:
"Which IPRs have been filed against patent 10,169,987, and how did they end?" "Show the office actions and rejection grounds for application 17/248,024." "What's the status of trademark serial number 97123456?"
Requires Node.js 24 or 26 (LTS). npx downloads and runs the server on demand. If execute reports SandboxUnavailable, see Sandbox runtimes. A Claude Desktop extension bundle (.mcpb) that asks for the keys at install time is built from this repository (pnpm mcpb:prepare && pnpm mcpb:pack).
See it in action
"Has anyone challenged patent 10,169,987 at the PTAB?"
The model finds the right calls with search_api and runs them in the sandbox:
const trials = await odp.ptab.proceedings.search({
q: 'patentOwnerData.patentNumber:10169987',
fields: ['trialNumber', 'trialMetaData.trialTypeCode', 'trialMetaData.trialStatusCategory',
'regularPetitionerData.realPartyInInterestName'],
});
const first = trials.patentTrialProceedingDataBag[0].trialNumber;
const decisions = await odp.ptab.decisions.byTrial(first);
return decisions.patentTrialDocumentDataBag.map(d => ({
date: d.decisionData?.decisionIssueDate,
outcome: d.decisionData?.trialOutcomeCategory,
}));…then answers in plain English, citing the trials and decisions it found.
What's covered
Need | Call |
Find applications/patents by title, applicant, inventor, CPC, dates, status |
|
Application behind a granted patent number |
|
One application's metadata, continuity, assignments, PTA, attorney, transactions, documents |
|
PTAB trials (IPR/PGR/CBM/DER), decisions, papers |
|
Ex parte appeals and interferences |
|
Petition decisions (with decision documents) |
|
Office action full text and rejection grounds |
|
Bulk dataset catalog and file lists |
|
Trademark status (1–25 cases per call), documents, last update |
|
Full surface: docs/sdk-reference.md. File downloads — PDFs, bulk files, and search/download CSV exports — are intentionally not exposed; the SDK returns their URLs instead.
How it works
Three tools, in the order the model uses them:
Tool | What it does |
| BM25 over the SDK method docs and a response-field dictionary. Returns signatures and ready-to-run JavaScript. |
| Looks up an exact entry ( |
| Runs JavaScript (no type annotations; top-level |
All three are annotated read-only and non-destructive (execute is also openWorldHint: true) and publish an outputSchema. Results come back as compact JSON text plus the same object as structuredContent. A failed execution (thrown error, timeout, limit) is returned with isError: true and the full envelope — { ok: false, error: { name, message, status? }, logs, durationMs } — so the model sees what went wrong. A search with no hits returns { count: 0, …Bag: [] }, not an error.
MCP client → execute(code) → sandbox → odp.* / tsdr.* RPC bridge → host HttpClient (key, queue, cache) → api.uspto.gov / tsdrapi.uspto.govArchitecture: docs/architecture.md · Paste-ready examples: examples/.
USPTO rate limits, and how the server respects them
USPTO allows one request in flight per API key (burst 1; concurrent calls get 429), 4–15 requests/second, and 5 million metadata plus 1.2 million document calls per key per week (reset Sunday 00:00 UTC). It asks clients to wait at least 5 seconds after a 429. So the server:
queues each key's calls through a gate: one in flight, at most 4 starts/s for ODP and 1/s for TSDR (
Promise.allin sandbox code is safe but not faster);on a
429, pauses every caller of that key for at least 5 s (or the fullRetry-After, if longer), then retries that one call once if the pause is 30 s or less; otherwise the call fails withRateLimited;caps upstream calls per
execute()(ODP 50, TSDR 25), per hour per key (counting every real attempt, retries included), and per authenticated subject;caches responses, including search POSTs keyed by their body, so repeated questions don't spend quota;
rejects upstream bodies over 8 MiB (
ResponseTooLarge) and results over 256 KiB returned fromexecute(ResultTooLarge) — usefieldsandlimitto keep records small.
Personal accounts (hosted mode)
USPTO_AUTH_PROVIDER=accounts adds Google sign-in, an /account page where each user saves their own ODP and TSDR keys (checked against USPTO, encrypted in PostgreSQL, never shown again), and OAuth/PKCE connections at /mcp/account. Each signed-in user's queries use only that user's own keys. Because USPTO keys are personal, account mode never uses an operator key (USPTO_API_KEY, USPTO_TSDR_API_KEY are ignored there): the anonymous /mcp endpoint offers only the documentation tools (search_api, describe_schema), and execute requires signing in. See docs/accounts.md.
Sandbox runtimes
execute needs a sandbox runner:
isolated-vm— a fresh V8 isolate per execution, with a heap cap and a host-enforced deadline.isolated-vm7 ships prebuilt binaries for Node 24 and 26 on macOS arm64, Linux x64/arm64 (glibc and musl) and Windows x64, so no compiler is needed. Preferred for single-user use (stdio,--insecurelocal HTTP).Deno — user code runs in a separate
denoprocess with no permissions (no network, files, env or subprocesses), inside a Worker stripped ofDeno,fetchand messaging globals; the server owns the deadline and kills the process group. Install Deno and it is used whenisolated-vmis unavailable, or always with--sandbox deno(USPTO_SANDBOX=deno).Authenticated HTTP serving (OIDC or accounts) runs user code only in the Deno runner — a separate, killable process per execution.
--sandbox isolateis refused there, and without Deno,executereportsSandboxUnavailableinstead of falling back to in-process execution.If no runner is available,
search_apianddescribe_schemastill work;executereturnsSandboxUnavailablewith instructions.
Every execution is bounded: code 256 KiB, returned value 256 KiB (ResultTooLarge), logs 64 KiB / 1,000 lines, SDK-call arguments 64 KiB, 16 calls pending at once. At most 8 executions run at once per server and 2 per authenticated subject (USPTO_MAX_CONCURRENT_EXECUTIONS, USPTO_MAX_EXECUTIONS_PER_SUBJECT); a client that cancels or disconnects stops its execution and any upstream calls in flight.
Self-hosting (remote HTTP)
# Local, single user, no auth (binds 127.0.0.1 unless HOST/--host says otherwise):
USPTO_API_KEY=... npx @blen/uspto-mcp-server --http --insecure --port 8080
# Your own server, authenticated via an OIDC issuer (your key serves only you: see API keys).
# Issuer, audience and an https JWKS URL are all required; Deno must be installed.
USPTO_API_KEY=... \
USPTO_AUTH_PROVIDER=clerk \
USPTO_AUTH_ISSUER=https://<tenant>.clerk.accounts.dev \
USPTO_AUTH_AUDIENCE=https://your-host.example.com/mcp \
USPTO_AUTH_JWKS_URL=https://<tenant>.clerk.accounts.dev/.well-known/jwks.json \
USPTO_PUBLIC_ORIGIN=https://your-host.example.com \
npx @blen/uspto-mcp-server --httpThen point any MCP client at it:
{ "mcpServers": { "uspto": { "type": "http", "url": "https://your-host.example.com/mcp" } } }The HTTP transport implements the stateless MCP 2026-07-28 Streamable HTTP profile — no initialize handshake and no Mcp-Session-Id — with a stateless legacy fallback for pre-2026 clients. It fails closed:
--httpwithout--insecurerefuses to start unless real authentication is configured (an OIDC provider, oraccounts). OIDC tokens must carry the configured issuer and audience, an expiry and a subject, use an asymmetric algorithm, and hold every scope inUSPTO_AUTH_SCOPES(otherwise403 insufficient_scope).Listening on anything but loopback requires
USPTO_PUBLIC_ORIGINorUSPTO_ALLOWED_HOSTS: every request'sHostmust match the configured names (DNS-rebinding protection); the trusted origin is never taken from the request. BrowserOrigins other than the server's own, loopback, orUSPTO_ALLOWED_ORIGINSget403.Request bodies are capped at 1 MiB, and tool arguments at a fixed number of elements.
It also serves OAuth 2.0 Protected Resource Metadata (RFC 9728), per-IP rate limiting and per-subject daily quotas. A Railway walkthrough is in deploy/RAILWAY.md; the Dockerfile runs on Node 26 (LTS) with Deno included.
The per-key gates, hourly buckets and quotas are in memory, so run one replica — and avoid deploys where an old and a new instance serve at the same time — or USPTO sees concurrent requests with one key.
Configuration
The most common knobs (full list and defaults in .env.example):
Variable | Default | Notes |
| — | ODP key. Unset ⇒ |
| — | TSDR key. Unset ⇒ |
|
|
|
|
| Identify your deployment. |
|
| Upstream calls per |
|
| Hourly attempts per configured key (per account in account mode). Must be ≥ 1. |
|
| Per authenticated subject per hour (HTTP only). |
|
| Requests in flight per key. Keep 1. |
|
| Requests started per second per key. |
|
| Largest upstream body accepted. |
|
| Simultaneous executions per server / per authenticated subject ( |
|
| Response cache. |
|
|
|
| — | Required for OIDC providers (JWKS over https; http only on loopback). |
| — | Comma-separated scopes every token must carry; advertised in resource metadata. |
| — | Public origin clients reach (OAuth metadata, trusted Host). Required for non-loopback HTTP unless |
| — | Extra accepted |
|
| Per-IP token bucket on the HTTP transport. |
| unset | Header your proxy overwrites with the client address (Railway: |
|
| Requests per authenticated subject per UTC day. |
CLI options: --http, --port, --host, --sandbox auto|isolate|deno, --insecure, --help.
Security
User code is sandboxed by design — no network, filesystem, env, or subprocess access, an acorn AST preflight, a host-enforced wall-clock deadline, byte budgets, and a V8 heap cap. API keys stay in the host process; any key an upstream echoes back is redacted from results and errors in every mode. The threat model is in SECURITY.md. Found a sandbox escape or auth bypass? Please open a private Security Advisory rather than a public issue.
Contributing
See CONTRIBUTING.md for the dev setup and ground rules, and please open an issue before anything non-trivial. By participating you agree to the Code of Conduct.
License
Apache-2.0 © 2026 BLEN, Inc. See also NOTICE.
Hosted service policies
The BLEN-hosted connector's Privacy Policy and Terms of Service describe data handling and conditions of use. The software remains licensed under Apache-2.0; self-hosted operators are responsible for their own policies.
Acknowledgements
The USPTO for publishing the Open Data Portal and TSDR APIs.
patent-dev/uspto-odp (MIT) for published sample responses, used for the TSDR part of the field dictionary until it can be captured live (the ODP part is generated from live captures).
The Model Context Protocol team for the spec and TypeScript SDK.
Built by BLEN, Inc.
Available Tools
3 toolsdescribe_schemaDescribe USPTO API SchemaARead-onlyIdempotent
Look up an endpoint or field by exact dotted id (path) or by namespace prefix. Use to drill into the bound source surfaces (odp., tsdr.).
Inputs: path, prefix. Returns: found, entries, message
executeQuery USPTO Patent and Trademark DataARead-onlyIdempotent
Run JavaScript inside a sandbox (no net, fs, env, or subprocess). Plain JS only — TypeScript type annotations are rejected. Globals: odp, tsdr. Top-level await is allowed; return the value you want as the result. USPTO serves one request at a time per API key, so calls are queued: prefer one well-filtered search (with fields to trim large records) over many lookups, and return only what you need.
Inputs: code (required), memoryMb, timeoutMs. Returns: ok, logs, error, value, +1 more
search_apiSearch USPTO API DocumentationARead-onlyIdempotent
BM25 search over the SDK methods and response-field dictionary for all bound sources (odp, tsdr): patent applications (file wrapper), PTAB trials/appeals/interferences, petition decisions, office actions, bulk datasets, and trademark status. Returns method signatures and JavaScript examples for use in execute. Start here.
Inputs: query (required), k. Returns: hits, note
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 3 tools
The three tools map to distinct phases: discovery by fuzzy search (search_api), exact/prefix schema lookup (describe_schema), and execution (execute). The overlap between search_api and describe_schema is real — both expose the same API surface — but the descriptions give clear routing cues ('Start here' vs 'drill into ... by exact dotted id'), so misselection is unlikely.
Two tools follow a verb_noun pattern (search_api, describe_schema) and the third is a bare verb (execute), which is a minor but defensible deviation since it is the terminal action. All names are lowercase snake_case and readable; there is no mixing of camelCase or arbitrary styles.
Three tools is at the low end of the ideal range but fits a code-execution gateway, where an entire SDK is reached through `execute` rather than one tool per endpoint. Splitting discovery into search and describe is justified by the breadth of the odp/tsdr surface; nothing feels padded.
The lifecycle of discover -> inspect -> call is fully covered, and arbitrary JS execution means no API operation is a dead end. Minor gaps exist: no dry-run or validation step before `execute`, and no way to inspect rate-limit/queue state despite the documented one-request-per-key constraint.
Maintenance
Related MCP Connectors
The USPTO prosecution record for your AI. Connect once and work any U.S. patent application.
Patent search, USPTO data, patent landscape & pgvector prior-art search for agents.
Search U.S. case law, fetch opinions, and ask matter-aware legal questions over your documents.
Real-time Amazon, WIPO & PACER data for AI agents — 19 tools via the MCP protocol.
Related MCP Servers
- AlicenseNot gradedqualityFmaintenanceEnables AI agents to perform patent search, portfolio analysis, technology trend tracking, and semantic prior-art search using USPTO data.MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI agents to search and screen US intellectual property — granted patents with full claims, published applications, trademarks in every status, owners, inventors, USPTO documents, prosecution file wrappers, PTAB trials, and e-commerce product pages. Supports freedom-to-operate screenings, knockout trademark searches, and patent status/expiry/ownership checks through a single authenticated remote connection.1MIT
- FlicenseNot gradedqualityAmaintenanceExposes 20+ tools that let any MCP-compatible client run hybrid retrieval over MPEP/USC/CFR regulations, search 100M+ granted and published patents via Google BigQuery for prior art, and perform automated 35 USC 112 compliance checks on draft claims and applications. It also generates publication-style diagrams and flowcharts from natural-language descriptions.-
- FlicenseNot gradedqualityAmaintenanceEnables AI clients to search patent rules and statutes with hybrid RAG, hunt prior art across 100M+ patents via BigQuery, run automated application compliance checks, and generate patent-style diagrams. It exposes 20+ tools that any MCP-compatible client can call for patent search, analysis, and figure creation.-