# Patent Lookup ✅ Company Portfolios, Inventors, Prior Art (`pvalyou/patent-lookup`) Actor

Patents by company, inventor, keywords, CPC or publication number from the EPO's official worldwide data: 100+ offices, family, legal status, citations, claims. Verified company portfolios. $0.002 per search, $0.0015 per patent row, no start fee beyond compute.

- **URL**: https://apify.com/pvalyou/patent-lookup.md
- **Developed by:** [Pvalyou](https://apify.com/pvalyou) (community)
- **Categories:** Developer tools, AI, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 patent rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🔬 Patent Lookup: a company's patents, an inventor's patents, prior art, one document in full

**Find out what a company has patented, what a person has invented, or what has already been filed on an idea, from the European Patent Office's official worldwide patent data.** Five modes, one Actor: a company portfolio with every row's applicant checked against the company name, an inventor's patents, a keyword search with CPC and office filters, a single publication number opened with its family, legal events, citations and claims, or every member of a patent family. Try it now with the prefilled input: the portfolios of `Mobileye Vision Technologies Ltd` and `Iscar Ltd`.

$0.002 a search and $0.0015 a patent row, for investors and analysts sizing a patent moat, competitive intelligence teams, R\&D and founders running a prior-art check, recruiters and IP operations. This patent search API does in one call what you would otherwise do by hand in Google Patents or Espacenet, one query and one company at a time, and it returns the rows as JSON with the family, the legal status and the citations attached.

The data is the EPO's own worldwide bibliographic database (DOCDB, 100+ patent offices), its legal-events database (INPADOC) and its full-text collections, read through the EPO's Open Patent Services under the EPO's terms of use. No scraping of Google Patents, no data broker, no inventor profiles built from anywhere else.

**What you get**

- ✅ **Company portfolios that keep namesakes out.** A company query is not a text search for the name. Every row that comes back has its applicant compared with the company name you gave, so "Medical Laser Systems" does not fill up with "Topcon Medical Laser Systems". Each row says whether the applicant is the company itself, another party, or unknown. Frequently requested companies answer from a pre-built portfolio that is refreshed every 90 days and stamped with its `as_of` date.
- ✅ **Every office, one schema.** US, EP, WO, CN, JP, KR, IL, DE, GB and the rest of the EPO's coverage return the same fields: publication number, title, abstract, inventors, applicant, priority, filing and publication dates, estimated expiry, granted flag, family id, IPC, CPC, Google Patents and Espacenet links.
- ✅ **One document in full.** Family members across offices, INPADOC legal events (examination, grant, fees, lapse), forward citations, and the claims and description text where the EPO carries it (EP and WO publications and several national collections).
- ✅ **Priced per row.** $0.002 per search, $0.0015 per patent row, $0.0075 per document, $0.003 per family, plus $0.00005 to start the run. A 50-patent portfolio costs about 8 cents. No match and invalid input cost nothing.

This is not a legal opinion and not a certified register extract. For legal proof order the document from the patent office.

### 👥 Who uses a patent lookup?

- 📈 **Investors and analysts.** Read a startup's patent moat before a round: how many families, which offices, granted or pending, who the inventors are, and whether the filings are recent, without a namesake's patents landing in the count.
- 🏢 **Competitive intelligence.** Pull a competitor's filings by office and year, collapse them to one row per family, and schedule the same run monthly to see what is new.
- 🧑‍🔬 **R\&D and founders.** Prior-art check before you file: keywords in title and abstract, narrowed by CPC class, office and publication date, with claims text on the EP and WO documents you want to read closely.
- 🎓 **Recruiters and researchers.** An inventor's patents across employers, plus the companies whose portfolios name that inventor, so a career reads from the patent record.
- ⚖️ **IP and legal operations.** A publication number opened with its family, its legal events and its forward citations, in structured JSON, for docketing checks and freedom-to-operate triage.
- 🤖 **AI agents and pipelines.** Structured JSON with the source and the as-of date on every row, callable from the Apify API, the MCP server and the Python and JavaScript clients. Priced per event, the platform's $0.00005 Actor start included, so it is eligible for agentic payment.

### ⬇️ Input: a mode and a list of queries

One run, one mode, any number of queries read in that mode. The prefilled input runs two company portfolios.

```json
{
  "mode": "company",
  "queries": ["Mobileye Vision Technologies Ltd", "Iscar Ltd"],
  "max_results": 100
}
```

| Field | What it does |
|---|---|
| `mode` | `company` (patents the company owns), `inventor` (patents naming a person), `search` (keywords with filters), `document` (one publication number in full), `family` (every member of a publication's family). |
| `queries` | One query per line: company names, inventor names, search phrases or publication numbers. Each entry may also be an object with `query`, `mode` and any filter below, so one run can mix modes. |
| `max_results` | Rows per company, inventor or search query, up to 500. Each row is one `patent_record` event. |
| `countries` | Offices to keep (`US`, `EP`, `WO`, `CN`, `JP`, `KR`, `IL` and the other two-letter codes). |
| `granted_only`, `one_per_family` | Keep granted patents only. Collapse each family to one row. |
| `published_from`, `published_to` | Inventor and search modes, publication date as `2020`, `2020-06` or `2020-06-15`. |
| `filed_from`, `filed_to` | Company mode, filing date as `YYYY-MM-DD`. |
| `cpc`, `ipc`, `applicant`, `inventor` | Search mode: classification symbols (comma separated, any matches) and applicant or inventor names to narrow the keyword search. |
| `company` | Inventor mode: keep patents where this company is the applicant. |
| `include` | Document mode: `family`, `legal`, `citations`, `claims`, `description`. Default family, legal and citations. |
| `offset` | Company, inventor and search modes: skip this many results before the first row, so a second run pages past the first `max_results` instead of returning them again. |
| `refresh` | Company mode: query the EPO now even when a pre-built portfolio exists. |

An empty query, a query over 200 characters (300 for a search), an unknown mode, or a document or family query that is not shaped like a publication number is rejected before any paid step, as an uncharged error item, and the run still ends normally.

Publication numbers are accepted in every common form: `EP3000000A1`, `US12724156B1`, `WO2023187781A1`, `US 2024/0394598 A1`, `ep3000000`.

### ⬆️ Output: one dataset item per patent row

Every item carries `type`, the `query` and `mode` it came from, and `charged`, so the dataset is the complete record of what you paid for.

| `type` | Charged | Contents |
|---|---|---|
| `patent` | once per row (`patent_record`) | one patent row from a company, inventor or search query |
| `search_summary` | once per company, inventor or search query (`patent_search`), once per family query (`patent_family`) | match status, source and as-of date, the company resolved, candidates, related companies, totals, `has_more`, `truncated` |
| `document` | once (`patent_document`) | the publication with the sections you asked for |
| `family_member` | never (the family's summary item is the charged one) | one member of the family, full patent row |
| `error` | never | an `error` code and a message |

A patent row from the first prefilled query:

```json
{
  "type": "patent", "query": "Mobileye Vision Technologies Ltd", "mode": "company",
  "charged": true, "charged_event": "patent_record",
  "publication_number": "US20260099146A1", "country_code": "US", "patent_number": "20260099146", "kind_code": "A1",
  "family_id": "93936260", "document_type": "publication", "application_id": "US202519416498",
  "priority_date": "2023-06-23", "filing_date": "2025-12-11", "publication_date": "2026-04-09",
  "estimated_expiration": "2045-12-11", "is_granted": false,
  "title": "Systems and methods for vehicle navigation",
  "abstract": "A system for navigating a host vehicle relative to a road segment is disclosed. The system may comprise at least one pro ...",
  "inventors": ["Lotan Roy Maor", "Harouche Shahar", "Shaag Nadav"],
  "applicant": "Mobileye Vision Technologies Ltd", "applicant_country": null, "applicant_match": "company",
  "priority_country": null, "ipc": "G05D1/243",
  "cpc": ["B60W10/20", "G05D1/2435", "G06N20/00", "G06N3/045", "G06V10/764", "G06V10/82", "G06V20/58", "G06V20/582", "G06V20/588"],
  "family_size": 100,
  "google_patents_url": "https://patents.google.com/patent/US20260099146A1/en",
  "espacenet_url": "https://worldwide.espacenet.com/patent/search?q=pn%3DUS20260099146A1",
  "source": "stored", "as_of": "2026-08-14", "search_term_used": "MOBILEYE VISION TECHNOLOGIES LTD", "confidence": 1.0
}
```

Its summary item, showing the company the query resolved to and how much more there is:

```json
{
  "type": "search_summary", "query": "Mobileye Vision Technologies Ltd", "mode": "company",
  "charged": true, "charged_event": "patent_search", "status": "matched", "source": "stored",
  "organization_name": "Mobileye Vision Technologies Ltd.", "organization_as_of": "2026-08-14",
  "organization_patents_total": 290, "candidates": [], "related_companies": [],
  "n_records": 100, "total_available": 290, "has_more": true, "truncated": false,
  "search_term_used": "MOBILEYE VISION TECHNOLOGIES LTD", "cql": null, "elapsed_s": 3.1
}
```

`source` is `stored` when the answer comes from a pre-built portfolio (then `as_of` is the date of its last refresh, at most 90 days ago) and `live` when the EPO was queried at the moment of your run (then `as_of` is today). `applicant_match` says whether the row's applicant is the company itself, another party (a co-applicant, a licensee, an inventor filing in their own name, or a transliterated name) or unknown. `related_companies` on an inventor query lists companies whose patent portfolios name that inventor, with their filing years.

A document item carries, on top of the patent row, `family` (members with office, kind and date), `legal_events` (INPADOC codes with dates and descriptions, for the whole family), `citations` (`forward_count` and the citing publications, backward citations where the EPO lists them), and `claims` and `description` as `{lang, text}` where the EPO carries full text.

Export the dataset as JSON, CSV, Excel or XML, or read it through the Apify API. Lists (`inventors`, `cpc`, `legal_events`) are kept as JSON in CSV exports.

### 💰 How much does a patent lookup cost?

| Event | Price | When it fires |
|---|---|---|
| `patent_search` | **$0.002** | once per company, inventor or search query, whatever it finds |
| `patent_record` | **$0.0015** | once per patent row returned by such a query |
| `patent_document` | **$0.0075** | once per publication opened in document mode, when it exists |
| `patent_family` | **$0.003** | once per family query that found the family |
| Actor start | **$0.00005** | once per run |
| No match, invalid input, rate limit, upstream failure | **free** | |

The worked examples below are the event charges only. The Actor start adds $0.00005 a run, so the prefilled input is $0.304 of events and $0.30405 in total:

- The prefilled input, two portfolios at 100 rows each: 2 x $0.002 + 200 x $0.0015 = **$0.304**.
- A 50-patent startup portfolio: $0.002 + 50 x $0.0015 = **$0.077**.
- One inventor with 12 patents: **$0.020**.
- A prior-art search returning 500 rows: **$0.752**.
- One publication opened with family, legal events and claims: **$0.0075**.
- A family of 8 members: **$0.003**.
- 1,000 company names checked, 600 with patents averaging 20 rows: 1,000 x $0.002 + 12,000 x $0.0015 = **$20.00**.

Set a spending limit on the run for a hard cap: the Actor stops before the next query once it is reached and marks any row it could not charge.

### 🗺️ What is covered

- **Offices.** The EPO's worldwide bibliographic database covers publications from more than 100 patent offices, with English titles and abstracts where the office supplies them. Claims and description text are available for EP and WO publications and several national collections. Legal events come from INPADOC and cover the offices that report to it.
- **Companies.** Any company that has filed a patent anywhere in the EPO's coverage. Frequently requested companies answer from a pre-built portfolio, built from the company's registered legal names (current, alternate and past) with only the families whose applicant matches one of them kept, refreshed every 90 days and dated. Every other company is searched live at the EPO with the same applicant check.
- **Inventors, keywords, documents and families** are always answered live from the EPO at the moment of the run.

### 🔎 How the lookup works

1. A company name is matched against the pre-built portfolios first: an exact match on the registered names, then a close match on the legal name. One clear winner is served from its portfolio with the `as_of` date. Two strong candidates come back as `ambiguous` with the shortlist, uncharged rows. Otherwise the EPO is searched live for the name as applicant, and every row's applicant is checked against the name before it is returned.
2. An inventor name, a keyword search and a document number are sent to the EPO as one query in its own query language (the `cql` field in the summary shows it). Filters for office and publication date go into the query, the granted and one-per-family filters are applied to what comes back.
3. Rows are resolved from the EPO's bibliographic service in batches, under a wall-clock budget of 150 seconds per query. A query cut short by the budget says so (`truncated: true`), and `has_more` on the summary says there are more rows: run it again with `offset` set to what you already have.
4. A document is opened by its exact publication number (the kind code decides the document, without it the granted publication wins, else the latest), then the sections you asked for are fetched one by one.
5. Nothing is estimated or inferred and no language model is involved: every field is the EPO's own value, and `confidence` scores the company-name match only.

### ⏱️ How long does a query take?

A pre-built portfolio answers in 2 to 4 seconds. A live company, inventor or search query takes 3 to 10 seconds for 100 rows and up to two minutes for 500, because the EPO paces search and retrieval per account. A document with family, legal events and claims takes 5 to 10 seconds. Queries run one after another, and two live queries may be in flight per API key, so a run of 100 company names finishes in a few minutes to a quarter of an hour.

### 🔌 Patent API, clients and integrations

Run the Actor from the Apify Console, from the [Apify API](https://docs.apify.com/api/v2), from the Python or JavaScript client, from the Apify MCP server, or from Make, Zapier and n8n through the Apify integrations. Schedule it to re-run a competitor list monthly, and set a webhook on run completion to pull the dataset into your own system.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("pvalyou/patent-lookup").call(run_input={
    "mode": "company",
    "queries": ["Mobileye Vision Technologies Ltd", {"query": "EP3000000A1", "mode": "document", "include": ["family", "legal", "claims"]}],
    "max_results": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["type"], item.get("publication_number"), item.get("title"), item.get("applicant"), item.get("charged"))
```

### 🔐 Data, licences and privacy

- **Official source.** Every answer is read from the European Patent Office's Open Patent Services, under the EPO's terms and conditions for OPS, which allow OPS data to be included in our own products and services and distributed as part of them. We do not scrape Google Patents or any other patent website, and we do not redistribute the EPO's data set as such: there is no bulk export mode.
- **Not a certified extract.** Bibliographic data, legal events and full text are the EPO's records as published. For legal proof order the document from the patent office. Legal events are informational and may lag the national office.
- **What we keep.** Pre-built company portfolios are retained, refreshed every 90 days and served with their `as_of` date, so you know how old such an answer is (`refresh` forces a live pass). Every other answer is passed through from the EPO to your run and not retained. Operational logs keep the query text, the mode, timing and the billing outcome, which is what running and billing the service needs.
- **Personal data.** Inventor names are printed in every patent publication by law, and we return them as the EPO publishes them. We build no inventor profiles from other sources. `related_companies` on an inventor query is computed from the patent record alone. Use inventor data in line with the laws of your jurisdiction. A person who wants a patent record corrected should ask the office that published it. Objections about this Actor's processing can be raised through the Issues tab on this page.
- **No access controls bypassed.** No CAPTCHA solving, no logins, no credentials of yours. The EPO's fair-use rules on volume and pacing are enforced in the service itself.

### ❓ FAQ

#### Is the data live?

Pre-built company portfolios are dated (`source: stored`, `as_of` the last refresh, at most 90 days old, `refresh: true` forces a live pass). Everything else is live from the EPO at the moment of the run (`source: live`).

#### Why did a company come back ambiguous?

Two or more pre-built portfolios carry that name, or a name that close. The summary item lists the candidates with their number of patents. Send the exact legal name, or use search mode with `applicant` for a raw applicant search that is not verified.

#### How is the company mode different from searching the applicant field?

An applicant search on any patent site matches the tokens of the name, so "Medical Laser Systems" also returns "Topcon Medical Laser Systems". Company mode checks every row's applicant against the company's name before returning it, and pre-built portfolios were built the same way against the company's registered names. `applicant_match` on each row tells you what the check found.

#### What does `applicant_match: other` mean?

The row belongs to a family that was verified by its applicant, but this member of it names another party: a co-applicant, a licensee, a subsidiary under a transliterated name, or an inventor filing in their own name. The row is kept and labelled rather than hidden.

#### Can I get backward citations?

Forward citations (publications citing this one) are returned on every document. Backward citations (what this document cites) are returned where the EPO lists them in the bibliographic record, which is mostly EP search reports, and `backward_count` is 0 otherwise. This is a limit of the source, not a paid extra.

#### Which documents have claims text?

EP and WO publications and several national collections the EPO holds in full text. For others `claims` is null and `claims_note` says so, and the row still carries the Google Patents and Espacenet links where the full text can be read.

#### Is it legal to use?

Yes. The EPO's terms for Open Patent Services permit including the data in our own products and services and distributing it as part of them, with no royalties. Patent publications are public records by design. Inventor names are personal data in some jurisdictions: use them lawfully.

#### Is there a free tier or a trial?

Every no-match, every rejected input and every failed query is free, and Apify's free plan credit covers the first paid lookups. There is no subscription: you pay per search, per row, per document and per family, and nothing else.

#### What is the EPO weekly allowance?

The EPO grants a weekly data allowance per account. If paid traffic ever uses it up, live queries answer with an uncharged error until Monday 00:00 GMT while pre-built portfolios keep answering, and the allowance is raised on our side.

### 📏 Limits

- A query is at most 200 characters (300 for a search), and each query has a wall-clock budget of 150 seconds in the service and 180 in the Actor.
- A company, inventor or search query returns at most 500 rows per run, from the first 500 results of the EPO's ranking. The summary says `has_more` when there are more.
- A family answer lists at most 100 members. Legal events cover the whole family of the document opened.
- At most two live queries are in flight per API key. Queries run one after another inside a run.
- Exact duplicates (same text, same mode) within one run are collapsed. The run's spending limit is honoured.

### 🔗 Works well with

A patent portfolio is one answer about a company, and the other five are sold the same way: [Company Enrichment API](https://apify.com/pvalyou/company-record) for firmographics, classification and funding, [Company Registry Lookup](https://apify.com/pvalyou/company-registry-lookup) for the registered legal names an applicant search should be run against, [LinkedIn Person Enrichment](https://apify.com/pvalyou/linkedin-person-enrichment) for the career record of an inventor, [Job Postings](https://apify.com/pvalyou/job-postings) for what the company is hiring for now, and [Website Liveness Check](https://apify.com/pvalyou/website-liveness-check) for whether it still has a live site.

### 💬 Support and feedback

Found a company that resolved wrong, a document that did not open, or a source you need? Open an issue on this Actor's page with the query, the mode and what you expected. Issues are answered by the developer.

### 📝 Changelog

- **0.1 (2026-09-08)** First public release: company, inventor, search, document and family modes on the EPO's Open Patent Services, four priced events.

# Actor input Schema

## `mode` (type: `string`):

How every query is read. Company: the patents a company owns (verified against the company's legal names). Inventor: patents naming a person. Search: keywords in title and abstract, narrowed by the filters below. Document: one publication number with family, legal status, citations and claims. Family: every member of a publication's family.

## `queries` (type: `array`):

One query per line, read in the mode above: company names, inventor names, search phrases or publication numbers (EP3000000A1, US12724156B1, WO2023187781A1). For programmatic use each entry may also be an object with 'query', 'mode' and any filter below, so one run can mix modes.

## `max_results` (type: `integer`):

Cap on the rows a company, inventor or search query returns. Each row is one patent\_record event. Up to 500 (the live search window). Larger portfolios: read has\_more in the summary, then run again with the same query and a higher offset.

## `offset` (type: `integer`):

Where the page starts for a company, inventor or search query. 0 is the first page. For the next page, raise it by the rows you already read (0, then 100, then 200 at 100 rows per query) for as long as has\_more in the summary stays true. A live search reaches 500 rows, a stored company portfolio reaches its whole size. Document and family modes ignore it.

## `countries` (type: `array`):

Keep only publications from these offices: US, EP, WO, CN, JP, KR, IL, DE, GB and the other two-letter codes. Empty means every office.

## `granted_only` (type: `boolean`):

Drop applications and keep granted patents (kind codes B, C, E, S, U, Y).

## `one_per_family` (type: `boolean`):

Collapse the members of each patent family to one row, so a portfolio counts inventions rather than filings.

## `published_from` (type: `string`):

Inventor and search modes: earliest publication date (2020, 2020-06, 2020-06-15).

## `published_to` (type: `string`):

Inventor and search modes: latest publication date.

## `filed_from` (type: `string`):

Company mode: earliest filing date, YYYY-MM-DD.

## `filed_to` (type: `string`):

Company mode: latest filing date, YYYY-MM-DD.

## `cpc` (type: `string`):

Search mode: CPC symbols, comma separated (G01S17, H04L9/06, A61K). Any of them matches.

## `ipc` (type: `string`):

Search mode: IPC symbols, comma separated.

## `applicant` (type: `string`):

Search mode: narrow the keyword search to this applicant name (token match, not verified).

## `inventor` (type: `string`):

Search mode: narrow the keyword search to this inventor.

## `company` (type: `string`):

Inventor mode: narrow to patents where this company is the applicant.

## `include` (type: `array`):

Document mode: which sections to fetch beyond the bibliographic record. Claims and description text exist for EP and WO publications and a few national collections.

## `refresh` (type: `boolean`):

Company mode: query the EPO now even when a pre-built portfolio exists (pre-built portfolios are refreshed every 90 days and carry their as\_of date).

## Actor input object example

```json
{
  "mode": "company",
  "queries": [
    "Mobileye Vision Technologies Ltd",
    "Iscar Ltd"
  ],
  "max_results": 100,
  "offset": 0,
  "granted_only": false,
  "one_per_family": false,
  "include": [
    "family",
    "legal",
    "citations"
  ],
  "refresh": false
}
```

# Actor output Schema

## `results` (type: `string`):

Every item of the run with every field it carries: patent rows, documents, family members, search summaries and error items.

## `patents` (type: `string`):

Every item of the run, shown as the patent columns: publication number, title, applicant, inventors, dates, granted, office, source and as-of date, total available, charged. A view picks the columns and never drops rows, so search summaries and error items are in this table too, with the per-patent columns left blank. The summary row carries the total available and whether more rows exist.

## `summaries` (type: `string`):

Every item of the run, shown as the search-summary columns: organisation matched, term and CQL searched, rows returned against total available, whether more exist, family members, offices, other candidates. A view picks the columns and never drops rows, so patent, document and family rows are in this table too, with the summary columns left blank.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "Mobileye Vision Technologies Ltd",
        "Iscar Ltd"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("pvalyou/patent-lookup").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        "Mobileye Vision Technologies Ltd",
        "Iscar Ltd",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("pvalyou/patent-lookup").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "Mobileye Vision Technologies Ltd",
    "Iscar Ltd"
  ]
}' |
apify call pvalyou/patent-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,pvalyou/patent-lookup"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/fdkhfQwsEAzQmVP8F/builds/GubW5RmomhZldJpj0/openapi.json