Google Patents MCP - Search, Details, Citations, AI Summaries

The Google Patents API for AI agents and IP professionals. Use this actor with Claude, Cursor, ChatGPT, or any MCP-compatible AI agent.

Search Google Patents by keyword, inventor, or assignee across USPTO, EPO, WIPO, JPO, CN, KR, and 100+ patent offices. Pull full patent details: claims, citations, family graphs, CPC classifications, and PDF URLs. Get AI-generated patent summaries (top assignees, inventors, and CPC classes with percentage and year-range frequency). Pay per event - no flat monthly fees.

What you get

Here is what the Google Patents MCP and API returns on every run:

• Search results across 100+ offices - patent id, title, snippet, assignee, inventor, and the priority, filing, grant, and publication dates for each hit from USPTO, EPO, WIPO, JPO, CN, KR, and more.
• Full patent details - claims text, CPC classifications, backward and forward citations, cited_by counts, worldwide applications, the family graph, legal events, images, and the PDF URL.
• AI patent summaries - top assignees, inventors, and CPC classes for any search, each with a percentage and a year-range frequency array for landscaping.
• Structured JSON - one clean row per search page or details record, ready to load into a sheet, a database, or an AI agent.

Use Cases: Google Patents MCP, API, and AI Summaries

• Run a prior-art search across 100+ offices, then export every hit as JSON for a claim-chart workflow.
• Pull the full claims text and citation network for one patent to support a freedom-to-operate review.
• Build a technology landscape from the AI summary block: top assignees and CPC classes with year-range frequency.
• Wire the Google Patents MCP into Claude or Cursor so an agent answers patent questions right in chat.
• Track a competitor's new filings on a schedule and alert your team when fresh applications appear.
• Search Google Patents AI filings by assignee to see which companies are patenting machine-learning methods.

Use it from your AI agent

Wire this actor into Claude, Cursor, ChatGPT, or any MCP client and your agent can run tasks like:

• "Find all patents filed by Apple in the last 5 years and return assignees, inventors, filing dates, and citation counts."
• "Pull the full claims, abstract, and citation network for patent US10123456B2."
• "Get an AI-generated summary of patents about graphene battery with the top assignees and CPC classes."
• "Monitor new patents filed in CPC class H01M for any new applications since last month."
• "Build a citation graph from patent US11734097B1 showing all backward and forward citations."
• "Find all patents by inventor John Smith at IBM and rank by forward citation count."

For IP attorneys, R&D teams, and patent valuation specialists

This actor is built for professional patent work:

• Prior-art search - Full keyword + filter search across 100+ offices with CPC/IPC classification filtering and date-range filtering on priority, filing, or publication dates.
• Freedom-to-operate analysis - Pull full claims text and citation networks for any patent in seconds; export as JSON to feed into your claim-chart workflow.
• Technology landscaping - The AI summary block returns top assignees and top CPC classes for any search, with year-range frequency arrays so you can visualize a technology landscape in one chart.
• Patent valuation - Forward citation counts (cited_by) come back with every details lookup, ready to feed citation-weighted valuation models.
• Competitive intelligence - byAssignee mode gives you every patent from a target company filtered to a country, type, status, and date range, in one call.

Quick start

Use as an MCP tool (Claude, Cursor, ChatGPT)

This actor runs on the Apify MCP server, so any MCP-compatible AI client can discover and call it.

1. Install the Apify MCP server. Point your client at the hosted endpoint:

https://mcp.apify.com

In a client that uses an mcpServers config (such as Claude Desktop or Cursor), add a server entry like this and restart the client:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}

The exact, per-client setup steps are in the Apify MCP integration docs.

2. Call this actor by name. Once the server is connected, your agent can find it through search-actors or call it directly by its full name:

johnvc/google-patents-api

Every input parameter carries an LLM-readable title and description, so the agent can pick the right inputs on its own.

Watch: how to install and use the Apify MCP server

New to MCP? This Apify walkthrough shows how to install the MCP server and use it to discover and run actors from Claude, Cursor, or any MCP client.

Run from the Apify console

1. Click Try for free on the actor page.
2. Fill in a search query, e.g. q: graphene battery, max_pages: 2.
3. Click Start. Results land in the default dataset, one row per search page.

Run via the Apify API

curl -X POST "https://api.apify.com/v2/acts/johnvc~google-patents-api/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "graphene battery",
    "country": "US,EP",
    "after": "filing:20200101",
    "max_pages": 3,
    "include_ai_summary": true
  }'

How to get started

• View this actor on the Store: Google Patents API on Apify.
• Clone the example repo for a Python quick start plus MCP setup walkthroughs for Claude, Cursor, and ChatGPT: Apify-Google-Patents-API on GitHub.
• New here? Follow the Quick start above, or wire the actor into your AI agent through the MCP steps.

Input parameters

The actor accepts one flat input form. The mode is implicit from which fields you fill:

Field	Type	Description
q	string	Free-text search query. At least one of q, patent_id, assignee, or inventor is required.
patent_id	string	Provide to fetch full details for a specific patent. Format patent/US10123456B2/en or patent/US10123456B2.
assignee	string	Comma-separated assignee names (e.g. Apple,Microsoft).
inventor	string	Comma-separated inventor names.
country	string	Comma-separated patent office codes: US, EP, WO, JP, KR, CN, DE, GB, FR, CA, AU, IN, ...
language	string	Comma-separated language codes: EN, DE, ZH, FR, ES, AR, JA, KO, PT, RU, IT, NL, SV, FI, NO, DA.
status	enum	GRANT or APPLICATION.
type	enum	PATENT or DESIGN.
before / after	string	Date filters in the form type:YYYYMMDD, where type is priority, filing, or publication.
sort	enum	relevance, new, old.
litigation	enum	YES or NO.
num	integer	Results per page (10 to 100, default 10).
max_pages	integer	Number of pages to fetch (default 1, 0 for unlimited).
include_ai_summary	boolean	Attach the AI summary block to the first page item.
include_details	boolean	After pagination, also pull full details for each result up to 10 patents.

Output

Each dataset item represents one page of search results (or one details record). The shape is:

{
  "search_parameters": { ... },
  "search_metadata": {
    "total_results": 1340,
    "patents_count": 10,
    "pages_processed": 1,
    "mode": "search"
  },
  "search_timestamp": "2026-05-14T12:34:56",
  "page_number": 1,
  "patents": [
    {
      "patent_id": "patent/US10123456B2/en",
      "title": "...",
      "snippet": "...",
      "assignee": ["..."],
      "inventor": ["..."],
      "priority_date": "2018-01-15",
      "filing_date": "2019-01-15",
      "grant_date": "2021-11-23",
      "publication_date": "2021-11-23",
      "publication_number": "US10123456B2",
      "pdf": "https://patentimages.storage.googleapis.com/..."
    }
  ],
  "ai_summary": {
    "assignees": [{ "key": "...", "percentage": 12.4, "frequency": [...] }],
    "inventors": [...],
    "cpc": [...]
  }
}

In details mode, the same item also carries a details object with claims, cpc_classifications, patent_citations, non_patent_citations, cited_by, worldwide_applications, parent/child/priority applications, legal_events, images, and the PDF URL.

Pricing

Pay per event:

Event	Price
Setup (per run)	$0.02
Page processed (one dataset item written)	$0.02

A search page (~10 patents), a details lookup, and a details-mode result each count as one page_processed. Use max_pages and include_details to control your total spend.

Scheduled monitoring

To monitor new filings, schedule this actor in the Apify console and pair it with the after: publication:YYYYMMDD parameter. Each run returns only patents published after your cursor date - feed the dataset into your downstream alerting workflow.

🔌 Integrations: Automate Google Patents Monitoring

A single run answers one question: who filed what, and when. The real value comes from running the Google Patents API repeatedly, so fresh filings, citations, and status changes land in your stack every day. See the full list of Apify platform integrations.

Tasks and Schedules (the core recipe). Save one task per thing you monitor (a task for assignee: Toyota, q: solid state battery, another for q: graphene battery), then attach a schedule from the actor's Actions, then Schedule menu. Pair each run with after: publication:YYYYMMDD so you only get patents published since your last cursor date. Useful cron strings: 0 7 * * * (daily 7 AM), 0 */6 * * * (every six hours), 0 9 * * 1 (Mondays). One schedule can trigger many tasks at once. The Track new solid state battery patents from Toyota task shows this pattern end to end.

n8n. This actor ships an n8n community node (see the n8n integration section below). A four-step monitor: Schedule Trigger, then the Google Patents node, then a Filter on new publication_number values, then Slack or email.

Make and Zapier. The same pattern works no-code with Make and Zapier: trigger on a schedule, run the actor, route the new rows where you need them.

Store the history (Supabase). Send each run's rows into a table so a filing history accumulates across runs. No-code: the n8n Actor node, then a Supabase node. Or in Python (each patent row carries patent_id, title, assignee, publication_number, filing_date, and publication_date):

from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_API_TOKEN")
supabase = create_client("YOUR_SUPABASE_URL", "YOUR_SUPABASE_KEY")

run = apify.actor("johnvc/google-patents-api").call(run_input={
    "assignee": "Toyota",
    "q": "solid state battery",
    "after": "publication:20260101",
    "max_pages": 3,
})

rows = []
for page in apify.dataset(run["defaultDatasetId"]).iterate_items():
    for p in page.get("patents", []):
        rows.append({
            "patent_id": p.get("patent_id"),
            "title": p.get("title"),
            "assignee": p.get("assignee"),
            "publication_number": p.get("publication_number"),
            "filing_date": p.get("filing_date"),
            "publication_date": p.get("publication_date"),
        })

supabase.table("patents").upsert(rows, on_conflict="patent_id").execute()

MCP and AI agents. Add the actor as a tool in any MCP client through the hosted Apify MCP server so Claude Code (free trial), Claude Cowork (free trial), Cursor, or ChatGPT can call it directly. An agent can answer a question like "which assignees dominate CPC class H01M this year?" in one step. The Run patent searches in Claude via a Google Patents MCP task shows this live.

Webhooks. For anything custom, fire an Apify webhook on ACTOR.RUN.SUCCEEDED to push each run's dataset into your own service.

🔗 Related Tools

Patent research rarely stops at patents. These related johnvc APIs cover the neighboring research, litigation, news, and company data:

• Google Scholar API - academic papers, citations, and author profiles for the non-patent prior-art searches that run alongside your patent hits.
• Google Scholar Case Law API - US court opinions and case law for freedom-to-operate and patent-litigation research.
• Google News API - track product launches and competitor announcements next to their patent filings for competitive intelligence.
• Crunchbase Company API - funding, investors, and firmographics to enrich the assignee company behind a patent.

Prefer a single, actively maintained option? Thinner alternatives such as codingfrontend/google-patents-scraper return a limited field set (no CPC classifications, no patent family graph, and no AI summary), show a lower run success rate, and carry little adoption or user ratings. This API is actively maintained and returns clean, structured records with claims, citation networks, family graphs, CPC classes, and an optional AI summary.

Support

Issues or feature requests: open a ticket on the Apify actor page or message the maintainer through the Apify console.

---

n8n integration

Available as an n8n community node, n8n-nodes-google-patents-api. In n8n: Settings, Community Nodes, install n8n-nodes-google-patents-api, then use it in any workflow (it also works as an AI Agent tool).

---

Featured Tasks

Ready-to-run examples that show this API solving a specific problem. Each opens its own setup so you can run it on your account in one click.

• Find all patents assigned to OpenAI - OpenAI's patent portfolio with numbers, dates, inventors, and statuses.
• Track new solid state battery patents from Toyota - fresh Toyota solid-state battery filings with numbers and dates.
• Run patent searches in Claude via a Google Patents MCP - patent search inside Claude (free trial available) chat via MCP, with assignees and dates.

FAQ

Can I schedule the Google Patents API?

Yes. Any run can be automated on a schedule. Save a task with your query, then attach a schedule from the actor's Actions, then Schedule menu. Use 0 7 * * * for daily at 7 AM, 0 */6 * * * for every six hours, or 0 9 * * 1 for Monday mornings, and one schedule can trigger many tasks at once. Pair each run with after: publication:YYYYMMDD so you only receive fresh filings. See the Integrations section above for the full monitoring recipe.

Should I use an API or a web scraper for patent data?

An official patent API is often rate limited, quota bound, and missing fields like citation networks or family graphs. A web scraper pulls the same public data with no quota. This actor gives you both in one: a no-code scraper you run from the console, and a clean API endpoint you call yourself, returning claims, citations, CPC classes, and PDF links with no per-field limits.

Can I integrate this patent scraper with other apps?

Yes. The actor connects to almost any cloud service through Apify integrations, including Make, Zapier, and Slack. For anything custom, use webhooks on ACTOR.RUN.SUCCEEDED. The Integrations section above has the full recipes.

Can I use the Google Patents API programmatically?

Yes. The Apify API lets you run the actor, schedule it, and fetch datasets from your own code, and the apify-client package is available for both Node.js and Python. See the actor's own API tab for ready-made snippets.

Can I use this as a Google Patents MCP server?

Yes. Add the actor as a tool in any MCP client through the hosted Apify MCP server using the actor-specific URL https://mcp.apify.com/?tools=actors,docs,johnvc/google-patents-api. That lets Claude Code (free trial), Claude Cowork (free trial), Cursor, or ChatGPT run patent searches in chat. See the Apify MCP docs.

What is the API for the Google Patents database?

This actor is that API. Google Patents is a free index of over 120 million patent documents from USPTO, EPO, WIPO, JPO, and 100+ offices, but it has no official public API. This actor gives you a programmatic endpoint over the same patent data: search, details, citations, family graphs, and CPC classifications, all returned as structured JSON.

Are Google AI patents just for defensive purposes?

The actor does not judge intent; it returns the public filing record so you can decide. Search Google Patents AI filings by assignee, then read the status (GRANT or APPLICATION), the claims, and the forward citation counts to see how actively a machine-learning patent is being built on. Whether a filing is defensive or offensive is a legal judgment; the data (dates, claims, citations, legal events) is what the actor gives you.

How else can I research prior art and IP?

Patent research rarely stops at patents. Pair this API with related johnvc tools: the Google Scholar API for non-patent prior art and citations, the Google Scholar Case Law API for litigation and freedom-to-operate research, the Google News API for competitive intelligence, and the Crunchbase Company API to enrich the assignee company. See Related Tools above for a thinner competitor comparison.

Last Updated: 2026.07.13