Tool reference

This page documents every tool the GoVeda Patent MCP server exposes, with parameters, return shapes, and credit costs. You don’t need to call tools by name — just describe what you want and your AI assistant picks the right one. The names are here so you know exactly what’s available.

New to the server? Start with Patent MCP Server to connect your AI assistant, then come back here for the details. For the formulas behind the 50–590 and 690–2,850 tiered search costs below, see MCP Pricing.

For every tool that accepts a publication number, GoVeda normalizes supported formatting variants and known publication mappings. It never replaces an unresolved reference with a likely match. If a tool returns UNRESOLVED_REFERENCE, use discover_patent_references to retrieve candidates for review, then continue only after the user selects one or explicitly authorizes choosing a likely match.

Search & discovery

`semantic_patent_search` — Semantic search across 220M+ global patents 50–590 credits

Natural language search across 220M+ global patents. Describe the technology or invention you’re looking for. Polls internally and returns final results in a single call (typically 5–15 seconds).

Parameter	Type	Required	Default	Description
`query`	string	Yes	—	Natural language description of the technology (2–10,000 chars; 2–4 char queries succeed with a warning)
`limit`	integer	No	10	Number of results to return (1–1,000)
`exclude`	string[]	No	—	Array of patent UCIDs to exclude from results (the entire patent family of each UCID is excluded)
`search_conditions`	object	No	—	JSON filter object to narrow results (see Filter conditions)

Returns: Search results with publication number, title, relevance score, patent URL, current legal_status, and publication_type for each match.

`discover_patent_references` — Find candidates for unresolved patent references Free

Find available publication candidates for one or more references that another patent tool could not resolve. Discovery preserves each original reference and returns possibilities for review; it does not prove that a candidate is the same patent and does not select one.

Parameter	Type	Required	Default	Description
`references`	string[]	Yes	—	Patent references to investigate, returned in the same order. Maximum 25 per call.
`limit_per_reference`	integer	No	5	Maximum candidates per reference (1–10).

Returns: Guidance plus position-aligned results. Each result contains the original reference, an ordered candidates list, and any per-reference error. Every candidate includes publication_number, title, publication_date, and a GoVeda url. Candidate order helps review but does not establish identity.

`prior_art_search` — Find prior art for a given patent 690–2,850 credits

Find patents similar to a known patent for prior art analysis. Returns a search_id — poll with get_search_status to get results. Typically takes 3–5 minutes.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number to use as the prior-art search target (e.g., US-11234567-B2). Accepts supported formatting variants and known publication mappings.
`limit`	integer	No	50	Number of prior art results (1–1,000)
`search_conditions`	object	No	—	JSON filter object to narrow results (see Filter conditions)

Returns: search_id for polling with get_search_status.

`get_search_status` — Check status of a prior art search Free

Check whether a prior_art_search request has completed. When status is completed, the response includes the full results.

Parameter	Type	Required	Default	Description
`search_id`	string	Yes	—	ID returned by `prior_art_search`

Returns: Status and results (when completed) with UCID, relevance score, and patent URL.

`lookup_classifications` — Find CPC/IPC classification codes by keyword or symbol Free

Look up CPC/IPC patent classification codes by keyword, technology description, or partial symbol. Useful for finding the right codes to pass into search_conditions for semantic_patent_search or prior_art_search.

Parameter	Type	Required	Default	Description
`query`	string	Yes	—	Keyword, classification symbol, or technology description (1–500 chars)
`limit`	integer	No	20	Maximum number of results (1–50)

Returns: A ranked list of classifications with symbol, title, type (cpc or ipc), level, and a relevance score.

`lookup_party` — Resolve a company name to its standardized assignee form 1 credit

Resolve a free-text company name (e.g., Qualcomm) to the canonical assignee name(s) actually stored on patent records. Required before using the current_assignees / original_assignees filters in search_conditions, because those filters are an exact-string match — Qualcomm, Qualcomm Inc., and QUALCOMM INCORPORATED are not interchangeable, and only one form exists in the index.

Set expand_hierarchy=true to also retrieve the ultimate corporate parent and all subsidiary names. Pass the full all_names list as the value of a current_assignees (or original_assignees) filter to cover an entire corporate group.

Parameter	Type	Required	Default	Description
`query`	string	Yes	—	Company name or prefix (1–200 chars). Use the full official name — common abbreviations may not match.
`expand_hierarchy`	boolean	No	`false`	Include ultimate owner + all subsidiary names in `all_names`. Only available for entities in the curated dictionary (mostly Russell 3000 / S&P 500 / Nikkei 225 / DAX 40); for other entities, `relationship`, `ultimate_owner`, and `country` are returned as `null`.

Returns: Up to 10 ranked results with name, all_names, relationship (owner, subsidiary, or former_name), ultimate_owner, and country.

Note: Assignee/company names only. Inventor names are not supported — names vary too widely (transliterations, name order, abbreviations) to resolve reliably, and the inventors filter is not available.

`party_count` — Verify assignee names exist and count their patents 1 credit

Confirm that one or more exact assignee names exist in the index and count how many patents each holds. Deterministic — no LLM, no web; the same input always returns the same output. Use this to verify a portfolio size before listing it, or to compare several companies at once.

Names are matched exactly (including casing) against the stored assignee form — call lookup_party first to resolve a free-text company name. An unknown name is reported per-name (exists: false, patent_count: 0), never as an error, so exists distinguishes an unknown name from a real one filtered to zero.

Parameter	Type	Required	Default	Description
`names`	string[]	Yes	—	Exact stored assignee names (case-sensitive), 1–50 entries. List a company’s stored variants together for a merged total.
`search_conditions`	object	No	—	JSON filter object to narrow the count (see Filter conditions). A `current_assignees`/`original_assignees` condition ANDs with `names` (the co-assignee query).
`breakdown`	string	No	—	Set to `authority` to also return per-jurisdiction counts alongside the total.

Returns: results (per-name name / exists / patent_count, in request order), total (union count over patents that have a publication date — a patent held by several listed names counts once), and breakdown (per-authority counts when requested). total equals party_patents’s total under the same names + conditions.

`party_patents` — List an assignee’s patents (cursor-paginated) 1 credit/page

Enumerate the patents held by one or more exact assignee names, publication date descending, as a clean paginated list. Synchronous — no task submission or polling. For semantic / topic search use semantic_patent_search instead; for a free-text company name, resolve it with lookup_party first.

Names are matched exactly. An unknown name simply contributes nothing (no error); a filter matching nothing returns an empty list.

Parameter	Type	Required	Default	Description
`names`	string[]	Yes	—	Exact stored assignee names (case-sensitive), 1–50 entries. Variants of one company can be listed together to merge their portfolios.
`search_conditions`	object	No	—	JSON filter object to narrow the list (see Filter conditions).
`limit`	integer	No	100	Page size, 1–200 patents per page.
`cursor`	string	No	—	Opaque token from the previous page’s `next`. Omit for the first page; `next: null` means done.

Returns: total (exact count under the same filter), items (patent summaries — publication_number, publication_date, filing_date, authority, legal_status, publication_type, language, current_assignees, ipcs, cpcs; no title), and next (cursor for the next page, or null when exhausted). Fetch full content per publication_number with get_patent.

Patent content

`get_patent` — Retrieve content of a patent by publication number 1 credit

Fetch content of a specific patent. You can request specific sections or all of them. Supported formatting variants and known publication mappings are normalized before retrieval. Responses are bounded and paged; to read a patent’s complete text in one call, use get_patent_full_text.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number (e.g., US-11234567-B2)
`sections`	string[]	No	`["abstract", "dates"]`	Any of `abstract`, `claims`, `description`, `dates`, `parties`, `classifications`, `legal_events`, `family`, or the shorthand `all`.
`family_scope`	string	No	`simple`	Family relation when `family` is requested: `simple` (DOCDB) or `extended` (INPADOC).
`max_chars`	integer	No	`16000`	Shared body-text budget for `abstract`, `claims`, and `description` (1,000–64,000). Cuts preserve whole claims and description paragraphs.
`limit`	integer	No	`50`	Maximum items returned for each `family` or `legal_events` list (1–200).
`cursor`	string	No	—	Opaque continuation token from `truncations[].next_cursor`. Continue exactly one section at a time.
`paragraph_numbers`	string[]	No	—	Up to 20 as-filed paragraph numbers to retrieve from `description`, such as `0034`.
`completion_required`	boolean	No	`false`	Deprecated; leave `false`. To read complete sections, use `get_patent_full_text`. When `true`, reading continues until `is_completed` is `true`.

Returns: Sparse patent content for the requested sections, plus the current legal_status and publication_type. Unrequested section fields are omitted; requested sections with no source data return null or an empty list. truncations reports bounded content and supplies a per-section next_cursor; completion reads also report is_completed, returned and remaining characters, and estimated calls left. Temporary section failures appear in section_errors without discarding successful sections.

For citations, use the dedicated get_patent_forward_citations, get_patent_backward_patent_citations, and get_patent_backward_npl_citations tools.

`get_patent_full_text` — Read a patent’s complete text in one call 1 credit

Return a patent’s complete abstract, claims, and description as one Markdown document in a single call, with no cursor and no size limit. Use it when the task needs the whole text, such as reading, summarizing, or comparing an entire patent. Use get_patent for selected sections, specific paragraphs, or bibliographic data, and search_patent_content to locate a term without reading everything.

Sections appear in abstract, claims, description order with as-filed paragraph numbers, headings, lists, tables, and text formulas preserved. The result is text only: figures and image-only formulas or chemical structures are not included, while figure references in the prose, such as the brief description of the drawings, remain.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number. Accepts supported formatting variants and known publication mappings.
`sections`	string[]	No	all three	Any non-empty subset of `abstract`, `claims`, and `description`.

Returns: publication_number, title, url, the sections included, and markdown containing the complete text. Requested sections without source text are listed in unavailable_content. Long patents produce long results.

`batch_get_patents` — Retrieve multiple patents in one call 1 credit/patent

Fetch bounded, structured content for multiple patents in a single request. Request only the sections needed; successful rows are preserved when another patent or section fails.

Parameter	Type	Required	Default	Description
`publication_numbers`	string[]	Yes	—	Array of patent publication numbers. Maximum 25 per call.
`sections`	string[]	No	`["abstract", "dates"]`	Same section options as `get_patent`, including `legal_events`.
`family_scope`	string	No	`simple`	Family relation applied to every row: `simple` (DOCDB) or `extended` (INPADOC).
`limit`	integer	No	`50`	Maximum items in each row’s `family` or `legal_events` list (1–200).
`max_chars`	integer	No	`8000`	Body-text budget per patent (1,000–64,000), fairly shared under a 60,000-character aggregate limit.

Returns: A results array of sparse patent rows with current legal_status and publication_type. Each failed row carries a structured error, while successful rows remain available. Temporary section failures appear in that row’s section_errors; whole-batch failures set the top-level error and return an empty results array.

`search_patent_content` — Find relevant text inside one patent 1 credit

Search a patent’s abstract, claims, and description for keywords or phrases. Use this to locate relevant passages, then pass returned description paragraph numbers to get_patent for precise retrieval.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number. Accepts supported formatting variants and known publication mappings.
`q`	string	Yes	—	Search text (1–500 characters). In relevance mode, quoted phrases are boosted and `-word` excludes matches containing that word.
`sections`	string[]	No	all three	Any subset of `abstract`, `claims`, and `description`.
`match`	string	No	`relevance`	`relevance` for ranked token and phrase matching, or `exact` for a literal case-insensitive substring.
`cursor`	string	No	—	Opaque token from the previous page’s `next_cursor`.
`limit`	integer	No	`10`	Maximum hits on this page (1–50).

Returns: Ranked hits with section, para_num, text, and score, plus total_matches, has_more, and next_cursor. Description hits use the patent’s real as-filed paragraph number when one exists; abstract and claim hits set para_num to null.

`get_patent_forward_citations` — Patents that cite this patent 1 credit

Get forward citations — patents that cite this one (patents only, no NPL). Useful for impact / influence and downstream-patent analysis. Forward citations can number in the thousands for foundational patents, so the result is paginated — fetch the next page with the returned pagination.next_offset.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number whose citing patents to retrieve (e.g., US-11234567-B2). Accepts supported formatting variants and known publication mappings.
`scope`	string	No	`family`	`family` (INPADOC extended family — matches the web view) or `patent` (this publication only; faster, smaller)
`limit`	integer	No	25	Max citations per page (1–100)
`offset`	integer	No	0	Start offset within the full list; pass `pagination.next_offset` from the prior page

Returns: citations with compact publication_number, url, source, title, publication date, current legal_status, and publication_type; the applied scope; and pagination (offset / limit / returned / total / has_more / next_offset).

`get_patent_backward_patent_citations` — Patents this patent cites 1 credit

Get backward patent citations — patents that this patent cites (patents only; for non-patent literature use get_patent_backward_npl_citations). Use cited_in to trace every occurrence to its family member, citation-report source, examiner category, and related claims. Each citation row’s categories field is a compact summary derived from that row’s cited_in occurrences; cited_in is authoritative. Categories and claims belong to that source_member, which may differ from the patent requested. When an occurrence cannot be attributed to one report, its nested source is null. Paginated — fetch more with pagination.next_offset.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number whose backward patent citations to retrieve (e.g., US-11234567-B2). Accepts supported formatting variants and known publication mappings.
`scope`	string	No	`family`	`simple` (DOCDB family), `extended` (INPADOC family), or `patent` (this publication only). `family` remains an alias for `extended`.
`limit`	integer	No	25	Max citations per page (1–100)
`offset`	integer	No	0	Start offset within the full list; pass `pagination.next_offset` from the prior page

Returns: citations with compact publication_number, url, categories, cited_in, title, publication date, current legal_status, and publication_type. Each cited_in occurrence records { source_member, source, category, rel_claims } and is the authoritative provenance. The response also reports the applied scope and pagination.

`get_patent_backward_npl_citations` — Non-patent literature this patent cites 1 credit

Get backward non-patent-literature (NPL) citations — papers, books, standards, etc. that this patent cites. NPL exists only on the backward direction. Paginated — fetch more with pagination.next_offset.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number whose non-patent-literature citations to retrieve (e.g., US-11234567-B2). Accepts supported formatting variants and known publication mappings.
`scope`	string	No	`family`	`simple` (DOCDB family), `extended` (INPADOC family), or `patent` (this publication only). `family` remains an alias for `extended`.
`limit`	integer	No	25	Max citations per page (1–100)
`offset`	integer	No	0	Start offset within the full list; pass `pagination.next_offset` from the prior page

Returns: citations (a list of { text, source, category, author, title, date }), the applied scope, and pagination.

`get_patent_attachments` — List a patent’s PDF & drawing attachments 1 credit

List the stored binary attachments of a patent — the full-document PDF and drawings (figures). Returns metadata and a download_url for each file. Binary content is not returned over MCP — download from the URL with a Bearer access token — send Authorization: Bearer <token> (the same authenticated session used to call this tool); X-API-Key is not a supported auth mode for these URLs. Coverage varies by authority and publication date; an empty list means nothing is stored.

This tool is behind a feature flag. If it does not appear in your client’s tool list, it is not enabled for your account — use the REST endpoints below instead.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number whose attachments to list (e.g., US-10000000-B2). Accepts supported formatting variants and known publication mappings.

Returns: count and an attachments array, each with filename, media, size, kind, and download_url.

Convenience REST endpoints (outside MCP): GET /api/patents/{publication_number}/pdf (full PDF) and GET /api/patents/{publication_number}/images/abstract (cover figure as PNG).

`get_patent_transfers` — Ownership / assignment transfer history 1 credit

Get a patent’s transfer (assignment) history — who owned it and when ownership changed. Combines USPTO reassignment records (US patents) and transfer legal events (CN/EP/… patents) into one timeline, newest first. For the current owner only, use get_patent with sections=["parties"] instead. An empty list means no transfer was recorded.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number whose ownership transfers to retrieve (e.g., US-10000000-B2). Accepts supported formatting variants and known publication mappings.

Returns: count and a transfers array, each with date, type, from_parties, to_parties, details, and source.

`get_patent_translations` — Stored multilingual text variants 1 credit

Get the language variants of a patent’s text (title, abstract, claims, description) as stored in the corpus — for example, Chinese patents carry both ZH and EN text. This is not on-demand machine translation: if the requested language is not stored, the best available variant is returned with is_fallback=true — check available_languages in the response.

Parameter	Type	Required	Default	Description
`publication_number`	string	Yes	—	Patent publication number (e.g., CN-111932531-A). Accepts supported formatting variants and known publication mappings.
`lang`	string	Yes	—	Requested language code (ISO 639-1, 2 letters, e.g. `EN`, `ZH`, `JA`, `DE`)
`fields`	string[]	No	`["title", "abstract"]`	Array of: `title`, `abstract`, `claims`, `description`
`family_fallback`	boolean	No	`false`	When a field is missing entirely (e.g. an EP-B1 with no abstract), borrow it from a patent-family member. Borrowed fields carry `from_family_member`.

Returns: The requested fields plus available_languages. Long fields are truncated to 8,000 characters.

Reports

`generate_novelty_report` — Generate a novelty & patentability report 720 credits

Run a novelty and patentability assessment for an invention description. Returns a report_id — poll with get_report_status to track progress. Typically takes 5–15 minutes.

Parameter	Type	Required	Default	Description
`description`	string	Yes	—	Description of the invention (min 10 chars)
`prior_art`	string[]	No	—	Array of known prior art UCIDs to include
`skip_search`	boolean	No	`false`	Skip automatic prior art search and use only the patents in `prior_art`. Requires `prior_art` to be set — the request is rejected if you set `skip_search=true` without supplying patents.

Returns: report_id for polling with get_report_status.

`get_report_status` — Check report generation progress Free

Check the progress of a novelty report. Returns stage information and patent analysis counts.

Parameter	Type	Required	Default	Description
`report_id`	string	Yes	—	ID returned by `generate_novelty_report`

Returns: Progress with stage, total/processed/relevant patent counts, and elapsed time.

Stages: pending → searching → analyzing_query → analyzing_patents → analyzing_final → completed

`get_report_summary` — Get executive summary and patent directory Free

Get the patentability assessment and a directory of analyzed patents from a completed report. Report status must be completed.

Parameter	Type	Required	Default	Description
`report_id`	string	Yes	—	ID returned by `generate_novelty_report`
`directory_limit`	integer	No	`30`	Maximum directory entries returned on this page (1–100).
`directory_offset`	integer	No	`0`	Starting offset for this directory page.

Returns: Patentability assessment, executive_summary (verdict explanation), a compact relevant_prior_art selection, and a paginated directory of accessible analyzed patents. The directory includes patents outside the relevant-prior-art selection; use is_relevant to distinguish them.

Follow directory_pagination.next_offset in subsequent calls to retrieve the remaining directory pages. limited_preview and hidden_patents indicate when report access is restricted; pagination does not unlock hidden content.

`get_report_patent_analysis` — Get detailed analysis for specific patents Free

Retrieve detailed per-patent analysis from a completed report. Report status must be completed.

Parameter	Type	Required	Default	Description
`report_id`	string	Yes	—	ID returned by `generate_novelty_report`
`publication_numbers`	string[]	Yes	—	Array of patent UCIDs (max 10)

Returns: Detailed analysis for each accessible patent with relevance scores, sorted by relevance. withheld identifies requested analyses that exist but require the report to be unlocked; not_found identifies requested analyses that are absent.

Account

`get_usage` — Check credit balance and billing periods Free

Returns your current credit balance and billing period details.

Not available in ChatGPT. This tool is exposed to Claude, Cursor, and other MCP clients. In ChatGPT, check your balance on the Plan & Credits page instead.

Parameter	Type	Required	Default	Description
—	—	—	—	No parameters required

Returns: Total remaining credits, reserved credits (held for in-progress operations), and billing period details with expiry dates.

New accounts get a 14-day free trial (10,000 credits) automatically the first time a request needs credits — there’s no separate activation tool to call.

Filter conditions

semantic_patent_search, prior_art_search, party_count, and party_patents accept an optional search_conditions parameter — a JSON object (not a serialized JSON string) describing the filters to apply. Conditions support and/or logic and can be nested for complex queries.

Structure


{
  "operator": "and" | "or",
  "conditions": [
    { "field": "<name>", "operator": "<op>", "value": <value> }
  ]
}

Supported fields and operators

Field	Operators	Value
`filing_date`, `publication_date`, `expiration_date`	`gte`, `lte`, `gt`, `lt`, `between`	`YYYYMMDD` string (or `[from, to]` for `between`)
`authority`, `language`	`in`, `not_in`	List of codes, e.g. `["US", "EP"]`
`cpc_codes`, `ipc_codes`	`in`, `not_in`, `contains`, `not_contains`	List of classification symbols
`current_assignees`	`in`, `not_in`, `contains`, `not_contains`	List of standardized company names — the current owner. See note below
`original_assignees`	`in`, `not_in`, `contains`, `not_contains`	List of standardized company names — the owner at filing time (differs from `current_assignees` when the patent was reassigned). See note below
`legal_status`	`eq`, `in`	`pending`, `in_force`, `patented`, `abandoned`, `lapsed`, `expired`, or `revoked`
`publication_type`	`eq`, `in`	`application` or `grant`

Use lookup_classifications to find the right CPC/IPC codes before adding them to a filter.

Discovering assignee names. The current_assignees / original_assignees filters are an exact-string match against the canonical name stored on patent records — Qualcomm, Qualcomm Inc., and QUALCOMM INCORPORATED are not interchangeable, and only one form exists in the index. Always call lookup_party first to resolve the user’s intent into the correct standardized name(s). Use expand_hierarchy=true and pass the returned all_names list as the filter value to cover an entire corporate group. To match a company as either the current or the original assignee, or the two fields together in a nested condition group.

Inventor-name filtering is not supported. Inventor names vary too widely (transliterations, diacritics, name order, abbreviations) to resolve reliably and we have no inventor-suggest mechanism.

Example — US/EP patents published since 2020 in a specific CPC area


{
  "operator": "and",
  "conditions": [
    { "field": "authority", "operator": "in", "value": ["US", "EP"] },
    { "field": "publication_date", "operator": "gte", "value": "20200101" },
    { "field": "cpc_codes", "operator": "in", "value": ["H01L"] }
  ]
}

Example — patents assigned to a corporate group (after lookup_party)


{
  "operator": "and",
  "conditions": [
    { "field": "current_assignees", "operator": "in", "value": ["Qualcomm Inc", "Qualcomm Technologies, Inc.", "Qualcomm Atheros, Inc."] },
    { "field": "legal_status", "operator": "in", "value": ["pending", "in_force", "patented"] }
  ]
}

Getting started

Here is a complete first-time flow, from connecting to fetching your first patent:

You: Get the abstract and claims for patent US-20160143891-A1

Assistant: (your GoVeda account has no credits yet, so this request automatically activates your 14-day free trial — 10,000 credits, shared with the GoVeda web app — then calls get_patent with sections=["abstract", "claims"])

Here’s patent US-20160143891-A1: …

Free trial credits are shared between MCP and the GoVeda web app. Check your balance with get_usage in Claude, Cursor, and other MCP clients, or on the Plan & Credits page from any client.

Troubleshooting

“Insufficient credits.” Add credits on the Plan & Credits page. In Claude, Cursor, and other MCP clients you can also check your balance with get_usage; ChatGPT does not expose that tool.

OAuth sign-in loop. Clear your browser cookies for mcp.goveda.com and try connecting again.

Tool not found. Make sure your MCP client is configured with the correct endpoint (https://mcp.goveda.com/mcp) and HTTP transport.

Tool reference

Search & discovery

semantic_patent_search — Semantic search across 220M+ global patents 50–590 credits

discover_patent_references — Find candidates for unresolved patent references Free

prior_art_search — Find prior art for a given patent 690–2,850 credits

get_search_status — Check status of a prior art search Free

lookup_classifications — Find CPC/IPC classification codes by keyword or symbol Free

lookup_party — Resolve a company name to its standardized assignee form 1 credit

party_count — Verify assignee names exist and count their patents 1 credit

party_patents — List an assignee’s patents (cursor-paginated) 1 credit/page

Patent content

get_patent — Retrieve content of a patent by publication number 1 credit

get_patent_full_text — Read a patent’s complete text in one call 1 credit

batch_get_patents — Retrieve multiple patents in one call 1 credit/patent

search_patent_content — Find relevant text inside one patent 1 credit

get_patent_forward_citations — Patents that cite this patent 1 credit

get_patent_backward_patent_citations — Patents this patent cites 1 credit

get_patent_backward_npl_citations — Non-patent literature this patent cites 1 credit

get_patent_attachments — List a patent’s PDF & drawing attachments 1 credit

get_patent_transfers — Ownership / assignment transfer history 1 credit

get_patent_translations — Stored multilingual text variants 1 credit