# India IPO Patents Scraper | Indian Patent Office Search (`parseforge/india-ipo-patents-scraper`) Actor

Search Indian patents from the IPO 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 pharma, IT and biotech IP research at scale in India.

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

## 🇮🇳 India IPO Patents Scraper

> 🚀 **Export Indian patent records in seconds.** Search the Indian Patent Office by keyword, applicant, inventor, and date. Download as CSV, Excel, JSON, or XML.

> 🕒 **Last updated:** 2026-05-26 · **📊 15 fields** per record · **Hundreds of thousands of IN patents** · **IPO coverage 1972-present**

The India IPO Patents Scraper pulls Indian patent records from the public bibliographic data of the Indian Patent Office (IPO), accessed via the Google Patents index which mirrors InPASS publications.

India is one of the fastest-growing patent jurisdictions, with millions of filings in pharma, IT, biotech, and traditional knowledge areas. This scraper covers granted patents and published applications with full bibliographic data.

**Target Audience / Use Cases**

| Who | Why |
|---|---|
| Indian and international IP attorneys | Prior art search in India |
| Pharma and biotech companies | Track patent filings in a major pharma market |
| IT/software firms | Monitor patent activity in Indian tech hubs |
| Investors | Map Indian patent portfolios for due diligence |
| Researchers | Study Indian innovation trends |
| Journalists | Cover IP and innovation in India |

---

### 📋 What the India IPO Patents Scraper does

- Searches Indian patent bibliographic data
- Paginates automatically up to maxItems
- Returns 15 fields per record
- Exports to CSV, Excel, JSON, or XML
- Filters by date range and grant/application status
- Direct source links for every record

> 💡 **Why it matters:** India is one of the worlds top-10 patent offices and a major hub for pharma, IT, and biotech innovation. Programmatic access to IPO data enables scaled patent intelligence.

---

### 🎬 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>ayurveda</td><td>Free-text query</td></tr>
<tr><td>country</td><td>select</td><td>IN</td><td>Set to IN for Indian patents</td></tr>
<tr><td>assignee</td><td>string</td><td></td><td>Filter by applicant</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</td></tr>
<tr><td>dateTo</td><td>string</td><td></td><td>To date</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 - Indian pharma patents:**
```json
{
    "maxItems": 100,
    "query": "metformin",
    "country": "IN"
}
````

**Example 2 - Find Tata Consultancy patents:**

```json
{
    "maxItems": 50,
    "country": "IN",
    "assignee": "Tata Consultancy Services",
    "dateFrom": "2022-01-01"
}
```

> ⚠️ **Good to Know:** Country is locked to IN. Use Google Patents Scraper for worldwide coverage.

***

### 📊 Output

Each record contains up to 15 fields:

| Field | Type | Description |
|---|---|---|
| 🔢 `publicationNumber` | string | Indian publication number |
| 📋 `title` | string | 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 | IN |
| 📄 `pdfUrl` | string | PDF link |
| 🖼️ `thumbnailUrl` | string | Thumbnail |
| 🔗 `sourceUrl` | string | Source URL |
| 🕒 `scrapedAt` | string | Timestamp |

**Sample record:**

```json
{
  "publicationNumber": "IN202311000123A",
  "title": "Ayurvedic composition for diabetes",
  "assignee": "Cipla Limited",
  "countryCode": "IN",
  "sourceUrl": "https://patents.google.com/patent/IN202311000123A/en",
  "scrapedAt": "2026-05-26T12:00:00.000Z"
}
```

***

### ✨ Why choose this Actor

- 🇮🇳 **India-focused** - locked to IN
- 🔄 **Real-time**
- 🔍 **6 filter modes**
- 📑 **15 fields**
- 📦 **Batch export**
- 💰 **Pay-per-result**

***

### 📈 How it compares to alternatives

| Feature | This Actor | InPASS Search | Indian Patent Database |
|---|---|---|---|
| Search by keyword | Yes | Yes | Yes |
| Bulk export | Yes | No | Limited |
| Pagination | Automatic | Manual | Manual |
| 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 **India IPO Patents Scraper** actor page and click **Try for free**
3. Enter your query, applicant, 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

#### Pharma Patent Tracking

India is a major generic pharma market. Track patent filings and expirations to plan generic launches and life-cycle management.

#### Traditional Knowledge IP

Search ayurveda, yoga, and traditional knowledge patents to study how India protects and commercializes traditional IP.

#### IT and Software Patents

Monitor Indian software patent activity in Bangalore, Pune, and Hyderabad tech corridors.

#### M\&A Due Diligence

Map an Indian targets patent portfolio in minutes.

***

### 🔌 Automating India IPO 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 Indian inventors can research existing patents before filing.

#### Journalism and Investigations

Journalists covering Indian innovation can quantify activity by sector or company.

#### Non-Profit and Policy Research

Policy researchers studying TRIPS compliance and Indian IP policy can build longitudinal datasets.

#### Education

Indian law schools use IPO data in IP courses.

***

### 🤖 Ask an AI assistant about this scraper

You can ask your AI assistant questions like:

- "How do I search Indian patents?"
- "What is InPASS?"
- "How do I find patents by an Indian pharma company?"
- "How is the Indian Patent Office organized?"

The answers will reference this actor and the Indian Patent Office bibliographic data.

***

### ❓ Frequently Asked Questions

**What is InPASS?**
The Indian Patent Office public search system at iprsearch.ipindia.gov.in.

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

**Can I search non-English Indian filings?**
Most filings are in English. Some Hindi filings are also indexed.

**Does this require an account?**
No.

**Can I filter by application status?**
Yes. status=GRANT, APPLICATION, or empty.

**Are pre-grant oppositions visible?**
No. Only bibliographic data is in the index.

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

**Can I export to CSV?**
Yes.

**Can I run on a schedule?**
Yes.

**What if my company filed under a slightly different name?**
Try multiple variations - applicant names are matched as substrings.

**Are PCT-derived Indian patents included?**
Yes. PCT national-phase entries in India appear with IN publication numbers.

***

### 🔌 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 |
| [China CNIPA Patents Scraper](https://apify.com/parseforge/china-cnipa-patents-scraper) | Chinese patent search |
| [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 Indian patent data. ParseForge is not affiliated with the Indian Patent 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": "ayurveda",
  "country": "IN",
  "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": "ayurveda",
    "country": "IN",
    "sort": "new"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/india-ipo-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": "ayurveda",
    "country": "IN",
    "sort": "new",
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "India IPO Patents Scraper | Indian Patent Office Search",
        "description": "Search Indian patents from the IPO 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 pharma, IT and biotech IP research at scale in India.",
        "version": "0.1",
        "x-build-id": "gkgOuafGzwCaTToxF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~india-ipo-patents-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-india-ipo-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~india-ipo-patents-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-india-ipo-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~india-ipo-patents-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-india-ipo-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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
