- Brand
- Unknown
- Category
- Pending
- Primary Subcategory
- Pending
Integration details
Description
Search and analyze IP Author's 183M-publication global patent corpus and US prosecution data. • Run guided prior-art, freedom-to-operate, patent-landscape, evidence-of-use, and SEP-essentiality workflows; • Inspect application file wrappers, claims, citations, specifications, and response arguments; • Compare examiners; and • Prepare downloadable research artifacts. Results are research support, not legal opinions, and should be reviewed by qualified counsel.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Category
- Pending
- Primary Subcategory
- Pending
- Secondary Subcategories
- None listed
- Brand
- Unknown
- Access
- Account required
- First tracked
- 2026-10-15
- Tool count
- 20
- Geography
- US
The broad Category that contains the Primary Subcategory.
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Your score is coming
ChatGPT now suggests Plugins on its own when they match a user's request.Your Plugin Discovery Score measures how often yours appears, and it will show here as soon as it’s ready.
What discovery looks like

Get alerts for IP Author
Get updates when IP Author’s Discoverability Score or category rank changes.
Competitive lineup
20 tools agents can invoke
Parsed structured citations for a US application — the prior-art references that were either submitted by the applicant (IDS / SB-08 / 1449 forms) or cited by the examiner (892 form). Each row identifies one cited reference with: cited_ucid (patent UCID like 'US-20200351973-A1', or null for NPL); npl_text (free-form for non-patent literature, null for patents); cited_by ('applicant' / 'examiner' / 'third_party'); source_document_code (IDS / 1449 / SB08 / 892 / REF.OTHER); submission_date; considered (examiner-initialed flag, relevant for IDS forms only); pcs_verified (whether the UCID resolved in the corpus); pcs_metadata (title / pd / famid / ab_snippet from the corpus when verified); and npl_url + npl_snippet when enrichment has run. Supports invalidity, FTO, and prior-art-mapping workflows. Typical parameter patterns: - 'what prior art has the applicant disclosed?' → cited_by_filter=['applicant'] - 'what art did the examiner find?' → cited_by_filter=['examiner'], document_codes=['892'] - 'clean corpus-verified prior-art set, no NPL noise' → only_pcs_verified=true Returns an empty list (count=0) when no IDS-class citations are on record for this app — the applicant may have filed none yet, or they have not been processed yet. Either way the response is valid and safe to act on.
application_citations
Fetch the body text (raw_text) of one document from a US application's file wrapper. The body_ref comes from a prior application_filewrapper call — every entry in data.documents has a body_ref field. This tool exists so you can fetch ONLY the bodies the user actually needs after triaging the metadata, instead of pulling every body inline by default. Designed for requests about a specific document — 'what does the final rejection say?', 'show me the applicant's remarks from 2026-04-07', etc. Each call returns ~10-50 KB (one body), so the response fits inline cleanly. If the user wants the bodies of several documents, each body_ref identifies one document. The body_ref is an opaque value from application_filewrapper and is not client-decodable.
application_document_body
Pull the complete prosecution + publication record for a US application. Merges three sources into a metadata-only view by default: (a) office actions and the applicant's formal responses; (b) supplemental filing documents (CLM = claims-as-filed, REM = applicant remarks, A... = amendments, SPEC, IDS, NOA, etc.); each has document_code, mail_date, direction, body_ref, and optional download_url; (c) patent-publication metadata when the app is published — title, abstract, publication number, UCID, assignee, status. Claims (clm) and specification (desc) bodies are NOT included by default — see application_spec for those. Patent identity: top-level `patent_number` is the GRANTED US patent number from the USPTO applications table (null while the app is pending), with `grant_date`, `filing_date`, and `application_status_text` alongside. The publication number is distinct from the granted patent number and identifies the pre-grant A1 UCID for a pending application (e.g. app 16024707: patent_number=11355438, publication US-20200006232-A1). Each document in data.documents carries a `body_ref` (an opaque string) and a `raw_text_size` or `file_size_bytes` hint. To fetch the body text of a specific document, pass that body_ref to application_document_body. The body_ref is an opaque continuation value and is not client-decodable. This lazy-fetch design keeps the default response small (~5 KB) so you can triage 7-doc filewrappers without burning context, then pull only the bodies the user actually needs. Optional high-volume fields: - include_body=true: inline raw_text for every document in one call. Convenient but bloats the response (~70-500 KB). - include_pcs_full_text=true: inline the full claim + description text too. The per-document body_ref path is the lower-volume option when every body is not required. Parsed prior-art citation rows (IDS / 892 / 1449 forms — structured records of which references the applicant disclosed and which ones the examiner cited) are available from application_citations and are not bundled here. When publication metadata is present it includes the title and abstract. Document bodies are available separately by body_ref, and full claims or specification text is available through application_spec.
application_filewrapper
Given a US application with an office action, find the closest precedent office actions: granted applications handled by the SAME examiner that received the SAME statutory rejection (for example a 35 U.S.C. 103 obviousness rejection) and were overcome to reach grant. Results are ranked by how much subject matter they share with the target, measured by overlapping CPC subclass, so the closest technical matches come first. Each precedent carries the granted patent number (the proof it was overcome), the shared CPC subclasses, and a short preview of the rejection it faced. Use it to show an attorney how this examiner's comparable rejections were successfully answered before drafting a response. The statute, examiner, and art unit default to the target application's own record; override `statute` for a different rejection, or `examiner_name` to study how a different examiner handled it. When no same-examiner precedent shares a CPC subclass, it falls back to same examiner plus statute plus art unit. `match_mode` in the result says which path was used, and `warnings` explains any empty result. To read how a specific precedent was overcome, pass its application number to application_response_arguments or application_filewrapper.
application_precedents
Fetch the full specification (desc, ~50-500 KB) and claims (clm, ~10-50 KB) of a published US application from the IP Author patent corpus. Used for drafting, amendment, claim-construction, §112 written-description analysis, and prior-art mapping. Title and abstract are NOT returned here — they're already in application_filewrapper's metadata. This tool is intended for requests that require the full disclosure body. Unpublished / pre-publication apps (no published corpus text) fall back to the as-filed SPEC and CLM documents from the USPTO file wrapper — `_source` says so when that happened. Errors only when neither the corpus nor filing documents have the text.
application_spec
**Bulk-download full-document patent PDFs.** Accepts a list of patent UCIDs (e.g. from a `search` result) and returns a single ZIP of their full-document PDFs plus a coverage report. Max 500 UCIDs per batch. The operation self-polls: a quickly completed batch returns the full result inline; otherwise it returns a `next_step` identifying `bulk_download` with the result's `job_id` as the continuation — each call keeps working and returns the ZIP directly when it is ready. Large batches take MINUTES (a few hundred PDFs is normally 2-4 minutes). Continuation calls use the job_id; an in-progress state is not a failure and the download is delivered only when the result carries `download_url`. While a job is running, continuation uses its `job_id`; resubmitting the UCID list creates another batch. The result carries `download_url` (a ZIP link), `retrieved` (how many were found), and two shortfall buckets: `missing`/`missing_ucids` (no PDF available for those — usually older or non-US patents) and `errors`/`error_ucids` (couldn't be retrieved this time — re-submitting just those UCIDs usually returns them).
bulk_download
Claim-by-claim amendment tracking for a US application. Diffs every claim snapshot (as-filed → each amendment round) in the file wrapper and returns a chronological timeline: which claims were added, canceled, or amended at each round, with before/after previews and a per-amendment length delta (a longer claim usually means added limitations = narrowing = prosecution-history estoppel risk). `summary` gives the headline (rounds, net claim change, claims ever added/removed). Supports estoppel and claim-scope-surrender analysis and shows how the claims reached their granted form. If no snapshots are parseable the result carries `advice` — a hydration gap, NOT 'no amendments were made'.
application_claim_evolution
**Get the processing status of an uploaded document.** Poll after uploading a PDF file until `status` changes from `processing` to `ready` (or `failed`). For inline text uploads (`document_upload`), status is always `ready` immediately — no polling needed. Response includes: `doc_id`, `name`, `type`, `status`, `pages`, `chars`, `expires_at`, and `error` (if failed).
document_status
**Register a large document (spec sheet, standard, product datasheet, invention disclosure) so an analysis can reference it by id instead of inlining its full text.** Accepts large documents already available as text — a multi-hundred-page standard, a long datasheet, or a full IDF. Returns a `doc_id` immediately with `status: ready`. Pass that `doc_id` to evidence_of_use or freedom_to_operate via their `doc_ids` input: the server resolves it to the document's text and reads it in full (chunked, never truncated), so a huge document never has to travel inline through a capped text field. For a binary PDF that has not been extracted yet, upload the file through IP Author's document upload and poll `document_status` until it is ready. Documents are consumer-scoped (only the uploading API key can access them) and expire 30 days from last reference. `expires_at` is returned so calling apps can warn users before expiry.
document_upload
Practitioner-grade evidence-of-use claim chart. `patent_ucid` is the only required input; the tool harvests its own product evidence. It maps a patent against a product for an infringement read, a claim chart, an evidence-of-use analysis, or an invalidity-vs-infringement comparison, running claim construction, prosecution-history estoppel, doctrine-of-equivalents analysis, visual comparison against the patent's drawings, a conservative review pass, and the all-elements rule over evidence it finds and ranks itself. `patent_ucid` alone identifies candidate (company, product) pairs from the claim language and charts the chosen one; add `company` / `company_url`, `product_urls`, `evidence`, or `product_description` to target a product; `doc_ids` (preferred for large files) or inline `product_file_contents` add uploaded documents; `patents=[UCID, …]` (max 10) runs a batch. Returns per-product `claim_charts[]` — each with construction, estoppel, element mappings, coverage, critical review, documentation gaps, decidability and assessment — alongside `claim_construction`, `prosecution_history`, `visual_corroboration`, `temporal` (the product's availability against the patent's priority and issue dates), `comparative_coverage`, `recommended_next_steps`, `_provenance`, and `workflow_guidance`. The language is neutral (overlap, correspondence); the construction, estoppel and doctrine-of-equivalents conclusions require attorney review, and it is not a legal opinion or an infringement determination. Heavy operation: roughly a minute per interactive step, several minutes for a full unattended run. Collaborative by default (see `autonomous`): it pauses for user confirmation or adjustment, and a review step advances only with the user's confirmation; the finished chart and export deliverables arrive in a completed result.
evidence_of_use
Head-to-head comparison of 2 US examiners: grant rate, statute rejection mix, art unit, average prosecution length, allowance after interview. Both name_a and name_b are required.
examiner_compare
Search IP Author's complete US Office-Action rejection corpus (~25M rejection paragraphs). Returns highlighted rejection excerpts plus Office-Action metadata such as mail date, examiner, application number, and rejection statute. `legal_reasoning_type_prefix` is the categorical search field. Rejections are organized into approximately 19 legal reasoning categories. For questions about Alice, KSR, anticipation, indefiniteness, or similar doctrines, use the category prefix. This covers category variants even when the rejection does not name the leading case and returns a structured `rejection_summary`. Available legal_reasoning_type_prefix values: - 101_Alice → all 3 Alice variants (mental_process, organizing_human_activity, mathematical_concept) - 101_Alice_mental_process | 101_Alice_organizing_human_activity | 101_Alice_mathematical_concept (more specific) - 102_anticipation → explicit + inherency - 103_TSM_combination | 103_KSR (5 KSR variants) - 112_indefiniteness | 112_written_description | 112_lack_of_enablement | 112_means_plus_function - double_patenting_obvious | double_patenting_statutory - restriction_requirement `q` supports specific named references (Fitzmaurice, Bilski) or phrases not captured by the available categories. Reading the response: - data.matches: result list. Each match has legal_reasoning_type (legal category), statute, rejection_summary (curated summary), and snippet (highlighted excerpt when q is supplied). - meta.total_match_count: corpus-wide count before the limit. When it is larger than match_count, you're seeing a sample, not the answer. - meta.next_offset: present when more results exist. Paginate by calling again with offset=<next_offset>. - meta.advice: rule-based suggestions for pagination or narrowing. Q syntax: whitespace-separated terms are ANDed. Multi-word queries miss variants that don't contain every word. A distinctive term ('Alice', 'Fitzmaurice', 'Bilski') generally has broader recall than a full citation. Use 'OR' / '"phrase"' / '-exclude' for fine control. Scoping (combine freely): - company: company name, matched across recognized name variants. - application_number: single app. Fastest path. - pd_from / pd_to: YYYYMMDD inclusive bounds on Office-Action mail date. - doc_types: CTNF / CTFR / NOA / CTAV / CTQU. - pending_only: when true, narrows to Office Actions on apps whose current status_text is one of the awaiting-response values (Final Rejection Mailed, Non Final Action Mailed, Advisory Action Mailed, Ex parte Quayle, Notice of Allowance Mailed). This supports a combined keyword, company, and pending-status search in one call. Sort modes: - 'relevance' (default): keyword-match strength. Best for prior-art-style retrieval. Degenerate for single-term queries (every match scores ~equal); the advice field will tell you to switch to date_desc if so. - 'date_desc' / 'date_asc': chronological browsing; date_desc places recent rejections first. Pagination uses limit (max 500) and offset; meta.next_offset is null after the final page. This tool returns matching rejection records and a total count, not corpus-wide distribution buckets — narrow the query or paginate to work through the matches.
filewrapper_search
Guided freedom-to-operate analysis. Finds active and pending patent rights that may cover a product, lets the user review the scope and candidates, compares shortlisted claims to the product, and produces an auditable clearance report with ranked risks, unresolved questions, and recommended physical checks. No preliminary retrieval call is required. The workflow is interactive by default: it returns the product's features, the search boundary, the surfaced patents and claims it proposes to read, the clearance read, and the output format, so the user can confirm or revise each. A review point advances only with the user's confirmation. New runs accept `product_description`, or `claim_elements` when the product features are already defined. The report includes the reviewed search scope, relevant granted and pending rights, claim-by-claim findings, legal-status and ownership context, mitigation considerations, and clear warnings for any unresolved scope or data gap. At the final review point the report can be delivered as a Word, Excel or PDF file to download. A partial result does not yet include the clearance conclusion.
freedom_to_operate
Continue a `landscape` run and collect the finished report using the `job_id` returned by `landscape`. It keeps working on the same run and returns the finished bundle directly when it is ready; if the run needs more time it returns the current progress plus a `next_step` identifying `landscape_status` with the same `job_id` as the next step. A result whose status starts with `completed` contains the report. Most runs take 30-240s; runs with `deep_taxonomy` can take up to ~8 minutes, and a stage that repeats across calls is normal, not a stall. While running, `progress` shows the step count and the current stage. Interim progress does not contain a landscape report. The completed bundle has the same structured sections, narrative hints, presentation outline, and optional private `report_url` as a completed `landscape` response.
landscape_status
**The landscape tool.** Comprehensive multi-section report: filer scorecard with composite quality index, filing trajectory + acceleration, geo + CPC distribution, crown jewels (multi-factor), technology evolution heatmap, whitespace matrix, SEP overlay, lead-lag, evolving pipeline (granted/pending/expiring), continuation stacking, M&A signals, momentum forecast. Add `market_context` via `augmentations` to also open with cited market/industry context. Persona-tailored output (vc | ip_director | litigator | rd_scientist | inventor). `q` determines which patents are analysed; `topic` is the plain-English label used for market context. Precise queries combine quoted phrases with OR and classification filters, for example tac_en:("5G NR" OR "5G New Radio") AND cpcpri:H04W*. Bare terms can match an excessively broad corpus. When `q` is absent, the short `topic` label becomes the patent search. A search matching too little or far too much is not reported as a landscape: the result carries status `insufficient_corpus` or `decomposition_required` plus a hint describing how the query can be adjusted. Drives itself: it submits and polls internally. For corpora over ~10k families this can take 90-240s (up to ~8 minutes with `deep_taxonomy`); if it does not finish within one window it returns a `job_id` and a `next_step` identifying `landscape_status` as the continuation tool. Re-entering `landscape` with that job opens another report view rather than polling the existing view. A completed result contains structured report sections, a narrative hint for each section, and a top-level `presentation.report_outline`. The outline identifies the recommended section order and table data, which carry the report's substance; a short bullet summary in their place omits most of it. Hosts that render inline app UIs show the landscape as an interactive report — charts, tables, section navigation — automatically; there is nothing to pass on for that. A completed run also carries `report_url`: that same interactive report, stored and openable only by the person who ran the search — a long signed link, meant as a labelled link rather than pasted as raw text. The field is absent when no interactive report was stored.
landscape
Search for prior art and assess novelty across patents, non-patent literature, or technical-standards contributions. A new search requires `corpus` and `corpus_because`; the server validates that the selected corpus matches the supplied user intent. The `standards` corpus applies to requests for standards contributions. That collection is currently strongest for multimedia video-coding inventions. A complete review may require separate searches across more than one corpus. The tool is collaborative by default: it returns reviewable invention framing, scope, date, filters, search terms, and ranked results so the user can confirm or revise them. A review step advances only with user-supplied confirmation. `autonomous=true` requires explicit user authorization to skip intermediate review; the run then applies defaults and stops at the ranked results — the same results screen, opening with the defaults it chose — where the user refines or picks the deliverable. Existing searches continue with fields returned by the prior result; a new search represents a different invention. A change to an earlier step after the results — the scope, the target date, a filter, the search — is a continuation of the same run: a continuation on the results step with the user's words (e.g. 'go back to the filters and set the year to 2020'); the run reopens that step and keeps the parked results and prior changes — none of it is lost by this reopening. (A new search for text that already has a paused run continues that run; `new_run=true` only if the user explicitly wants to start over.) Returns characterization, public filter and query specifications, ranked references with analysis, additional relevant references when available, and requested report or download deliverables. The subject patent and its related publications are excluded from invalidity results and disclosed in `self_excluded`.
prior_art_search
**Deep prosecution strategy brief** for an Office Action response decision. US prosecutions only. Composite of: file_wrapper + response_arguments + filewrapper_search (similar rejections), enriched with: - rejection-statute mix (the statutes cited in the latest Office Action) - argument patterns: named patterns like 'swearing behind under 1.131', 'TSM rebuttal', 'Graham secondary considerations', 'enablement carve-out' — each with a summary, frequency in the corpus, and 'when to use' note. - recommended_strategies with risk_level (low/med/high) and expected path to allowance - deadline math: statutory due date, USPTO 1-5 month extension fees (large/small/micro entity), AFCP 2.0 eligibility window - strategic options playbook: response (with/without amendment) / RCE / continuation / AFCP 2.0 / pre-appeal brief / full appeal — with viability, expected pendency, USPTO fees, and statute-driven preference annotations.
prosecution_strategy
Extract the argument sections from each prior response on a US application, showing what was argued and what worked. Merges the parsed responses table with applicant response documents (REM / amendments) from the file wrapper. Each response carries _source, and inline arguments_text when the stored body really is argument text; a text_quality flag means the response EXISTS but our stored copy is partial or unavailable. In that case the response and date remain present, and download_url points to the source document. The `_meta.advice` field describes data-quality limitations.
application_response_arguments
SEP essentiality assessment. Construes the claims, identifies the standard and release, reads the specification when it can be retrieved, maps every limitation to a provision, and re-checks each mapping before reaching a weakest-link verdict. Supports SEP essentiality analysis, declared-SEP checks, FRAND licensing research, and patent-to-standard mapping. The tool is collaborative by default: it returns the claims to assess, the standard and release it will chart against, whether the specification was actually retrieved, the limitation-to-provision mapping, and the output format, so the user can confirm or revise each. A review step advances only with user-supplied confirmation. Declared-SEP status (e.g. ETSI) is surfaced when known; standards are often paywalled, so the specification text can be supplied when a fetch is unavailable. A patent is standard-essential when a mandatory portion of the standard cannot be implemented without practicing every limitation of the claim, so the assessment follows the all-limitations / weakest-link rule. Returns the patent, the identified standard and release (with declared status), a per-claim mapping (each limitation with its verbatim normative text, section citation, and match strength), an overall assessment (verdict, confidence, essentiality type, key risks, recommended next steps), and a ready-to-read claim chart. The verdict is delivered in the completed result.
sep_analysis
Search the IP Author patent corpus (179M global publications) using a structured Boolean query DSL. Returns hits[] + the headline count via TOP-LEVEL `total_hits`. FAMILY-LEVEL RESULTS ARE THE DEFAULT (load-bearing): - One result per EXTENDED PATENT FAMILY, not per publication. So a search describes distinct inventions without counting the same family repeatedly. - `total_hits` is the complete family count for count questions. - `family_scope='single'` returns every publication, such as for per-country filing analysis. - `family_scope='simple_family'` groups by simple family. READING THE RESPONSE — load-bearing: - data.total_hits: the complete family-level count. `len(hits)` and facet bucket sums describe only the returned sample. - data.returned: how many rows were actually returned. - data.hits[]: one publication per family. - data.advice: rule-based hints about narrowing or pagination. - _pagination: cursor/has_more/total (mirror of total_hits for backward compat). ASSIGNEE FIELDS — pick the right one: - co: current parent rollup for portfolio-level counts ('all Huawei patents'). co:Huawei catches every Huawei subsidiary rolled up to the canonical parent. - pa: literal assignee name on the document, appropriate when you need a specific entity (e.g. counting 'Apple Computer, Inc.' separately from 'Apple Inc.'). It does not include subsidiary rollups. - normpaorig / suggestedpa: pre/post-reassignment canonical forms. Supports proximity operators (ADJ, NEAR, WITH, SAME, with W/N shorthands and numeric distances like NEAR5, 3W). **EMBEDDED BREAKDOWNS — load-bearing for efficient analysis:** - Every `search` response includes, in `data.facets`, top-5 buckets for top filers (`co`), primary CPC class (`cpcpri`), and publication year (`pdyear`) — a free overview of the result set in the same response, so you rarely need a second call just to break results down. - `auto_facets` selects different breakdown fields, including logical field, e.g. `auto_facets: ["pnctry", "adyear"]` (publication country, filing year); an empty array disables embedded breakdowns. **DATE-RANGE SHORTHAND**: `filters` accepts `{pd_from: "20200101", pd_to: "20251231"}`. Examples: co:Cisco AND pnctry:US AND pd:[20240101 TO *] clm:("zero trust" NEAR5 networking) co:(Qualcomm OR Huawei OR Samsung) AND tac_en:beamforming AND clm:5G AND pd:[20200101 TO *] ← correct for company rollup standards_declared:true AND co:Qualcomm*
search
IP Author ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve IP Author's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.