# US Patents Scraper — Search, Keyword & Assignee (`logiover/patentsview-scraper`) Actor

Scrape US patents by keyword, assignee, or date range. Extract patent ID, title, date, abstract, inventors, assignees, CPC class, type, and claims count. No API key required.

- **URL**: https://apify.com/logiover/patentsview-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## US Patents Scraper — Search Patents by Keyword, Assignee & Inventor (No API Key)

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00A67E?logo=apify\&logoColor=white)](https://apify.com/logiover/patentsview-scraper)
[![Run on Apify](https://img.shields.io/badge/▶️_Run_on_Apify-00A67E?logo=apify\&logoColor=white)](https://apify.com/logiover/patentsview-scraper)
![No API key](https://img.shields.io/badge/No%20API%20key-required-2ea44f)
![No login](https://img.shields.io/badge/No%20login-required-2ea44f)
![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-F59E0B)
![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)

> ### ▶️ [Run the US Patents Scraper on Apify →](https://apify.com/logiover/patentsview-scraper)
>
> This repository is **documentation only**. The scraper itself runs as a hosted Actor on the Apify platform — no setup, no infrastructure, no code to maintain.

Scrape **patent search results** by keyword, **assignee (owner company)**, inventor name, date range and patent office in a single run. The **US Patents Scraper** turns a plain search query into a clean, structured dataset of patents — **patent ID, title, publication & filing dates, abstract, assignees, inventors, CPC classification, patent type, claim count and direct links to the patent page and PDF**. Search US patents by default, or switch to any major office worldwide (EP, WIPO/PCT, JP, CN, KR, DE, GB and more). **No API key, no login, no developer account** — just a query and you get hundreds to thousands of patents back.

Leave every filter empty and the Actor returns the **most recent patents** automatically, so you always get a live feed. Use it as an unofficial **patent search API alternative** for competitive intelligence, prior-art discovery, IP landscaping, technology scouting and R\&D analytics.

***

### 📤 What you get (output fields)

Every run writes one structured row per patent to your Apify dataset. Fields:

| Field | Description |
|-------|-------------|
| `patent_id` | Publication number (e.g. `US12615098B2`). |
| `title` | Patent title. |
| `patent_date` | Publication or grant date (`YYYY-MM-DD`). |
| `filing_date` | Application filing date (`YYYY-MM-DD`). |
| `priority_date` | Earliest priority date (`YYYY-MM-DD`). |
| `abstract` | Abstract snippet. |
| `assignees` | Assignee / owner company name(s). |
| `inventors` | Inventor name(s). |
| `cpc_class` | Cooperative Patent Classification code(s). |
| `type` | Detected type: grant, application, utility, design or patent. |
| `num_claims` | Claim count when available. |
| `patent_url` | Patent page URL. |
| `pdf_url` | Direct PDF URL when available. |
| `country` | Two-letter office / country code from the publication number. |
| `status` | Legal status stage when available. |

### 💡 Use cases

- **Competitive IP intelligence** — track every new patent filed by a rival company by setting `assignee` to their name (e.g. `Samsung`, `Apple`, `Tesla`).
- **Prior-art & freedom-to-operate search** — pull all patents matching a technical keyword before filing, to surface conflicting claims early.
- **Technology scouting & landscaping** — map who is patenting in a field (e.g. `solid-state battery`, `mRNA`, `LiDAR`) and how activity trends over time by publication date.
- **R\&D and innovation analytics** — build a dataset of CPC classes, claim counts and filing dates to quantify a technology area or a company's portfolio.
- **Inventor & talent tracking** — follow a named inventor's output across companies with the `inventor` filter.
- **M\&A and investment due diligence** — assess a target's patent footprint (volume, assignees, recency) as part of technical due diligence.
- **Academic & policy research** — assemble structured, exportable patent datasets for bibliometric and innovation studies.
- **Patent monetization & licensing** — find licensable patents in a niche by keyword and assignee, with direct links to the full document and PDF.

### 🚀 Quick start (4 ways)

#### 1) Apify Console (no code)

1. Open the [US Patents Scraper](https://apify.com/logiover/patentsview-scraper) and click **Try for free**.
2. Type a keyword in **Search Query** (or leave everything empty for the newest patents), optionally add an **Assignee** or **Date From/To**.
3. Click **Start**, then open the **Output** tab and export to **JSON, CSV or Excel**.

#### 2) Apify CLI

```bash
npm install -g apify-cli
apify login
## Run with default input (newest patents)
apify call logiover/patentsview-scraper
```

#### 3) API / curl (run and get results in one call)

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~patentsview-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "machine learning",
    "assignee": "Google",
    "dateFrom": "2023-01-01",
    "countryCode": "US",
    "maxResults": 200
  }'
```

#### 4) apify-client (JavaScript & Python)

See [`examples/javascript.md`](examples/javascript.md) and [`examples/python.md`](examples/python.md). More curl recipes in [`examples/api-curl.md`](examples/api-curl.md) and CLI recipes in [`examples/cli.md`](examples/cli.md).

### 📥 Input

All inputs are **optional** — run it as-is to get the most recent patents.

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | Keyword(s) to search in patent titles and abstracts (e.g. `battery`, `solar panel`). Leave empty for the newest patents. |
| `assignee` | string | Filter by assignee / owner company (e.g. `Samsung`, `Apple`, `Tesla`). |
| `inventor` | string | Filter by inventor last name or full name (e.g. `Smith`, `John Smith`). |
| `dateFrom` | string | Only patents published on/after this date (`YYYY-MM-DD`). |
| `dateTo` | string | Only patents published on/before this date (`YYYY-MM-DD`). |
| `countryCode` | select | Patent office. Default `US`. Choose **All offices** for worldwide, or pick `EP`, `WO`, `JP`, `CN`, `KR`, `DE`, `GB`, `FR`, `CA`, `AU`, `IN`, `RU`, `BR`, `ES`, `IT`, `NL`, `CH`, `SE`, `TW`. |
| `sort` | select | `relevance`, `new` (newest first) or `old` (oldest first). Newest-first is used automatically when no filters are set. |
| `maxResults` | integer | Max patents to scrape. Default `200`. Set `0` to pull everything available (capped at ~10,000 per query). |
| `proxyConfig` | object | Proxy settings. Apify Proxy (automatic) is recommended. |

> **Dropdowns:** `countryCode` and `sort` are select menus in the Console. Set `countryCode` to `ALL` for a worldwide search across every office.

### 📦 Output sample

A realistic dataset row:

```json
{
  "patent_id": "US12615098B2",
  "title": "Machine learning system for adaptive battery management",
  "patent_date": "2024-03-19",
  "filing_date": "2022-08-01",
  "priority_date": "2021-08-02",
  "abstract": "A method for predicting battery state-of-charge using a trained neural network that adapts to cell degradation over time…",
  "assignees": "Google LLC",
  "inventors": "Jane R. Smith; Wei Chen",
  "cpc_class": "G06N3/08; H01M10/48",
  "type": "grant",
  "num_claims": 20,
  "patent_url": "https://patents.google.com/patent/US12615098B2/en",
  "pdf_url": "https://patentimages.storage.googleapis.com/…/US12615098B2.pdf",
  "country": "US",
  "status": "Active"
}
```

### 🔌 Integrations & automation

Because the scraper runs on Apify, you can plug patent data into anything:

- **Schedules** — run daily/weekly to monitor new patents from a competitor (`assignee`) or in a technology field (`query`).
- **Webhooks** — trigger a downstream workflow the moment a run finishes.
- **Google Sheets / Airtable** — auto-append new patents to a tracking sheet.
- **Amazon S3 / storage** — archive each run's dataset.
- **Zapier · Make · n8n · Pipedream** — connect via the Apify integrations to route new patents into Slack, email, a database or a BI dashboard.
- **Apify API** — start runs and pull the dataset programmatically from your own backend.

### 📄 Export formats

Download any run's dataset as **CSV, JSON, JSONL, Excel (XLSX) or XML** from the Console, or fetch it through the Apify Dataset API in the format you need.

### ❓ FAQ

#### How do I search patents by keyword without an API key?

Open the [US Patents Scraper](https://apify.com/logiover/patentsview-scraper), type your keyword into **Search Query**, and run it. No developer account, OAuth or API key is required — you get structured patent results (title, assignee, inventors, dates, CPC, claims and links) back as a dataset.

#### Is this a patent search API alternative?

Yes. It works as an unofficial **patent search API alternative** — you send a query, assignee, inventor or date range and receive clean, structured patent data without stitching together an official API, keys or pagination logic.

#### Can I scrape patents by company (assignee)?

Yes. Set the `assignee` field to a company name such as `Apple`, `Samsung` or `Tesla` to pull that company's patents. Combine it with `dateFrom`/`dateTo` to track only recent filings.

#### Can I search patents from offices other than the US?

Yes. Set `countryCode` to any supported office — `EP` (Europe), `WO` (WIPO/PCT), `JP`, `CN`, `KR`, `DE`, `GB`, `FR` and more — or choose **All offices** for a worldwide search.

#### How many patents can I get in one run?

Hundreds to thousands. Use `maxResults` to bound a run (default `200`), or set it to `0` to pull everything available for the query (capped at ~10,000 results per query).

#### How do I export patent data to Excel or CSV?

Run the Actor, then download the dataset as **Excel, CSV, JSON or XML** from the Apify Console, or pull it via the Apify API — a ready patent-data export for spreadsheets and databases.

#### Does it include the patent abstract, CPC class and claim count?

Yes. Each row includes an `abstract` snippet, the `cpc_class` classification code(s), the detected `type` (grant/application/utility/design) and `num_claims` when available, plus links to the patent page and PDF.

#### Can I get only the newest patents?

Yes. Leave the search fields empty (or set `sort` to `new`) and the Actor returns the most recent patents automatically — ideal for a scheduled "latest patents" feed.

#### How do I do a prior-art search with this?

Set `query` to the core technical terms of your invention and (optionally) a date range, then review the returned titles, abstracts and CPC classes for conflicting claims — a fast first-pass prior-art and freedom-to-operate scan.

#### Is it free?

The Actor runs on Apify's pay-per-result model with a free tier to start — try it, then scale up. See the **Pricing** tab on the [Actor page](https://apify.com/logiover/patentsview-scraper).

### 🔗 Related actors by logiover

- [Crunchbase Company Data Scraper](https://apify.com/logiover/crunchbase-scraper) — company, funding & investor data for IP + M\&A due diligence.
- [GitHub Repo & Activity Scraper](https://apify.com/logiover/github-activity-scraper) — track a company's open-source and engineering activity alongside its patents.

👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across B2B data, real estate, jobs, crypto and social media.

***

📄 **Documentation only** — this repository contains no source code. The Actor runs on the Apify platform.
▶️ **Run it:** https://apify.com/logiover/patentsview-scraper

Released under the [MIT License](LICENSE) · © 2026 logiover

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Recovered the Actor's missing README from the maintained canonical documentation copy after the live Apify source was found to contain only a broken ../README.md pointer; all 15 documented output fields match the typed dataset contract and retained live samples.

# Actor input Schema

## `query` (type: `string`):

Optional. Keyword(s) to search in patent titles and abstracts (e.g. 'battery', 'solar panel', 'machine learning'). Leave every filter empty to return the most recent patents.

## `assignee` (type: `string`):

Optional. Filter by patent assignee/owner company name (e.g. 'Samsung', 'Apple', 'Tesla').

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

Optional. Filter by inventor last name or full name (e.g. 'Smith', 'John Smith').

## `dateFrom` (type: `string`):

Optional. Only patents published on or after this date (e.g. '2022-01-01').

## `dateTo` (type: `string`):

Optional. Only patents published on or before this date (e.g. '2024-12-31').

## `countryCode` (type: `string`):

Patent office to search. Default 'US'. Choose 'All offices' for worldwide results.

## `sort` (type: `string`):

Result ordering. 'Newest first' is used automatically when no search filters are provided.

## `maxResults` (type: `integer`):

Maximum number of patents to scrape (bounds the run so it stays fast & cheap). Set 0 to pull everything available (Google Patents caps at ~10,000 per query).

## `proxyConfig` (type: `object`):

Proxy settings for scraping. Apify Proxy (automatic) is recommended.

## Actor input object example

```json
{
  "query": "machine learning",
  "countryCode": "US",
  "sort": "new",
  "maxResults": 200,
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All patents extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "query": "machine learning",
    "proxyConfig": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/patentsview-scraper").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 = {
    "query": "machine learning",
    "proxyConfig": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/patentsview-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "query": "machine learning",
  "proxyConfig": {
    "useApifyProxy": true
  }
}' |
apify call logiover/patentsview-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/patentsview-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/hG04duB3AEyOtnD9M/builds/okG8TimG5Kp2g6ixc/openapi.json