# TradeIndia Sellers & Products Scraper (`solidcode/tradeindia-scraper`) Actor

\[💰 $2.5 / 1K] Extract products and sellers from TradeIndia, India's B2B marketplace. Scrape any category or seller page, or search by keyword. Each product includes name, price, MOQ, specs, and images, plus the seller's company, location, business type, and trust badges.

- **URL**: https://apify.com/solidcode/tradeindia-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 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

## TradeIndia Sellers & Products Scraper

Pull product catalogs and supplier profiles from TradeIndia — India's largest B2B marketplace — and get one clean, flat row per product with the selling company's details, trade terms, and trust signals already attached. Feed it a category URL, a seller page, or a plain keyword, and it walks the entire listing feed for you. Built for B2B sourcing teams, lead-generation agencies, and procurement managers who need verified Indian supplier data without browsing thousands of catalog pages by hand.

### Why This Scraper?

- **~35 fields per product in one flat row** — product details and the selling company's profile are denormalized into every row, so each result is a complete supplier lead with no joining or lookups required.
- **Full B2B trade terms on every product** — minimum order quantity (MOQ), supply ability, delivery time, and packaging details, the exact figures procurement teams need to qualify a supplier.
- **Business-type classification flags** — each seller is tagged Manufacturer, Supplier, Exporter, Distributor, and Trader as five separate boolean flags, so you can isolate factory-direct manufacturers from resellers in one filter.
- **Trust and reputation signals** — Super Seller, Premium Seller, and Trust Stamp badges plus buyer-feedback count and response rate, for ranking suppliers by credibility before you reach out.
- **Whole-category extraction** — walks the listing feed end to end, pulling hundreds to thousands of products from a single category (one observed category held 498 products) instead of stopping at the first page.
- **Keyword search built in** — type "industrial valves" or "cotton t-shirts" and skip hunting for the exact category URL; results come back in the same flat schema.
- **Multiple URLs and terms per run** — queue any mix of category URLs, seller pages, and search keywords in a single run, each with its own result cap.
- **Company location on every row** — city, state, country, and established year for territory mapping and regional supplier discovery across India.
- **Per-product specifications captured** — the product spec table (material, grade, packaging size, and similar key-values) is parsed into a structured object, not flattened into one blob.
- **Lean export toggle** — switch off seller details for a compact product-only feed when you only need names, prices, and MOQ.

### Use Cases

**Supplier Discovery & Lead Generation**
- Build targeted lists of Indian manufacturers in a product category, filtered to factory-direct suppliers via the Manufacturer flag.
- Capture company name, city, state, and seller profile URL for every product as a ready-to-import lead record.
- Rank prospects by Super Seller, Premium Seller, and Trust Stamp badges before outreach.

**Procurement & Sourcing**
- Compare minimum order quantity, supply ability, and delivery time across competing suppliers for the same item.
- Shortlist vendors by certifications and established year to de-risk a new sourcing relationship.
- Pull packaging details and product specifications to confirm a supplier matches your spec before requesting a quote.

**Competitive Pricing Intelligence**
- Track listed prices and MOQ across a whole category to benchmark your own quotes.
- Monitor how many suppliers list a given product and at what price points.
- Spot pricing gaps and underserved niches in a product category.

**Market Research**
- Map the supplier landscape of an industry by city and state across India.
- Measure the manufacturer-versus-distributor mix in a category.
- Analyze buyer-feedback counts and response rates to gauge market activity.

### Getting Started

#### Search by keyword

```json
{
  "searchTerms": ["industrial valves"]
}
````

#### Scrape a full category

```json
{
  "startUrls": ["https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"],
  "maxResults": 0
}
```

#### Multiple inputs with a lean export

```json
{
  "startUrls": [
    "https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/",
    "https://www.tradeindia.com/seller/industrial-supplies/industrial-valves/"
  ],
  "searchTerms": ["cotton t-shirts"],
  "maxResults": 500,
  "includeSellerDetails": false
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `["https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"]` | One or more TradeIndia category or seller page URLs. Each URL is scraped in turn. |
| `searchTerms` | array | `[]` | Optional product keywords to search on TradeIndia, e.g. "industrial valves" or "cotton t-shirts". Use this when you do not have a specific page URL in mind. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of products to collect from each URL or search term. Set to `0` to collect all available results. |
| `includeSellerDetails` | boolean | `true` | Include extended company information for each seller, such as business type, established year, certifications, and trust badges. Turn off for a leaner, product-only export. |

### Output

Each result is one product as a flat row, with the selling company's details attached.

```json
{
  "productId": "123456789",
  "productName": "Pediatric Multivitamin Syrup 100ml",
  "productDescription": "Sugar-free pediatric multivitamin syrup for daily nutritional support.",
  "productUrl": "https://www.tradeindia.com/products/pediatric-multivitamin-syrup-123456789.html",
  "imageUrl": "https://tiimg.tistatic.com/.../pediatric-syrup.jpg",
  "price": "150 INR",
  "currency": "INR",
  "minOrderQuantity": "100 Box",
  "specifications": {
    "Form": "Syrup",
    "Packaging Size": "100 ml",
    "Shelf Life": "24 Months"
  },
  "supplyAbility": "10000 Box Per Month",
  "deliveryTime": "7-10 Days",
  "packagingDetails": "Carton box of 50 units",
  "productStatus": "active",
  "companyName": "Wellness Pharma Pvt. Ltd.",
  "city": "Ahmedabad",
  "state": "Gujarat",
  "profileId": "9988776",
  "userId": "5544332",
  "profileUrl": "https://www.tradeindia.com/wellness-pharma/",
  "country": "India",
  "countryCode": "IN",
  "businessType": "Manufacturer",
  "establishedYear": "2009",
  "memberSince": "2014",
  "certifications": ["ISO 9001:2015", "GMP"],
  "isManufacturer": true,
  "isSupplier": true,
  "isExporter": true,
  "isDistributor": false,
  "isTrader": false,
  "buyerFeedbackCount": 47,
  "responseRate": "85%",
  "isSuperSeller": true,
  "isPremiumSeller": false,
  "hasTrustStamp": true,
  "sourceUrl": "https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/",
  "scrapedAt": "2026-06-27T10:00:00Z"
}
```

#### Product Core

| Field | Type | Description |
|-------|------|-------------|
| `productId` | string | TradeIndia product identifier |
| `productName` | string | Product title |
| `productDescription` | string | Product description |
| `productStatus` | string | Listing status |
| `productUrl` | string | Link to the product detail page |
| `imageUrl` | string | Primary product image URL |

#### Pricing & Order Terms

| Field | Type | Description |
|-------|------|-------------|
| `price` | string | Listed price (frequently unset by the seller) |
| `currency` | string | Currency code, e.g. INR |
| `minOrderQuantity` | string | Minimum order quantity (MOQ) |
| `supplyAbility` | string | Stated supply ability |
| `deliveryTime` | string | Stated delivery time |
| `packagingDetails` | string | Packaging details |

#### Specifications

| Field | Type | Description |
|-------|------|-------------|
| `specifications` | object | Product spec key-values (e.g. material, form, packaging size) |
| `certifications` | array | Company certifications, e.g. ISO 9001, GMP |

#### Seller / Company

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Seller / company name |
| `city` | string | Seller city |
| `state` | string | Seller state |
| `country` | string | Seller country |
| `countryCode` | string | Seller country code |
| `businessType` | string | Primary business type |
| `establishedYear` | string | Year the company was established |
| `memberSince` | string | TradeIndia membership start year |
| `isManufacturer` | boolean | Classification flag |
| `isSupplier` | boolean | Classification flag |
| `isExporter` | boolean | Classification flag |
| `isDistributor` | boolean | Classification flag |
| `isTrader` | boolean | Classification flag |
| `buyerFeedbackCount` | integer | Number of buyer feedbacks |
| `responseRate` | string | Seller response rate |
| `isSuperSeller` | boolean | Super Seller trust badge |
| `isPremiumSeller` | boolean | Premium Seller trust badge |
| `hasTrustStamp` | boolean | Trust Stamp badge |

#### Identifiers & Source

| Field | Type | Description |
|-------|------|-------------|
| `profileId` | string | Seller profile id |
| `userId` | string | Seller user id |
| `profileUrl` | string | Seller profile page URL |
| `sourceUrl` | string | The input URL or search term this row came from |
| `scrapedAt` | string | ISO timestamp of when the row was collected |

Extended seller fields (everything in the Seller / Company and Identifiers tables beyond `companyName`, `city`, and `state`) are omitted when `includeSellerDetails` is set to `false`.

### Tips for Best Results

- **Category URLs return the richest seller data.** Category and seller pages include the full supplier profile — response rate, established year, certifications, country, and buyer-feedback count. Keyword search returns the same products but a slightly leaner seller block, leaving `responseRate`, `establishedYear`, `countryCode`, and `buyerFeedbackCount` blank. Prefer a category URL whenever you need complete supplier profiles.
- **Set `maxResults` to `0` to capture an entire category** — large categories run into the thousands of products, so leave a generous cap only when you genuinely want the full feed.
- **Filter on the business-type flags after extraction** — use `isManufacturer` to drop resellers and surface factory-direct suppliers, the highest-value B2B leads.
- **Price is often blank by design** — many TradeIndia sellers list MOQ and supply ability but no price. Lean on `minOrderQuantity` and `supplyAbility` to qualify suppliers when `price` is empty.
- **Queue several categories in one run** by adding multiple URLs to `startUrls`; the `sourceUrl` field tells you which input each row came from.
- **Turn off `includeSellerDetails`** when you only need a product price-and-MOQ list — the export is leaner and faster to scan in a spreadsheet.
- **Rank prospects by trust badges and feedback** — sort on `isSuperSeller`, `hasTrustStamp`, and `buyerFeedbackCount` to put the most credible suppliers at the top of your outreach list.
- **Use category or seller-listing URLs, not bare profile pages** — a category or seller-listing page lists products; a standalone company profile page may return no products. If a URL comes back empty, open it on tradeindia.com and confirm it shows a product grid.

### Pricing

**From $2.50 per 1,000 results** — flat pay-per-result pricing, with every product row counting as one result. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.30 | $0.29 | $0.27 | $0.25 |
| 1,000 | $3.00 | $2.85 | $2.65 | $2.50 |
| 10,000 | $30.00 | $28.50 | $26.50 | $25.00 |
| 100,000 | $300.00 | $285.00 | $265.00 | $250.00 |

A "result" is a single product row. Platform usage fees, if any, are billed separately by Apify.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This scraper collects publicly available business listings from TradeIndia. Use it responsibly: respect TradeIndia's Terms of Service, comply with applicable data-protection laws (including GDPR and India's data-protection rules where relevant), and only use collected company data for legitimate business purposes such as supplier discovery, procurement, and market research. You are responsible for how you use the data you collect.

# Actor input Schema

## `startUrls` (type: `array`):

Paste one or more TradeIndia category or seller page URLs, for example https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/. Each URL is scraped in turn.

## `searchTerms` (type: `array`):

Optional product keywords to search on TradeIndia, for example 'industrial valves' or 'cotton t-shirts'. Each term is searched and its results collected. Use this if you do not have a specific page URL in mind.

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

Maximum number of products to collect from each URL or search term. Set to 0 to collect all available results. Lower numbers keep runs fast and inexpensive. Results come in pages of 50, so a small cap may return up to a full extra page (for example, a cap of 10 still returns the full 50-result first page) — pages are never cut off partway.

## `includeSellerDetails` (type: `boolean`):

Include extended company information for each seller, such as business type, established year, certifications, and trust badges. Turn off for a leaner, product-only export.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"
  ],
  "searchTerms": [],
  "maxResults": 100,
  "includeSellerDetails": true
}
```

# Actor output Schema

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

Table of scraped products with key fields.

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

Detailed product data including specifications and full seller profile.

# 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 = {
    "startUrls": [
        "https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"
    ],
    "searchTerms": [],
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/tradeindia-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 = {
    "startUrls": ["https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"],
    "searchTerms": [],
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/tradeindia-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 '{
  "startUrls": [
    "https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/"
  ],
  "searchTerms": [],
  "maxResults": 100
}' |
apify call solidcode/tradeindia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TradeIndia Sellers & Products Scraper",
        "description": "[💰 $2.5 / 1K] Extract products and sellers from TradeIndia, India's B2B marketplace. Scrape any category or seller page, or search by keyword. Each product includes name, price, MOQ, specs, and images, plus the seller's company, location, business type, and trust badges.",
        "version": "1.0",
        "x-build-id": "F2X1yIIgga6JUMAmu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~tradeindia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-tradeindia-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/solidcode~tradeindia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-tradeindia-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/solidcode~tradeindia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-tradeindia-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": {
                    "startUrls": {
                        "title": "TradeIndia URLs",
                        "type": "array",
                        "description": "Paste one or more TradeIndia category or seller page URLs, for example https://www.tradeindia.com/seller/health-beauty/pediatric-medicines/. Each URL is scraped in turn.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Optional product keywords to search on TradeIndia, for example 'industrial valves' or 'cotton t-shirts'. Each term is searched and its results collected. Use this if you do not have a specific page URL in mind.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results Per Input",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to collect from each URL or search term. Set to 0 to collect all available results. Lower numbers keep runs fast and inexpensive. Results come in pages of 50, so a small cap may return up to a full extra page (for example, a cap of 10 still returns the full 50-result first page) — pages are never cut off partway."
                    },
                    "includeSellerDetails": {
                        "title": "Include Full Seller Details",
                        "type": "boolean",
                        "description": "Include extended company information for each seller, such as business type, established year, certifications, and trust badges. Turn off for a leaner, product-only export.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```