# Google Patents Owner & Assignee Lookup (`datapilot/google-patents-owner-assignee-lookup`) Actor

Search Google Patents by assignee with this Apify Actor. Retrieve patent titles, publication numbers, assignee names, publication dates, and export structured results. Supports keyword-based searches, Apify Proxy, and saves data directly to your Apify Dataset.

- **URL**: https://apify.com/datapilot/google-patents-owner-assignee-lookup.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

🔍 **Google Patents** Owner & Assignee Lookup is a powerful Apify Actor designed to discover and collect patent records directly from Google Patents by assignee (owner) name. This tool provides comprehensive **Google Patents** intelligence including publication number, title, assignee, and filing/grant date for every patent matching a given owner. Whether you're conducting IP due diligence, tracking a competitor's patent portfolio, or building a patent research dataset, the Google Patents Owner & Assignee Lookup delivers actionable **Google Patents** insights efficiently.

With direct Google Patents query integration, assignee-based search, configurable result limits, and reliable Apify Dataset delivery, the Google Patents Owner & Assignee Lookup ensures comprehensive **Google Patents** coverage for any company or inventor name. It focuses on key **Google Patents** signals including publication number, title, and assignee metadata, making it an essential tool for IP research and competitive intelligence.

***

### 📋 Table of Contents

- [Features](#-features)
- [Data Source](#-data-source)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields-explained)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Billing](#-billing)
- [Important Notes](#-important-notes)
- [Changelog](#-changelog)
- [Support](#-support--feedback)
- [License & Legal](#-license--legal)

***

### 🔥 Features

- **Google Patents API Integration** – Direct integration with Google Patents' internal query endpoint.
- **Assignee-Based Search** – Query patents by owner/assignee name with a single keyword input.
- **Configurable Result Limit** – Control how many patent records are fetched per run.
- **XSSI-Safe JSON Parsing** – Automatically strips Google's anti-hijacking response prefix before parsing.
- **Nested Response Handling** – Handles Google's nested content-wrapped JSON structure transparently.
- **Rich Patent Metadata** – Captures publication number, title, assignee, and best-available date (grant, publication, filing, or priority date).
- **Residential Proxy Support** – Apify residential proxy for reliable, uninterrupted access.
- **Real-Time Dataset Push** – Pushes results to Apify Dataset in a single batch.
- **Detailed Logging** – Logs search progress and final record counts.
- **Async Architecture** – Non-blocking async/await design using `httpx`.
- **Graceful Error Handling** – Logs and exits cleanly on HTTP errors or malformed responses.

***

### 📊 Data Source

#### **Google Patents Query Endpoint**

- **Authority**: Google Patents' public search interface
- **Endpoint**: `patents.google.com/xhr/query`
- **Coverage**: Global patent publications indexed by Google Patents
- **Data**: Publication number, title, assignee, and key dates
- **Access**: Public, key-less JSON endpoint (XSSI-protected)
- **Update Frequency**: Reflects Google Patents' current index at time of run

***

### ⚙️ How It Works

The Google Patents Owner & Assignee Lookup accepts an assignee/owner keyword and queries Google Patents' internal search endpoint with an `assignee:"..."` filter. The raw response is stripped of Google's XSSI protection prefix, parsed as JSON, and — if nested — unwrapped from its `content` field. Each result cluster is walked to extract publication number, title, assignee, and the best-available date field. All matching records are combined and pushed to the Apify Dataset in a single batch.

**Key Processing Steps:**

1. **Input Parsing** – Accept assignee keyword and result limit
2. **Query Construction** – Build an `assignee:"<keyword>"` search query
3. **Proxy Setup** – Configure Apify residential proxy
4. **API Query** – Fetch results from the Google Patents query endpoint
5. **XSSI Stripping** – Remove Google's `)]}'` anti-hijacking prefix
6. **JSON Parsing** – Parse the response, unwrapping nested `content` if present
7. **Result Extraction** – Walk clusters to extract patent-level records
8. **Field Mapping** – Extract publication number, title, assignee, and date
9. **Timestamp Tagging** – Record scrape time per entry
10. **Dataset Push** – Push all matched records in a single batch
11. **Summary Logging** – Report total records found or warn on empty results

**Key Benefits:**

- Pull **Google Patents** records for any company or inventor without manual searches
- Build assignee-level patent portfolios for IP research
- Track competitor patent activity over time
- Feed IP due-diligence workflows, dashboards, or research pipelines
- Automate recurring checks as new patents are published

***

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `keyword` | string | *(required)* | The assignee/owner name to search for (e.g., "Google LLC", "Tesla, Inc."). |
| `max_results` | integer | `50` | Maximum number of patent records to request per run. |
| `useApifyProxy` | boolean | `true` | Enable Apify residential proxies. |
| `apifyProxyGroups` | array | `["RESIDENTIAL"]` | Proxy group configuration. |

**Example Input:**

```json
{
  "keyword": "Tesla, Inc.",
  "max_results": 100
}
```

**Fetch a Small Sample for a Company:**

```json
{
  "keyword": "Apple Inc.",
  "max_results": 20
}
```

**Fetch Without Proxy:**

```json
{
  "keyword": "OpenAI OpCo, LLC",
  "max_results": 50,
  "useApifyProxy": false
}
```

***

### 📤 Output

The Actor pushes **Google Patents** records with the following structure:

| Field | Type | Description |
|-------|------|-------------|
| `assignment_id` | string | Publication number, used as the record identifier |
| `patent` | string | Combined "publication number — title" display string |
| `title` | string | Patent title |
| `publication_number` | string | Google Patents publication number |
| `assignee` | string | Assignee/owner name as recorded by Google Patents |
| `date` | string | Best-available date (grant, publication, filing, or priority date) |
| `scraped_at` | string | ISO 8601 timestamp of when the record was scraped |

**Example Google Patents Record:**

```json
{
  "assignment_id": "US11234567B2",
  "patent": "US11234567B2 — Battery thermal management system",
  "title": "Battery thermal management system",
  "publication_number": "US11234567B2",
  "assignee": "Tesla, Inc.",
  "date": "2024-03-15",
  "scraped_at": "2026-08-02T09:00:00+00:00"
}
```

***

### 🧰 Technical Stack

- **API:** Google Patents internal query endpoint (`xhr/query`, JSON format)
- **HTTP Client:** `httpx` for async HTTP requests
- **JSON Parsing:** Standard `json` handling with XSSI-prefix stripping
- **Date Handling:** `datetime` with timezone-aware UTC timestamps
- **Async:** `asyncio` for non-blocking request handling
- **Proxy:** Apify Proxy with `RESIDENTIAL` configuration
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment

***

### 📊 Data Fields Explained

#### **Patent Identification**

- **assignment\_id / publication\_number**: The unique publication number identifying the patent
- **title**: The official title of the patent as published

#### **Ownership**

- **assignee**: The company or individual listed as the patent owner/assignee

#### **Timing**

- **date**: The most relevant available date — grant date preferred, falling back to publication, filing, or priority date

***

### 🎯 Use Cases

- **IP Due Diligence** – Review a company's patent portfolio before an acquisition or investment
- **Competitive Intelligence** – Track competitors' patent filings and grants over time
- **Prior Art Research** – Identify existing patents held by a specific assignee
- **Academic Research** – Study innovation trends by company or inventor
- **Patent Portfolio Audits** – Compile a complete list of patents owned by an organization
- **Legal Research** – Support IP litigation or licensing negotiations with ownership data
- **Market Research** – Gauge R\&D activity and technology focus by assignee
- **Investment Research** – Assess a company's IP strength as part of valuation

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "keyword": "Tesla, Inc.",
  "max_results": 50
}
```

#### **2. Run the Actor**

Click **Start**. The Actor will:

- Build an assignee-filtered search query
- Query the Google Patents endpoint
- Parse and extract patent records
- Push all results to the Dataset

#### **3. Monitor Progress**

Console shows:

```
Initializing Google Patents Scraper for Assignee: 'Tesla, Inc.'
[Google Patents] Searching for assignee: 'Tesla, Inc.'...
Done! Successfully saved 50 patent(s) to Apify Dataset.
```

#### **4. View & Download Results**

- **Results Tab**: All **Google Patents** records
- **Export**: JSON, CSV, Excel, or HTML
- **Filter**: By assignee, publication number, or date
- **API Access**: Available via the Apify API

***

### ⚙️ Configuration

Single assignee, default limit:

```json
{
  "keyword": "Samsung Electronics Co., Ltd."
}
```

Large batch with proxy:

```json
{
  "keyword": "Microsoft Technology Licensing, LLC",
  "max_results": 200,
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"]
}
```

Small sample without proxy:

```json
{
  "keyword": "SpaceX",
  "max_results": 10,
  "useApifyProxy": false
}
```

***

### 📈 Performance

#### **Processing Speed**

- One request per run against the Google Patents query endpoint
- Result size controlled directly by `max_results`
- Scales with the number of records requested per assignee

#### **Resource Usage**

- Memory: Low, proportional to the number of records returned
- Network: Single outbound request per run
- Proxy: One residential proxy session per run

***

### 💰 Billing

#### **Batch Billing**

- **Billing Model:** Batch push (not per-record PPE)
- **Typical Cost:** Proportional to total patent records fetched
- **Efficiency:** Single-request design keeps runs fast and cost-efficient

***

### ⚠️ Important Notes

#### **Legal & Compliance**

- **Fair Use**: Respects Google Patents' public endpoint and reasonable rate limits
- **Official Source**: Pulls exclusively from Google Patents' own query interface
- **Accuracy**: Data reflects Google Patents' current index at time of run
- **Verification**: Cross-check critical ownership details against the official Google Patents website or national patent offices
- **Legal**: Not legal advice — consult a qualified IP attorney for legal or licensing decisions

#### **Data Quality**

- **Freshness**: Reflects Google Patents' index at the time of the run
- **Completeness**: Assignee name variations (e.g., subsidiaries, name changes) may affect result coverage
- **Accuracy**: Sourced directly from Google Patents' public data
- **Verification**: Cross-check time-sensitive or high-stakes figures against the live Google Patents portal

#### **Best Practices**

- Try multiple name variations for the same company (e.g., "Tesla, Inc." vs "Tesla Motors, Inc.") to maximize coverage
- Increase `max_results` gradually to avoid unnecessarily large runs
- Use a residential proxy for the most reliable access
- Re-run periodically to catch newly granted or published patents
- Combine results across name variants for a complete assignee portfolio

***

### 📦 Changelog

#### v1.0.0 (August 2026)

**Initial Release:**

- Google Patents query endpoint integration
- Assignee-based keyword search
- Configurable result limit
- XSSI-safe JSON parsing with nested content handling
- Publication number, title, assignee, and date extraction
- Apify residential proxy support
- Real-time Dataset push
- Async httpx architecture

***

### 🧑‍💻 Support & Feedback

- **Issues:** Submit via Apify console with the assignee keyword used
- **Documentation:** Check the Actor details page
- **Community:** Apify forum discussions
- **Feature Requests:** Suggest additional patent fields to extract
- **Bug Reports:** Include the keyword, expected result, and error details

***

### 📄 License & Legal

**Terms of Use:**

- Use for legitimate IP research, due diligence, and competitive intelligence
- Respect Google Patents' Terms of Service
- Attribute Google Patents as the original data source where required
- Use data responsibly

**Disclaimer:**
Google Patents Owner & Assignee Lookup is provided as-is for research purposes. Users are responsible for compliance with Google's ToS. This is not legal advice.

***

### 🎉 Get Started Today

**Deploy now for Google Patents research!**

Use for:

- 🔍 IP Due Diligence
- 📊 Competitive Patent Tracking
- 💡 Prior Art Research
- 📈 Patent Portfolio Audits
- 🎯 Innovation Intelligence

**Perfect for:**

- IP Attorneys & Paralegals
- Competitive Intelligence Analysts
- Investment & M\&A Researchers
- R\&D and Innovation Teams

***

**Last Updated:** August 2026
**Version:** 1.0.0
**Status:** Production Ready
**Platform:** Apify Actor
**Architecture:** Async/Await
**Data Source:** Google Patents Query Endpoint

***

### 📚 Related Tools

- USPTO Trademark Lookup
- World Bank Development Data Collector
- WHOIS Domain Lookup Tool

***

### ⚖️ Google Patents Excellence

This Actor is optimized for **Google Patents** research with:

- ✅ Assignee-level patent discovery
- ✅ Direct Google Patents endpoint integration
- ✅ XSSI-safe, nested JSON parsing
- ✅ Configurable result volume
- ✅ Real-time Dataset push
- ✅ Production-ready code

# Actor input Schema

## `keyword` (type: `string`):

Enter company name or assignee keyword (e.g. Google, Tesla, Apple).

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

Maximum patent records to fetch.

## `useApifyProxy` (type: `boolean`):

Recommended to ensure smooth connections and avoid Google IP rate-limiting.

## `apifyProxyGroups` (type: `array`):

Select proxy networks (RESIDENTIAL is recommended).

## Actor input object example

```json
{
  "keyword": "Tesla",
  "max_results": 50,
  "useApifyProxy": true,
  "apifyProxyGroups": [
    "RESIDENTIAL"
  ]
}
```

# 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 = {
    "keyword": "Tesla"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/google-patents-owner-assignee-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 = { "keyword": "Tesla" }

# Run the Actor and wait for it to finish
run = client.actor("datapilot/google-patents-owner-assignee-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 '{
  "keyword": "Tesla"
}' |
apify call datapilot/google-patents-owner-assignee-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datapilot/google-patents-owner-assignee-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/1PJWeGpOcK2xPM3KQ/builds/kfzwhli4khEbaxrf1/openapi.json