# India OGD Company Registry Scraper (`automation-lab/india-ogd-company-registry-scraper`) Actor

Scrape official India OGD/MCA company master data by CIN, company name, state, or RoC for KYB, due diligence, and B2B enrichment.

- **URL**: https://apify.com/automation-lab/india-ogd-company-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## India OGD Company Registry Scraper

Scrape official Indian company master data from the Open Government Data (OGD) India platform and Ministry of Corporate Affairs source dataset.

Use this actor to look up companies by CIN, exact registered name, state, or Registrar of Companies (RoC) and export clean JSON, CSV, Excel, or API results from Apify.

### What does India OGD Company Registry Scraper do?

It queries the public `data.gov.in` company master data API.

The actor returns Indian company registry records with CIN, company name, RoC, status, class, category, capital, incorporation date, registered office address, listing status, state, NIC code, and industrial classification.

It is designed for bulk KYB, vendor checks, due diligence, B2B enrichment, and India company research workflows.

### Who is it for?

- 🛡️ Compliance teams verifying Indian counterparties.
- 🏦 KYB and onboarding teams checking company status before approval.
- 📈 B2B sales teams building state or industry prospect lists.
- 🧾 Procurement teams screening vendors and suppliers.
- ⚖️ Legal teams preparing diligence packs.
- 🎓 Researchers studying Indian corporate registrations.
- 🧑‍💻 Developers who need a simple API around public MCA/OGD data.

### Why use this actor?

The MCA portal is useful for manual checks, but bulk workflows are slow.

This actor wraps the public OGD API in a repeatable Apify workflow.

You can schedule runs, export datasets, call the actor from code, or connect results to downstream tools.

### Data source

The source is the OGD India resource:

`Registrars of Companies (RoC)-wise Company Master Data`

Organization: Ministry of Corporate Affairs.

Resource ID: `4dbe5667-7b6b-41d7-82af-211562424d9a`.

### Data table

| Field | Description |
| --- | --- |
| `cin` | Corporate Identification Number |
| `companyName` | Registered company name |
| `rocCode` | Registrar of Companies value |
| `category` | Company category |
| `subCategory` | Company sub-category |
| `companyClass` | Public, Private, LLP, or other class when available |
| `authorizedCapital` | Authorized capital as a number |
| `paidUpCapital` | Paid-up capital as a number |
| `incorporationDate` | Registration/incorporation date |
| `registeredOfficeAddress` | Registered office address |
| `listingStatus` | Listed or unlisted when available |
| `companyStatus` | Current company status from OGD |
| `state` | Company state code/name value from OGD |
| `companyOrigin` | Indian or foreign company flag |
| `nicCode` | NIC activity code |
| `industrialClassification` | Industrial classification text |
| `sourceResourceId` | OGD resource UUID |
| `queryType` | Lookup mode used by the actor |
| `queryValue` | Input value that produced the row |
| `matchConfidence` | Confidence score for the match |

### How much does it cost to scrape India company registry data?

The actor uses pay-per-event pricing.

You pay a small start charge and then pay per company record saved.

For small tests, keep `maxResults` low.

For bulk state pulls, increase `maxResults` to the required volume.

### Quick start

1. Open the actor on Apify.
2. Enter one or more CINs, exact company names, states, or RoC values.
3. Set `maxResults`.
4. Run the actor.
5. Export the dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

#### CINs

Use CINs for precise lookup.

Example:

`L99999MH1960PLC011854`

#### Exact company names

Use full legal names for exact OGD filtering.

Example:

`INDORE WIRE CO LIMITED`

#### States

Use state values such as:

- `maharashtra`
- `delhi`
- `karnataka`
- `gujarat`

The actor normalizes state input to lowercase.

#### RoC codes

Use values such as:

- `ROC Mumbai`
- `ROC Delhi`
- `ROC Bangalore`

#### Status and class filters

When browsing by state, you can also filter by exact company status or company class.

Examples:

- `Active`
- `Public`
- `Private`

### Example input

```json
{
  "cins": ["L99999MH1960PLC011854"],
  "states": ["maharashtra"],
  "companyStatus": "Active",
  "maxResults": 10
}
````

### Example output

```json
{
  "cin": "L99999MH1960PLC011854",
  "companyName": "INDORE WIRE CO LIMITED",
  "rocCode": "ROC Mumbai",
  "companyStatus": "Active",
  "state": "maharashtra",
  "paidUpCapital": 83966500,
  "incorporationDate": "1960-10-25"
}
```

### Tips for best results

- Use CIN lookup when you need exact matches.
- Use exact company names rather than partial names.
- Use state browsing for prospecting and market mapping.
- Keep the first run small to validate your filters.
- Increase `maxResults` only after confirming the output shape.

### Integrations

You can connect this actor to:

- CRM enrichment pipelines.
- KYB onboarding queues.
- Vendor management systems.
- Compliance case management tools.
- Data warehouses.
- Google Sheets through Apify integrations.
- Webhooks that trigger after dataset items are saved.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/india-ogd-company-registry-scraper').call({
  cins: ['L99999MH1960PLC011854'],
  maxResults: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/india-ogd-company-registry-scraper').call(run_input={
    'states': ['maharashtra'],
    'companyStatus': 'Active',
    'maxResults': 10,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['cin'], item['companyName'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~india-ogd-company-registry-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"cins":["L99999MH1960PLC011854"],"maxResults":10}'
```

### MCP integration

Use the actor from MCP-compatible clients through Apify MCP Server.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/india-ogd-company-registry-scraper`

Claude Code setup:

```bash
claude mcp add apify-india-ogd-company-registry "https://mcp.apify.com/?tools=automation-lab/india-ogd-company-registry-scraper"
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-india-ogd-company-registry": {
      "url": "https://mcp.apify.com/?tools=automation-lab/india-ogd-company-registry-scraper"
    }
  }
}
```

MCP usage prompt:

> Use the Apify India OGD Company Registry tool to look up CIN L99999MH1960PLC011854 and return company status, RoC, capital, and registered office.

MCP example prompts:

- Use the Apify MCP tool `automation-lab/india-ogd-company-registry-scraper` to verify this Indian company CIN.
- Use the India OGD Company Registry MCP tool to export 25 active Delhi company records.
- Use MCP to compare company status, paid-up capital, and registered office for these vendor CINs.

### Claude Code MCP example

Ask Claude Code:

> Run the India OGD Company Registry Scraper for this CIN and summarize the company status and paid-up capital.

### Claude Desktop MCP example

Add the Apify MCP server and enable this actor as a tool.

Then ask:

> Look up these Indian supplier CINs and create a due diligence table.

### Example prompts

- “Find the company status for this CIN.”
- “Pull 100 active companies from Maharashtra.”
- “Create a CSV of Delhi companies with registration dates.”
- “Check whether these vendor company names exist in the OGD master data.”

### Limitations

The OGD endpoint supports exact filters for some fields.

Partial company-name search is not reliable through the verified API route, so this actor treats company names as exact registered names.

Some fields advertised by third-party registry products, such as director details or charges, are not present in this OGD resource.

### Frequently Asked Questions (FAQ)

#### Is this official MCA data?

The actor queries a public OGD India resource published by the Ministry of Corporate Affairs.

#### Can I search by partial company name?

The verified OGD route supports exact company-name filtering. Use the full legal name for best results.

#### Can I export to CSV or Excel?

Yes. Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, and more.

### Troubleshooting

#### Why did my company name return no records?

Use the exact registered name from official records. Partial names may not match the OGD exact filter.

#### Why did a state run return many unrelated companies?

State browsing returns registry rows for that state. Add status, class, or a lower `maxResults` to narrow the export.

#### Why are director names missing?

The verified OGD resource is company master data. It does not include director or charge details.

### Legality

This actor uses public government open data from OGD India.

You are responsible for how you use, store, and combine the data.

Follow applicable privacy, compliance, and data protection rules in your jurisdiction.

### Related scrapers

- [Zefix Scraper](https://apify.com/automation-lab/zefix-scraper)
- [France SIRENE Scraper](https://apify.com/automation-lab/france-sirene-scraper)
- [Moneyhouse.ch Scraper](https://apify.com/automation-lab/moneyhouse-ch-scraper)
- [Company Domain Finder](https://apify.com/automation-lab/company-domain-finder)

### Changelog

#### 0.1

Initial version with CIN, exact company name, state, and RoC lookup against the verified OGD India company master data endpoint.

### Support

If you need another input mode or additional MCA fields, open an issue on the Apify actor page.

### Notes for bulk users

For large state exports, run small validation jobs first.

Then increase `maxResults` gradually.

The source contains millions of records, so broad runs can produce large datasets.

### Field mapping

The actor maps original OGD fields into JavaScript-style names.

For example:

- `CompanyName` becomes `companyName`.
- `CompanyROCcode` becomes `rocCode`.
- `PaidupCapital` becomes `paidUpCapital`.
- `Registered_Office_Address` becomes `registeredOfficeAddress`.

### Source freshness

The source metadata includes an OGD update timestamp.

Each actor run queries the live API route rather than a bundled static file.

### Export formats

Apify datasets support:

- JSON
- CSV
- Excel
- XML
- RSS
- HTML table previews

### Scheduling

Schedule daily, weekly, or monthly runs in Apify Console.

This is useful for monitoring company status changes or refreshing B2B datasets.

### Webhooks

Use Apify webhooks to send run completion events to your application.

A webhook can start enrichment, compliance review, or warehouse loading after the dataset is ready.

### Performance

The actor is HTTP-only and runs with low memory.

No browser automation is used.

No proxy is required for normal operation.

# Actor input Schema

## `cins` (type: `array`):

Corporate Identification Numbers to look up exactly.

## `companyNames` (type: `array`):

Exact registered company names. The OGD API supports exact-name filtering, so include the full legal name for best results.

## `states` (type: `array`):

Indian state names to browse, such as maharashtra, delhi, karnataka, gujarat. Values are normalized to lowercase for the OGD API.

## `rocCodes` (type: `array`):

Optional exact Registrar of Companies values, for example ROC Mumbai or ROC Delhi.

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

Optional exact status filter used with state browsing, for example Active.

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

Optional exact company class filter used with state browsing, for example Private or Public.

## `maxResults` (type: `integer`):

Maximum number of company records to save across all lookups.

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

Optional data.gov.in API key. Leave empty to use the bundled public key verified during actor development.

## Actor input object example

```json
{
  "cins": [
    "L99999MH1960PLC011854"
  ],
  "companyNames": [
    "INDORE WIRE CO LIMITED"
  ],
  "states": [
    "maharashtra"
  ],
  "companyStatus": "Active",
  "maxResults": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "cins": [
        "L99999MH1960PLC011854"
    ],
    "companyNames": [
        "INDORE WIRE CO LIMITED"
    ],
    "states": [
        "maharashtra"
    ],
    "companyStatus": "Active",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/india-ogd-company-registry-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 = {
    "cins": ["L99999MH1960PLC011854"],
    "companyNames": ["INDORE WIRE CO LIMITED"],
    "states": ["maharashtra"],
    "companyStatus": "Active",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/india-ogd-company-registry-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 '{
  "cins": [
    "L99999MH1960PLC011854"
  ],
  "companyNames": [
    "INDORE WIRE CO LIMITED"
  ],
  "states": [
    "maharashtra"
  ],
  "companyStatus": "Active",
  "maxResults": 10
}' |
apify call automation-lab/india-ogd-company-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "India OGD Company Registry Scraper",
        "description": "Scrape official India OGD/MCA company master data by CIN, company name, state, or RoC for KYB, due diligence, and B2B enrichment.",
        "version": "0.1",
        "x-build-id": "qdncBo5hIXq7cx2U9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~india-ogd-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-india-ogd-company-registry-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/automation-lab~india-ogd-company-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-india-ogd-company-registry-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/automation-lab~india-ogd-company-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-india-ogd-company-registry-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": {
                    "cins": {
                        "title": "CINs",
                        "type": "array",
                        "description": "Corporate Identification Numbers to look up exactly.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyNames": {
                        "title": "Exact company names",
                        "type": "array",
                        "description": "Exact registered company names. The OGD API supports exact-name filtering, so include the full legal name for best results.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "States",
                        "type": "array",
                        "description": "Indian state names to browse, such as maharashtra, delhi, karnataka, gujarat. Values are normalized to lowercase for the OGD API.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "rocCodes": {
                        "title": "RoC codes",
                        "type": "array",
                        "description": "Optional exact Registrar of Companies values, for example ROC Mumbai or ROC Delhi.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyStatus": {
                        "title": "Company status",
                        "type": "string",
                        "description": "Optional exact status filter used with state browsing, for example Active."
                    },
                    "companyClass": {
                        "title": "Company class",
                        "type": "string",
                        "description": "Optional exact company class filter used with state browsing, for example Private or Public."
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of company records to save across all lookups.",
                        "default": 50
                    },
                    "apiKey": {
                        "title": "OGD API key",
                        "type": "string",
                        "description": "Optional data.gov.in API key. Leave empty to use the bundled public key verified during actor development."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```