# TradeIndia Supplier & Product Scraper (`automation-lab/tradeindia-supplier-product-scraper`) Actor

Scrape public TradeIndia search results for India B2B supplier leads, prices, MOQ, product specs, locations, badges, and profile links.

- **URL**: https://apify.com/automation-lab/tradeindia-supplier-product-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation, Business, E-commerce
- **Stats:** 2 total users, 1 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

## TradeIndia Supplier & Product Scraper

Scrape public TradeIndia search results for product and supplier leads.

The actor turns TradeIndia keyword searches into structured Apify dataset records with product titles, supplier names, prices, MOQ, locations, product specifications, profile links, badges, and source URLs.

Use it for India B2B sourcing, procurement research, price monitoring, supplier discovery, and lead-generation workflows.

---

### What does TradeIndia Supplier & Product Scraper do?

TradeIndia Supplier & Product Scraper extracts public listing data from TradeIndia search pages.

It supports:

- 🔎 Keyword searches such as `steel pipe`, `plastic granules`, or `industrial valves`
- 🔗 Direct TradeIndia search result URLs
- 🏷️ Sponsored listings when visible on the page
- 📦 Organic product/supplier cards
- 🧾 Product specifications and trade information from listing data
- 📍 Supplier location and business type fields
- 🧹 Duplicate removal across pages and keywords

The actor is HTTP-first and reads the server-rendered TradeIndia page data. No login is required for the supported listing fields.

### Who is it for?

This actor is useful for teams that need repeatable supplier intelligence from TradeIndia.

Typical users include:

- 🛒 Procurement teams building supplier shortlists
- 🌏 Importers and exporters sourcing India manufacturers
- 📞 B2B lead-generation teams enriching prospect lists
- 📊 Market researchers tracking product availability and pricing
- 🏭 Manufacturers benchmarking competitors and distributors
- 🧑‍💼 Sourcing agencies preparing vendor comparison sheets
- 🔁 Operations teams monitoring MOQ and price changes over time

### Why use this actor?

Manual TradeIndia research is slow when you need more than a few listings.

This actor helps you:

- Export structured data instead of copying cards by hand
- Compare suppliers across cities, business types, and badges
- Track price and MOQ text for recurring sourcing checks
- Feed supplier leads into spreadsheets, CRMs, or enrichment tools
- Build repeatable Apify tasks for recurring market monitoring

### What data can you extract?

The default dataset contains one row per product/supplier listing.

| Field | Description |
| --- | --- |
| `keyword` | Search keyword used for the listing |
| `productTitle` | Full TradeIndia product title |
| `productName` | Short product name when available |
| `productUrl` | Absolute URL to the TradeIndia product page |
| `imageUrl` | Product image URL |
| `priceText` | Displayed price text |
| `priceAmount` | Raw price/amount value when available |
| `currency` | Currency detected from the listing |
| `moq` | Minimum order quantity |
| `unit` | Price or order unit |
| `supplierName` | Supplier/company name |
| `supplierProfileUrl` | TradeIndia supplier profile URL |
| `supplierWebsite` | Public supplier website/catalog URL when exposed |
| `location` | Combined location string |
| `city` | Supplier city |
| `state` | Supplier state |
| `country` | Supplier country |
| `businessType` | Manufacturer, supplier, exporter, etc. |
| `memberSinceYears` | TradeIndia membership age in years |
| `badges` | Trust, premium, super seller, Made in India, and stock badges |
| `productSpecifications` | Key-value product specification object |
| `tradeInformation` | Supply ability, delivery time, and related trade fields |
| `searchRank` | Rank on the source page |
| `pageNumber` | Search result page number |
| `listingType` | `organic`, `sponsored`, or `showcase` |
| `sourceUrl` | Search page URL scraped |
| `scrapedAt` | ISO timestamp |

### How much does it cost to scrape TradeIndia supplier leads?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-item charge for each saved product/supplier record.

The default input is intentionally small so first runs stay cheap. Increase `maxItems` when you are ready to collect larger supplier lists.

Final Store pricing is shown on the Apify actor page before you start a run.

### How to use TradeIndia Supplier & Product Scraper

1. Open the actor on Apify.
2. Enter one or more TradeIndia product keywords.
3. Optionally add direct TradeIndia search URLs.
4. Set `maxItems` to the number of supplier/product records you need.
5. Keep sponsored listings enabled if you want paid supplier cards too.
6. Start the run.
7. Export the dataset as JSON, CSV, Excel, XML, or through the Apify API.

### Input options

#### `keywords`

TradeIndia search keywords.

Examples:

- `steel pipe`
- `plastic granules`
- `industrial valves`
- `rice mill machinery`

#### `searchUrls`

Direct TradeIndia search result URLs.

Use this when you already have a TradeIndia URL with a specific query.

#### `maxItems`

Maximum number of product/supplier records to save across all keywords and URLs.

#### `includeSponsored`

When enabled, the actor includes sponsored/banner cards shown above organic listings.

#### `includeShowcase`

When enabled, the actor includes TradeIndia showcase or recommended products from each page.

#### `requestDelayMillis`

Delay between paginated requests. The default polite delay is suitable for normal runs.

### Example input

```json
{
  "keywords": ["steel pipe"],
  "maxItems": 100,
  "includeSponsored": true,
  "includeShowcase": false,
  "requestDelayMillis": 350
}
````

### Example with direct TradeIndia URL

```json
{
  "searchUrls": [
    { "url": "https://www.tradeindia.com/search.html?keyword=industrial%20valves" }
  ],
  "maxItems": 75,
  "includeSponsored": true
}
```

### Example output

```json
{
  "keyword": "steel pipe",
  "productTitle": "Uncoated Lance Pipes - Color: Grey",
  "productName": "Uncoated Lance Pipes",
  "productUrl": "https://www.tradeindia.com/products/uncoated-lance-pipes-c4848038.html",
  "imageUrl": "https://cpimg.tistatic.com/04848038/b/4/Uncoated-Lance-Pipes.jpg",
  "priceText": "28 INR (Approx.)",
  "moq": "1000",
  "unit": "Meter/Meters",
  "supplierName": "Guru Corporation",
  "location": "Ahmedabad, Gujarat, India",
  "businessType": "Manufacturer | Supplier",
  "badges": ["Made in India", "Trust Stamp", "Super Seller", "In Stock"],
  "pageNumber": 1,
  "listingType": "organic"
}
```

### Tips for best results

- Use product-specific keywords for cleaner supplier lists.
- Run separate tasks for different product families.
- Keep `includeShowcase` off if you only want core search results.
- Use a direct TradeIndia URL when you want to preserve a specific search query.
- Schedule recurring runs to monitor price and MOQ changes.
- Export CSV for spreadsheet review and JSON for automation.

### Integrations

The dataset can be used with many sourcing and sales workflows.

Common patterns:

- Send CSV exports to procurement teams.
- Push supplier records to a CRM.
- Enrich supplier websites with email discovery tools.
- Compare price and MOQ changes in a database.
- Trigger notifications when new suppliers appear for a keyword.
- Connect the actor to Make, Zapier, n8n, or custom webhooks.

### API usage

You can run the actor from code with the Apify API.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tradeindia-supplier-product-scraper').call({
  keywords: ['steel pipe'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tradeindia-supplier-product-scraper').call(run_input={
    'keywords': ['steel pipe'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~tradeindia-supplier-product-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["steel pipe"],"maxItems":100}'
```

### MCP integration

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/tradeindia-supplier-product-scraper
```

Claude Code setup:

```bash
claude mcp add apify-tradeindia https://mcp.apify.com/?tools=automation-lab/tradeindia-supplier-product-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-tradeindia": {
      "url": "https://mcp.apify.com/?tools=automation-lab/tradeindia-supplier-product-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Use MCP tool `automation-lab/tradeindia-supplier-product-scraper` to collect 100 TradeIndia steel pipe supplier leads and summarize the top cities."
- "Run the TradeIndia product scraper through MCP for plastic granules and compare MOQ values."
- "Use the Apify MCP server to run a TradeIndia supplier monitor for industrial valves and alert me when new suppliers appear."

### Apify storage and exports

Results are saved to the default Apify dataset.

You can export data as:

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

You can also access results from the Dataset API.

### Scheduling recurring supplier monitoring

Apify tasks make monitoring easy.

Create a task with your keywords, then schedule it daily, weekly, or monthly.

Recurring runs can help you detect:

- New suppliers
- Changed prices
- Changed MOQ values
- New product specifications
- Supplier location changes
- Sponsored supplier activity

### Data quality notes

TradeIndia listing fields vary by supplier and product.

Some records may not include every optional field.

For example, a supplier may expose product specifications but not a public catalog website, or a listing may show MOQ without a normalized currency field.

The actor keeps raw text fields when normalization is not reliable.

### Limitations

This actor focuses on public unauthenticated listing data.

It does not promise private contact details that require login or inquiry forms.

Phone and email fields may not be available in public search listings.

The actor does not place inquiries, send messages, or interact with TradeIndia accounts.

### Legality

This actor extracts publicly available information from TradeIndia pages.

You are responsible for using the data in accordance with applicable laws, TradeIndia terms, privacy rules, and your own compliance requirements.

Do not use scraped data for spam, unlawful outreach, or activities that violate platform terms.

### FAQ

#### Why did I get fewer items than requested?

The search may have fewer public listings than `maxItems`, or duplicate products may be removed across sponsored, organic, and showcase sections.

Try broader keywords or enable showcase listings.

#### Why are email or phone fields missing?

TradeIndia often protects direct contact details behind account flows or inquiry actions. This actor targets public listing data and does not bypass login or private contact gates.

#### Why are some fields empty?

TradeIndia suppliers do not all publish the same metadata. Optional fields such as supplier website, state, trade information, or specifications may be absent on some listings.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/made-in-china-scraper
- https://apify.com/automation-lab/europages-scraper
- https://apify.com/automation-lab/thomasnet-scraper
- https://apify.com/automation-lab/website-contact-finder

### Support

If a TradeIndia page changes or you need another field from public listing data, open an issue on the actor page with a sample input and run URL.

### Changelog

See `.actor/CHANGELOG.md` for release notes.

# Actor input Schema

## `keywords` (type: `array`):

Product or supplier search terms to scrape on TradeIndia, for example steel pipe, plastic granules, industrial valves.

## `searchUrls` (type: `array`):

Optional direct TradeIndia search result URLs. Use this when you already have a filtered TradeIndia search page.

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

Maximum number of product-supplier records to save across all keywords and URLs.

## `includeSponsored` (type: `boolean`):

Also save TradeIndia banner/sponsored supplier cards shown above organic search results.

## `includeShowcase` (type: `boolean`):

Also save TradeIndia showcase/recommended products from each search page when available.

## `requestDelayMillis` (type: `integer`):

Small polite delay between TradeIndia pagination requests.

## Actor input object example

```json
{
  "keywords": [
    "steel pipe"
  ],
  "searchUrls": [
    {
      "url": "https://www.tradeindia.com/search.html?keyword=steel%20pipe"
    }
  ],
  "maxItems": 20,
  "includeSponsored": true,
  "includeShowcase": false,
  "requestDelayMillis": 350
}
```

# 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 = {
    "keywords": [
        "steel pipe"
    ],
    "searchUrls": [
        {
            "url": "https://www.tradeindia.com/search.html?keyword=steel%20pipe"
        }
    ],
    "maxItems": 20,
    "includeSponsored": true,
    "includeShowcase": false,
    "requestDelayMillis": 350
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tradeindia-supplier-product-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 = {
    "keywords": ["steel pipe"],
    "searchUrls": [{ "url": "https://www.tradeindia.com/search.html?keyword=steel%20pipe" }],
    "maxItems": 20,
    "includeSponsored": True,
    "includeShowcase": False,
    "requestDelayMillis": 350,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tradeindia-supplier-product-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 '{
  "keywords": [
    "steel pipe"
  ],
  "searchUrls": [
    {
      "url": "https://www.tradeindia.com/search.html?keyword=steel%20pipe"
    }
  ],
  "maxItems": 20,
  "includeSponsored": true,
  "includeShowcase": false,
  "requestDelayMillis": 350
}' |
apify call automation-lab/tradeindia-supplier-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradeIndia Supplier & Product Scraper",
        "description": "Scrape public TradeIndia search results for India B2B supplier leads, prices, MOQ, product specs, locations, badges, and profile links.",
        "version": "0.1",
        "x-build-id": "IQ1Syjwymg9SMh6yA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tradeindia-supplier-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tradeindia-supplier-product-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~tradeindia-supplier-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tradeindia-supplier-product-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~tradeindia-supplier-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tradeindia-supplier-product-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": {
                    "keywords": {
                        "title": "TradeIndia search keywords",
                        "type": "array",
                        "description": "Product or supplier search terms to scrape on TradeIndia, for example steel pipe, plastic granules, industrial valves.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "TradeIndia search URLs",
                        "type": "array",
                        "description": "Optional direct TradeIndia search result URLs. Use this when you already have a filtered TradeIndia search page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum products / suppliers",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of product-supplier records to save across all keywords and URLs.",
                        "default": 20
                    },
                    "includeSponsored": {
                        "title": "Include sponsored listings",
                        "type": "boolean",
                        "description": "Also save TradeIndia banner/sponsored supplier cards shown above organic search results.",
                        "default": true
                    },
                    "includeShowcase": {
                        "title": "Include showcase recommendations",
                        "type": "boolean",
                        "description": "Also save TradeIndia showcase/recommended products from each search page when available.",
                        "default": false
                    },
                    "requestDelayMillis": {
                        "title": "Delay between pages (milliseconds)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Small polite delay between TradeIndia pagination requests.",
                        "default": 350
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```