# Canada CIPO Patents Scraper | Canadian Patent Search (`parseforge/canada-cipo-patents-scraper`) Actor

Search Canadian patents from the CIPO bibliographic index by keyword, applicant, inventor, status and date. Export title, abstract, priority date, filing date, grant date and PDF links to CSV, Excel, JSON or XML for IP research, FTO and competitive analysis in Canada.

- **URL**: https://apify.com/parseforge/canada-cipo-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)

## 🇨🇦 Canada CIPO Patents Scraper

> 🚀 **Search and export Canadian patents from CIPO in seconds.** Filter by keyword, applicant, inventor, status and date. Download to CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-26 · **📊 15 fields** per record · **Millions of CA patents** · **CIPO coverage 1869-present**

The Canada CIPO Patents Scraper pulls Canadian patent records from the public Canadian Intellectual Property Office (CIPO) bibliographic data, accessed via the Google Patents index that mirrors CIPO publications.

CIPO has issued more than 3 million patents since Confederation. This scraper covers granted patents and published applications with full bibliographic data and direct links to CIPOs source documents.

**Target Audience / Use Cases**

| Who | Why |
|---|---|
| Canadian IP attorneys | Prior art and freedom-to-operate searches in Canada |
| Resource sector R&D | Track innovation in oil & gas, mining, and clean tech |
| Competitive intelligence | Monitor Canadian filings by competitors |
| Investors | Map Canadian patent portfolios |
| Academic researchers | Quantitative analysis of Canadian innovation |
| Journalists | Cover IP and innovation in Canadian industries |

---

### 📋 What the Canada CIPO Patents Scraper does

- Searches CIPO bibliographic data by query, assignee, inventor, status, date
- Paginates automatically until maxItems is reached
- Returns 15 structured fields per Canadian patent record
- Exports to CSV, Excel, JSON, or XML
- Filters by priority date range and grant/application status
- Direct CIPO source links for every record

> 💡 **Why it matters:** Canada is a top-10 patent office and a major innovation hub in clean tech, biotech, AI, and resource sectors. Programmatic access to CIPO data lets you build Canadian patent landscapes at scale.

---

### 🎬 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</td></tr>
<tr><td>query</td><td>string</td><td>oil sands</td><td>Free-text query</td></tr>
<tr><td>country</td><td>select</td><td>CA</td><td>Set to CA for Canadian patents</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>From date (YYYY-MM-DD)</td></tr>
<tr><td>dateTo</td><td>string</td><td></td><td>To date (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 - Canadian clean tech patents:**
```json
{
    "maxItems": 100,
    "query": "carbon capture",
    "country": "CA"
}
````

**Example 2 - Find patents by a Canadian university:**

```json
{
    "maxItems": 50,
    "country": "CA",
    "assignee": "University of Toronto",
    "dateFrom": "2020-01-01"
}
```

> ⚠️ **Good to Know:** The country filter is locked to CA for this scraper. Use Google Patents Scraper for worldwide coverage.

***

### 📊 Output

Each record contains up to 15 fields:

| Field | Type | Description |
|---|---|---|
| 🔢 `publicationNumber` | string | CIPO publication number (e.g. CA3100000A1) |
| 📋 `title` | string | Patent title |
| 📝 `snippet` | string | Abstract snippet |
| 🏢 `assignee` | string | Applicant |
| 🧑‍🔬 `inventor` | string | Inventor |
| 📅 `priorityDate` | string | Priority date |
| 📅 `filingDate` | string | Filing date |
| 📅 `publicationDate` | string | Publication date |
| 📅 `grantDate` | string | Grant date |
| 🌐 `language` | string | Language |
| 🇨🇦 `countryCode` | string | CA |
| 📄 `pdfUrl` | string | PDF link |
| 🖼️ `thumbnailUrl` | string | Thumbnail |
| 🔗 `sourceUrl` | string | Source URL |
| 🕒 `scrapedAt` | string | Timestamp |

**Sample record:**

```json
{
  "publicationNumber": "CA3150000A1",
  "title": "Method and system for oil sands extraction",
  "assignee": "Suncor Energy Inc.",
  "countryCode": "CA",
  "sourceUrl": "https://patents.google.com/patent/CA3150000A1/en",
  "scrapedAt": "2026-05-26T12:00:00.000Z"
}
```

***

### ✨ Why choose this Actor

- 🇨🇦 **Canadian-focused** - country filter locked to CA
- 🔄 **Real-time** scraping
- 🔍 **6 filter modes**
- 📑 **15 fields per record**
- 📦 **Batch export**
- 💰 **Pay-per-result**

***

### 📈 How it compares to alternatives

| Feature | This Actor | CIPO Patents Database | PatentScope (WIPO) |
|---|---|---|---|
| Bulk export | Yes | No | Yes |
| Filter by assignee | Yes | Yes | Yes |
| Pagination | Automatic | Manual | API key |
| No login required | Yes | Yes | Yes |
| Pay-per-result | Yes | Free | Free |

***

### 🚀 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 **Canada CIPO Patents Scraper** actor page and click **Try for free**
3. Enter your query, assignee, or inventor name
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

#### Resource Sector Innovation Tracking

Canada is a global leader in oil sands, mining, and forestry patents. Filter by keyword to monitor innovation in these sectors.

#### Clean Tech Patent Landscapes

Build maps of Canadian patent activity in solar, wind, hydrogen, carbon capture, and battery technology.

#### University Tech Transfer

Track patent filings from Canadian universities like Toronto, McGill, UBC, and Waterloo to spot licensing opportunities.

#### Competitive Monitoring

Monitor a Canadian competitors filings to spot new product lines or R\&D directions before they hit market.

***

### 🔌 Automating Canada CIPO 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 existing Canadian patents in their field before filing.

#### Journalism and Investigations

Journalists covering Canadian innovation can quantify R\&D activity by company or sector.

#### Non-Profit and Policy Research

Policy researchers can study Canadian innovation policy outcomes longitudinally.

#### Education

Canadian law schools use CIPO data in IP law courses.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your AI assistant questions like:

- "How do I search Canadian patents?"
- "What is CIPO?"
- "How do I find patents from a Canadian university?"
- "What is the difference between CIPO and USPTO?"

The answers will reference this actor and the CIPO patent index.

***

### ❓ Frequently Asked Questions

**What is CIPO?**
The Canadian Intellectual Property Office, the federal agency that grants patents in Canada.

**How current is the data?**
Patents typically appear in the index within days of publication by CIPO.

**Can I search by inventor?**
Yes. Use the inventor field.

**Are patent applications included?**
Yes. Use status=APPLICATION to filter to pending applications.

**Does this require a CIPO account?**
No. All data is public.

**Can I filter by date range?**
Yes. dateFrom and dateTo use YYYY-MM-DD.

**Are the patent claims included?**
No. Use the sourceUrl to access full text.

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

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

**Can I monitor a competitor automatically?**
Yes. Use Apify scheduler.

**What if a search returns no results?**
Try broader keywords or check the assignee/inventor spelling.

***

### 🔌 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 |
|---|---|
| [Google Patents Scraper](https://apify.com/parseforge/google-patents-scraper) | Worldwide patent search |
| [USPTO Patent Assignments Scraper](https://apify.com/parseforge/uspto-patent-assignments-scraper) | US patent ownership records |
| [USPTO PAIR Scraper](https://apify.com/parseforge/uspto-pair-scraper) | US 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 Canadian patent data. ParseForge is not affiliated with the Canadian Intellectual Property Office. Users are responsible for compliance with applicable laws.

# 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": "oil sands",
  "country": "CA",
  "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": "oil sands",
    "country": "CA",
    "sort": "new"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/canada-cipo-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": "oil sands",
    "country": "CA",
    "sort": "new",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/canada-cipo-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": "oil sands",
  "country": "CA",
  "sort": "new"
}' |
apify call parseforge/canada-cipo-patents-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Canada CIPO Patents Scraper | Canadian Patent Search",
        "description": "Search Canadian patents from the CIPO bibliographic index by keyword, applicant, inventor, status and date. Export title, abstract, priority date, filing date, grant date and PDF links to CSV, Excel, JSON or XML for IP research, FTO and competitive analysis in Canada.",
        "version": "0.1",
        "x-build-id": "G0PukPWTaCDIH1ew9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~canada-cipo-patents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-canada-cipo-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~canada-cipo-patents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-canada-cipo-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~canada-cipo-patents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-canada-cipo-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
