# Google Patents API (`johnvc/google-patents-api`) Actor

Google Patents API for Claude, Cursor, ChatGPT, and any MCP-compatible AI agent. Search by keyword, inventor, or assignee across USPTO, EPO, WIPO, JPO, CN, KR + 100 offices. Pull claims, citations, family graphs, CPC. AI patent summaries. Pay per event.

- **URL**: https://apify.com/johnvc/google-patents-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, Integrations, MCP servers
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.01 / 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.

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

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

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

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

### Use it from your AI agent

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

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

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

This actor is built for professional patent work:

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

### Quick start

#### Run as an MCP tool (Claude, Cursor, ChatGPT)

Connect your AI agent to Apify's MCP server, then call this actor by its full name:

````

johnvc/google-patents-api

````

The actor's input schema is fully described with `title` and `description` fields on every parameter, so your agent can pick the right inputs on its own.

#### Run from the Apify console

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

#### Run via the Apify API

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

### Input parameters

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

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

### Output

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

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

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

### Pricing

Pay per event:

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

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

### Scheduled monitoring

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

### Support

Issues or feature requests: open a ticket on the [Apify actor page](https://apify.com/johnvc/google-patents-api) or message the maintainer through the Apify console.

***

Last Updated: 2026.05.19

# Actor input Schema

## `q` (type: `string`):

Free-text search query (e.g., 'graphene battery', 'CRISPR gene editing'). At least one of: q, patent\_id, assignee, or inventor is required.

## `patent_id` (type: `string`):

Provide to fetch full details for a specific patent instead of running a search. Format: 'patent/\<publication\_number>/<lang>' (e.g., 'patent/US11734097B1/en') or 'patent/\<publication\_number>'.

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

Comma-separated assignee (company) names to filter results by (e.g., 'Apple,Microsoft'). Use alone or alongside q.

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

Comma-separated inventor names to filter results by (e.g., 'John Smith,Jane Doe'). Use alone or alongside q.

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

Comma-separated patent office codes. Common: US (USPTO), EP (EPO), WO (WIPO), JP (JPO), KR (KIPO), CN (CNIPA), DE, GB, FR, CA, AU, IN. Example: 'US,EP,WO'.

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

Comma-separated languages. Use full names (ENGLISH, GERMAN, CHINESE, FRENCH, SPANISH, ARABIC, JAPANESE, KOREAN, PORTUGUESE, RUSSIAN, ITALIAN, DUTCH, SWEDISH, FINNISH, NORWEGIAN, DANISH) or 2-letter codes (EN, DE, ZH, ...) which we translate automatically. Example: 'ENGLISH,GERMAN' or 'EN,DE'.

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

Filter by patent status.

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

Filter by patent type.

## `before` (type: `string`):

Upper-bound date filter. Format 'type:YYYYMMDD' where type is one of priority, filing, publication. Example: 'publication:20251231'.

## `after` (type: `string`):

Lower-bound date filter. Format 'type:YYYYMMDD' where type is one of priority, filing, publication. Example: 'filing:20200101'.

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

Sort search results by relevance (default), newest first, or oldest first.

## `litigation` (type: `string`):

Return only patents that have been litigated (YES) or only those that have not (NO).

## `num` (type: `integer`):

Results returned per page, 10 to 100. Default 10.

## `max_pages` (type: `integer`):

Maximum number of pages to fetch. Set to 0 for unlimited. Each page is one charged event.

## `clustered` (type: `boolean`):

Group results by classification when true.

## `dups` (type: `boolean`):

Collapse near-duplicate publications across languages so each unique invention shows once.

## `scholar` (type: `boolean`):

Also include matching Google Scholar (academic paper) results alongside patents. Useful for prior-art workflows that consider non-patent literature.

## `no_cache` (type: `boolean`):

Force a fresh fetch instead of returning cached results. Recommended for scheduled monitoring runs that need to detect newly published filings.

## `include_ai_summary` (type: `boolean`):

Attach the AI-generated summary block (top assignees, inventors, CPC classes with percentages and year-range frequencies) to the first page item. Returned free with every search response. Default ON. No competitor offers this.

## `include_details` (type: `boolean`):

After paginating, fetch full details (claims, citations, family, CPC, PDF URL) for each patent up to a hard cap of 10. Each details lookup is one additional charged event.

## Actor input object example

```json
{
  "q": "semiconductor cooling",
  "num": 10,
  "max_pages": 1,
  "clustered": false,
  "dups": false,
  "scholar": false,
  "no_cache": false,
  "include_ai_summary": true,
  "include_details": false
}
```

# Actor output Schema

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

Full results from all pages and details lookups. Each dataset item contains search\_parameters, search\_metadata, page\_number, and either a patents array, a details object, or both. When include\_ai\_summary is true, an ai\_summary block is attached to the first page item.

# 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 = {
    "q": "semiconductor cooling"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-patents-api").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 = { "q": "semiconductor cooling" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/google-patents-api").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 '{
  "q": "semiconductor cooling"
}' |
apify call johnvc/google-patents-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Patents API",
        "description": "Google Patents API for Claude, Cursor, ChatGPT, and any MCP-compatible AI agent. Search by keyword, inventor, or assignee across USPTO, EPO, WIPO, JPO, CN, KR + 100 offices. Pull claims, citations, family graphs, CPC. AI patent summaries. Pay per event.",
        "version": "0.0",
        "x-build-id": "xOpPEMoh2yQh0LA26"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~google-patents-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-google-patents-api",
                "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/johnvc~google-patents-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-google-patents-api",
                "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/johnvc~google-patents-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-google-patents-api",
                "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": {
                    "q": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text search query (e.g., 'graphene battery', 'CRISPR gene editing'). At least one of: q, patent_id, assignee, or inventor is required."
                    },
                    "patent_id": {
                        "title": "Patent ID (details mode)",
                        "type": "string",
                        "description": "Provide to fetch full details for a specific patent instead of running a search. Format: 'patent/<publication_number>/<lang>' (e.g., 'patent/US11734097B1/en') or 'patent/<publication_number>'."
                    },
                    "assignee": {
                        "title": "Assignee Filter",
                        "type": "string",
                        "description": "Comma-separated assignee (company) names to filter results by (e.g., 'Apple,Microsoft'). Use alone or alongside q."
                    },
                    "inventor": {
                        "title": "Inventor Filter",
                        "type": "string",
                        "description": "Comma-separated inventor names to filter results by (e.g., 'John Smith,Jane Doe'). Use alone or alongside q."
                    },
                    "country": {
                        "title": "Country / Patent Office",
                        "type": "string",
                        "description": "Comma-separated patent office codes. Common: US (USPTO), EP (EPO), WO (WIPO), JP (JPO), KR (KIPO), CN (CNIPA), DE, GB, FR, CA, AU, IN. Example: 'US,EP,WO'."
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Comma-separated languages. Use full names (ENGLISH, GERMAN, CHINESE, FRENCH, SPANISH, ARABIC, JAPANESE, KOREAN, PORTUGUESE, RUSSIAN, ITALIAN, DUTCH, SWEDISH, FINNISH, NORWEGIAN, DANISH) or 2-letter codes (EN, DE, ZH, ...) which we translate automatically. Example: 'ENGLISH,GERMAN' or 'EN,DE'."
                    },
                    "status": {
                        "title": "Patent Status",
                        "enum": [
                            "GRANT",
                            "APPLICATION"
                        ],
                        "type": "string",
                        "description": "Filter by patent status."
                    },
                    "type": {
                        "title": "Patent Type",
                        "enum": [
                            "PATENT",
                            "DESIGN"
                        ],
                        "type": "string",
                        "description": "Filter by patent type."
                    },
                    "before": {
                        "title": "Latest Date Filter",
                        "type": "string",
                        "description": "Upper-bound date filter. Format 'type:YYYYMMDD' where type is one of priority, filing, publication. Example: 'publication:20251231'."
                    },
                    "after": {
                        "title": "Earliest Date Filter",
                        "type": "string",
                        "description": "Lower-bound date filter. Format 'type:YYYYMMDD' where type is one of priority, filing, publication. Example: 'filing:20200101'."
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "relevance",
                            "new",
                            "old"
                        ],
                        "type": "string",
                        "description": "Sort search results by relevance (default), newest first, or oldest first."
                    },
                    "litigation": {
                        "title": "Litigation Filter",
                        "enum": [
                            "YES",
                            "NO"
                        ],
                        "type": "string",
                        "description": "Return only patents that have been litigated (YES) or only those that have not (NO)."
                    },
                    "num": {
                        "title": "Results per Page",
                        "minimum": 10,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Results returned per page, 10 to 100. Default 10.",
                        "default": 10
                    },
                    "max_pages": {
                        "title": "Maximum Pages",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of pages to fetch. Set to 0 for unlimited. Each page is one charged event.",
                        "default": 1
                    },
                    "clustered": {
                        "title": "Cluster by Classification",
                        "type": "boolean",
                        "description": "Group results by classification when true.",
                        "default": false
                    },
                    "dups": {
                        "title": "Deduplicate by Publication",
                        "type": "boolean",
                        "description": "Collapse near-duplicate publications across languages so each unique invention shows once.",
                        "default": false
                    },
                    "scholar": {
                        "title": "Include Google Scholar Results",
                        "type": "boolean",
                        "description": "Also include matching Google Scholar (academic paper) results alongside patents. Useful for prior-art workflows that consider non-patent literature.",
                        "default": false
                    },
                    "no_cache": {
                        "title": "Bypass Cache",
                        "type": "boolean",
                        "description": "Force a fresh fetch instead of returning cached results. Recommended for scheduled monitoring runs that need to detect newly published filings.",
                        "default": false
                    },
                    "include_ai_summary": {
                        "title": "Include AI Summary",
                        "type": "boolean",
                        "description": "Attach the AI-generated summary block (top assignees, inventors, CPC classes with percentages and year-range frequencies) to the first page item. Returned free with every search response. Default ON. No competitor offers this.",
                        "default": true
                    },
                    "include_details": {
                        "title": "Include Full Details for Each Result",
                        "type": "boolean",
                        "description": "After paginating, fetch full details (claims, citations, family, CPC, PDF URL) for each patent up to a hard cap of 10. Each details lookup is one additional charged event.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
