# Google Patents Scraper | Worldwide Patent Database (`parseforge/google-patents-scraper`) Actor

Search 120M+ patents worldwide from Google Patents covering USPTO, EPO, WIPO, CNIPA, JPO and more. Filter by country, assignee, inventor, status, date and language. Export title, abstract, dates and PDF links to CSV, Excel, JSON or XML for IP research at scale.

- **URL**: https://apify.com/parseforge/google-patents-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🌍 Google Patents Scraper

> 🚀 **Search 120+ million worldwide patents in seconds.** Filter by country, assignee, inventor, date and status across USPTO, EPO, WIPO, JPO, CNIPA and more. Export to CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-26 · **📊 15 fields** per record · **120M+ patents worldwide** · **100+ patent offices**

The Google Patents Scraper pulls patent records from the public Google Patents search index, which aggregates more than 120 million patent documents from 100+ patent offices including the USPTO, EPO, JPO, CNIPA, KIPO, CIPO, IPO India and many more.

Coverage spans granted patents and published applications from the late 19th century to the most recent publications, in dozens of languages with automatic English translation. The scraper supports the full Google Patents query syntax.

**Target Audience / Use Cases**

| Who | Why |
|---|---|
| IP professionals | Worldwide prior-art and freedom-to-operate searches |
| Competitive intelligence | Track filings across all major jurisdictions |
| R&D teams | Identify global technology trends |
| M&A analysts | Map global patent portfolios |
| Academic researchers | Cross-jurisdiction patent landscape studies |
| Journalists | Investigate corporate IP strategies globally |

---

### 📋 What the Google Patents Scraper does

- Searches Google Patents by keyword, country, assignee, inventor, status, and date range
- Paginates automatically up to maxItems
- Returns 15 structured fields per record
- Exports to CSV, Excel, JSON, or XML
- Supports 30+ country codes including US, EP, WO, CN, JP, KR, etc.

> 💡 **Why it matters:** Google Patents is the single most comprehensive free patent search index available. Programmatic access lets you build worldwide patent landscapes without juggling 10+ different national APIs.

---

### 🎬 Full Demo

_🚧 Coming soon_

---

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Default</th><th>Description</th></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Maximum records. Free users capped at 10.</td></tr>
<tr><td>query</td><td>string</td><td>machine learning</td><td>Free-text search query</td></tr>
<tr><td>country</td><td>select</td><td></td><td>ISO country code or empty for worldwide</td></tr>
<tr><td>assignee</td><td>string</td><td></td><td>Filter by assignee</td></tr>
<tr><td>inventor</td><td>string</td><td></td><td>Filter by inventor</td></tr>
<tr><td>status</td><td>select</td><td></td><td>GRANT/APPLICATION/both</td></tr>
<tr><td>dateFrom</td><td>string</td><td></td><td>Priority date from (YYYY-MM-DD)</td></tr>
<tr><td>dateTo</td><td>string</td><td></td><td>Priority date to (YYYY-MM-DD)</td></tr>
<tr><td>language</td><td>select</td><td></td><td>Language filter</td></tr>
<tr><td>sort</td><td>select</td><td>new</td><td>Sort order</td></tr>
</table>

**Example 1 - Worldwide AI search:**
```json
{
    "maxItems": 100,
    "query": "transformer neural network",
    "sort": "new"
}
````

**Example 2 - Find EPO filings from a specific company:**

```json
{
    "maxItems": 50,
    "country": "EP",
    "assignee": "Siemens AG",
    "dateFrom": "2022-01-01"
}
```

> ⚠️ **Good to Know:** Leave country empty to search worldwide. Use ISO codes like US, EP, WO, CN, JP, KR, GB, DE for specific offices.

***

### 📊 Output

Each record contains up to 15 fields:

| Field | Type | Description |
|---|---|---|
| 🔢 `publicationNumber` | string | Publication number |
| 📋 `title` | string | Title |
| 📝 `snippet` | string | Abstract snippet |
| 🏢 `assignee` | string | Assignee |
| 🧑‍🔬 `inventor` | string | Inventor |
| 📅 `priorityDate` | string | Priority date |
| 📅 `filingDate` | string | Filing date |
| 📅 `publicationDate` | string | Publication date |
| 📅 `grantDate` | string | Grant date if granted |
| 🌐 `language` | string | Language |
| 🇺🇳 `countryCode` | string | Country code |
| 📄 `pdfUrl` | string | PDF link |
| 🖼️ `thumbnailUrl` | string | Thumbnail |
| 🔗 `sourceUrl` | string | Google Patents URL |
| 🕒 `scrapedAt` | string | Collected timestamp |

**Sample record:**

```json
{
  "publicationNumber": "WO2024123456A1",
  "title": "System and method for training large language models",
  "assignee": "OpenAI Inc.",
  "inventor": "John Smith",
  "priorityDate": "2023-06-15",
  "publicationDate": "2024-06-20",
  "countryCode": "WO",
  "sourceUrl": "https://patents.google.com/patent/WO2024123456A1/en",
  "scrapedAt": "2026-05-26T12:00:00.000Z"
}
```

***

### ✨ Why choose this Actor

- 🌍 **Worldwide coverage** - 100+ patent offices in one search
- 🔄 **Real-time** scraping from Google Patents
- 🔍 **8 filter modes** - country, query, assignee, inventor, dates, status, language
- 📑 **15 fields per record**
- 📦 **Batch export**
- 💰 **Pay-per-result** pricing

***

### 📈 How it compares to alternatives

| Feature | This Actor | Google Patents UI | EPO Espacenet |
|---|---|---|---|
| Worldwide coverage | Yes | Yes | EU + select offices |
| Bulk export | Yes | Manual | API key required |
| Pagination | Automatic | Manual | API quota |
| Filter by country | Yes | Yes | Limited |
| No login required | Yes | Yes | Limited |

***

### 🚀 How to use

1. **Create a free account** at [Apify](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 free credit)
2. Open the **Google Patents Scraper** actor page and click **Try for free**
3. Enter your search query, country, and optional filters
4. Optionally set **maxItems** and other filters
5. Click **Start** and wait for the run to finish
6. Download your dataset as **CSV, Excel, JSON, or XML**

***

### 💼 Business use cases

#### Worldwide Patent Landscapes

Map patent activity across all major jurisdictions in a single query - quantify filings by country, assignee, or technology area.

#### Cross-Border Competitive Monitoring

Track a competitors filings in all jurisdictions at once. Schedule the actor weekly with the competitors name as the assignee filter.

#### PCT and EPO Tracking

Filter by country=WO for PCT applications or country=EP for European patents to monitor international filings.

#### Technology Trend Research

Combine keyword and date filters to build longitudinal datasets showing how interest in a technology has evolved across regions.

***

### 🔌 Automating Google Patents Scraper

Connect this actor to your workflow with no-code tools:

- **Make (Integromat)** - send new records to Google Sheets, Airtable, or Slack
- **Zapier** - automate alerts when new records are found
- **n8n** - build pipelines that run on a schedule and push to your warehouse
- **Webhooks** - get notified when a run completes via Apify webhooks

***

### 🌟 Beyond business use cases

#### Independent Researchers

Independent inventors can research what already exists worldwide before filing their own applications.

#### Journalism and Investigations

Journalists covering global technology can quantify innovation activity across countries and industries.

#### Non-Profit and Policy Research

Policy researchers studying global innovation can build comparative datasets across patent offices.

#### Education

University IP courses use Google Patents data to teach worldwide patent search techniques.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your AI assistant questions like:

- "How do I search for patents worldwide?"
- "What country codes does Google Patents support?"
- "How do I find all patents from a specific company globally?"
- "Can I filter by patent status across jurisdictions?"

The answers will reference this actor and the Google Patents index.

***

### ❓ Frequently Asked Questions

**What sources does Google Patents cover?**
100+ patent offices including USPTO, EPO, WIPO/PCT, JPO, CNIPA, KIPO, CIPO, IPO India, IP Australia, and many national offices.

**How recent is the data?**
Patents typically appear within days of publication.

**Can I search non-English patents?**
Yes. Google Patents auto-translates Chinese, Japanese, Korean, German, French, and many other languages.

**How do I find PCT (WIPO) applications?**
Set country to WO.

**How do I find European patents?**
Set country to EP for EPO patents.

**What is the difference between application and grant?**
Applications are pending. Grants are issued patents. Use the status filter.

**Can I run this on a schedule?**
Yes, via Apifys built-in scheduler.

**How many records per run?**
Free users: 10. Paid: up to 1,000,000.

**Can I export to CSV?**
Yes. CSV, Excel, JSON, and XML are all supported.

**Are family-related patents linked?**
Each record is a single publication. Family relationships are not exported in this version.

**Does it include patent claims?**
No. Claims are not in the search index. Use the sourceUrl to view full text on Google Patents.

***

### 🔌 Integrate with any app

Connect your dataset to 1,500+ apps via Apify integrations:

**Analytics:** Google Sheets, Airtable, Microsoft Excel, Tableau, Power BI
**Databases:** PostgreSQL, MySQL, MongoDB, BigQuery, Snowflake
**Communication:** Slack, Microsoft Teams, email notifications
**Storage:** Google Drive, Dropbox, Amazon S3, Azure Blob
**Automation:** Make, Zapier, n8n, Pipedream

***

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [USPTO Patent Assignments Scraper](https://apify.com/parseforge/uspto-patent-assignments-scraper) | Patent ownership and chain-of-title |
| [USPTO PAIR Scraper](https://apify.com/parseforge/uspto-pair-scraper) | US-only patent search |
| [Canada CIPO Patents Scraper](https://apify.com/parseforge/canada-cipo-patents-scraper) | Canadian patent search |

> 💡 **Pro Tip:** Browse the complete [ParseForge collection](https://apify.com/parseforge) for more government data, business intelligence, and research scrapers.

***

**Disclaimer:** This tool accesses publicly available patent data via Google Patents. ParseForge is not affiliated with Google or any patent office. Users are responsible for compliance with applicable laws and terms of use.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: 10. Paid: up to 1,000,000

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

Free-text keywords (e.g. "solar panel"). Use double quotes for exact phrases.

## `country` (type: `string`):

ISO country code (e.g. US, CA, IN, CN, JP, EP, WO). Leave empty for worldwide.

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

Filter by patent assignee (company or person)

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

Filter by inventor name

## `status` (type: `string`):

GRANT, APPLICATION, or empty for both

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

YYYY-MM-DD format

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

YYYY-MM-DD format

## `language` (type: `string`):

Filter by language code

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

Sort by publication date

## Actor input object example

```json
{
  "maxItems": 10,
  "query": "machine learning",
  "sort": "new"
}
```

# Actor output Schema

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

Scraped records

# 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 = {
    "maxItems": 10,
    "query": "machine learning",
    "country": "",
    "sort": "new"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/google-patents-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 = {
    "maxItems": 10,
    "query": "machine learning",
    "country": "",
    "sort": "new",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/google-patents-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 '{
  "maxItems": 10,
  "query": "machine learning",
  "country": "",
  "sort": "new"
}' |
apify call parseforge/google-patents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Patents Scraper | Worldwide Patent Database",
        "description": "Search 120M+ patents worldwide from Google Patents covering USPTO, EPO, WIPO, CNIPA, JPO and more. Filter by country, assignee, inventor, status, date and language. Export title, abstract, dates and PDF links to CSV, Excel, JSON or XML for IP research at scale.",
        "version": "0.1",
        "x-build-id": "Bf2HedimGDaVdNdjH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~google-patents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-google-patents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~google-patents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-google-patents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~google-patents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-google-patents-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: 10. Paid: up to 1,000,000"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text keywords (e.g. \"solar panel\"). Use double quotes for exact phrases."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "",
                            "US",
                            "CA",
                            "IN",
                            "CN",
                            "JP",
                            "KR",
                            "GB",
                            "DE",
                            "FR",
                            "EP",
                            "WO",
                            "AU",
                            "BR",
                            "RU",
                            "ES",
                            "IT",
                            "NL",
                            "MX",
                            "AR",
                            "ZA",
                            "CH",
                            "SE",
                            "NO",
                            "FI",
                            "DK",
                            "BE",
                            "AT",
                            "SG",
                            "TW",
                            "HK",
                            "IL",
                            "TR",
                            "PL",
                            "PT",
                            "GR",
                            "IE"
                        ],
                        "type": "string",
                        "description": "ISO country code (e.g. US, CA, IN, CN, JP, EP, WO). Leave empty for worldwide."
                    },
                    "assignee": {
                        "title": "Assignee",
                        "type": "string",
                        "description": "Filter by patent assignee (company or person)"
                    },
                    "inventor": {
                        "title": "Inventor",
                        "type": "string",
                        "description": "Filter by inventor name"
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "",
                            "GRANT",
                            "APPLICATION"
                        ],
                        "type": "string",
                        "description": "GRANT, APPLICATION, or empty for both"
                    },
                    "dateFrom": {
                        "title": "Priority Date From",
                        "type": "string",
                        "description": "YYYY-MM-DD format"
                    },
                    "dateTo": {
                        "title": "Priority Date To",
                        "type": "string",
                        "description": "YYYY-MM-DD format"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "",
                            "en",
                            "de",
                            "fr",
                            "zh",
                            "ja",
                            "ko",
                            "es",
                            "ru"
                        ],
                        "type": "string",
                        "description": "Filter by language code"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "new",
                            "old",
                            ""
                        ],
                        "type": "string",
                        "description": "Sort by publication date"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
