# Flipkart Product Scraper (`khadinakbar/flipkart-product-scraper`) Actor

Scrape Flipkart product details and search results — price, MRP, discount, rating, specs, seller, offers, stock. URL or keyword in, structured JSON out. MCP-ready.

- **URL**: https://apify.com/khadinakbar/flipkart-product-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, MCP servers, AI
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Flipkart Product Scraper

Scrape **Flipkart product details and search results** into clean, structured JSON. Pass a **search keyword** or **product URLs** and get back price, MRP, discount %, rating, full specifications, seller, available offers, stock status, highlights, and images — ready for price monitoring, catalog building, market research, and AI agents.

> **What you get:** one record per product. Keyword search auto-paginates and (optionally) opens each result for full detail. Product URLs are always scraped in full.

---

### What it scrapes

| Field | Description |
|---|---|
| `title` | Product name |
| `productId` | Flipkart `pid` / `itm` id |
| `url` / `shareUrl` | Product page link + cleaned share link |
| `currentPrice` | Current selling price (₹ INR) |
| `originalPrice` | Original price / MRP (₹ INR) |
| `discountPercent` / `discounted` | Discount off MRP |
| `rating` | Average rating (0–5) |
| `inStock` | Stock availability |
| `fAssured` | Flipkart Assured badge |
| `seller` | `{ name, rating }` |
| `highlights` | Key highlight bullets |
| `specifications` | Grouped spec sections → `{ section, details:[{name,value}] }` |
| `offers` | Bank / exchange / other offers → `{ type, description }` |
| `thumbnails` | Product image URLs |
| `scrapedAt` | ISO-8601 timestamp |

In search-only mode (`enrichProductDetails: false`) each record is a lightweight listing card: `title`, `currentPrice`, `originalPrice`, `thumbnail`, `url`, `productId`.

---

### When to use it

- **Price & MRP monitoring** across phones, electronics, fashion, appliances.
- **Catalog / competitor research** — pull a whole keyword's worth of products with specs.
- **Deal tracking** — discount % and offers per product.
- **AI agents (MCP)** — single URL or keyword in, structured JSON out.

**Not for:** Flipkart reviews scraping (separate tool), category-tree crawling, or seller-storefront enumeration.

---

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `search` | string | `iphone 15` | Keyword, as typed in Flipkart search |
| `productUrls` | string[] | `[]` | Flipkart product links (must contain `/p/`) |
| `maxProducts` | integer | `20` | Cap on products scraped & billed |
| `enrichProductDetails` | boolean | `true` | Open each search result for full detail |
| `sortBy` | enum | `relevance` | `relevance` · `price_asc` · `price_desc` · `newest` · `popularity` |
| `minPrice` / `maxPrice` | integer | — | Price-range filter (₹) for search |
| `maxSearchPages` | integer | `10` | Pagination safety cap |
| `proxyConfiguration` | object | RESIDENTIAL / IN | See proxy note below |

You can combine `search` and `productUrls` in one run. At least one is required.

#### Example input

```json
{
  "search": "wireless earbuds",
  "maxProducts": 50,
  "sortBy": "price_asc",
  "minPrice": 1000,
  "maxPrice": 5000,
  "enrichProductDetails": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "IN" }
}
````

```json
{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm6ac6485515ae4"
  ]
}
```

***

### Pricing — Pay Per Event

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| Product scraped | **$0.004** per product |

You are billed **only for products successfully scraped**. Blocked or failed requests are not charged. A 50-product run costs about **$0.20**. Pay-Per-Usage (compute + proxy) is also available for very large jobs.

***

### ⚠️ Proxy requirement (read this)

Flipkart aggressively blocks **datacenter IPs** with a reCAPTCHA "Are you a human?" interstitial. This actor defaults to **Apify Residential proxy with country = `IN` (India)**, which is required for reliable results and correct INR pricing. If you run it on a datacenter proxy you will see a clear, non-billed `ERROR` status telling you to switch to residential — no silent empty datasets.

***

### Usage

#### Apify API (JavaScript)

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/flipkart-product-scraper').call({
    search: 'iphone 15',
    maxProducts: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Apify API (Python)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/flipkart-product-scraper").call(
    run_input={"search": "iphone 15", "maxProducts": 20}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### MCP (AI agents)

Exposed as `apify--flipkart-product-scraper` via the Apify MCP server. Agents call it with a `search` keyword or `productUrls` and receive structured product JSON.

***

### FAQ

**Why are some fields missing on a product?**
Flipkart layouts vary by category; missing fields are omitted (not null-filled). Highlights/specs/offers depend on what the seller publishes.

**Why INR prices?**
Flipkart serves India; the actor defaults to an India residential proxy so prices reflect the Indian store in ₹.

**Can I scrape reviews?**
Not with this actor — use a dedicated Flipkart reviews scraper.

**Does it handle out-of-stock / coming-soon products?**
Yes — `inStock` is set accordingly and price may be absent.

**How do I scrape an entire keyword?**
Set `search` and raise `maxProducts` / `maxSearchPages`. Search auto-paginates.

***

### Legal & compliance

This actor collects only **publicly available** product data from Flipkart. It does not log in, bypass paywalls, or access private/personal data. You are responsible for using the scraped data in compliance with Flipkart's Terms of Service, applicable laws (including the DPDP Act and GDPR where relevant), and for respecting intellectual-property and database rights. Use for lawful purposes such as price comparison, research, and analytics. This actor is not affiliated with or endorsed by Flipkart.

# Actor input Schema

## `search` (type: `string`):

Free-text keyword searched on Flipkart, exactly as you would type it in the Flipkart search bar (e.g. 'iphone 15' or 'running shoes men'). Returns matching products from the search results, auto-paginating until 'Max products' is reached. Leave empty if you only want to scrape specific product URLs. NOT a product URL — put links in 'Product URLs' instead.

## `productUrls` (type: `array`):

Direct Flipkart product page links to scrape in full detail (each must contain '/p/' — e.g. 'https://www.flipkart.com/apple-iphone-15/p/itm6ac6485515ae4'). Use this for exact products you already know. Can be combined with 'Search'. NOT search/category/listing URLs — those are ignored; use the 'Search' field for keyword discovery.

## `maxProducts` (type: `integer`):

Maximum number of products to scrape and bill in this run, across search results and/or product URLs (e.g. 20). Caps cost: each product is charged once. Defaults to 20. When you pass more 'Product URLs' than this, the cap is automatically raised so all your URLs are scraped.

## `enrichProductDetails` (type: `boolean`):

When ON (default), each product found via 'Search' is opened and scraped in full (specs, offers, seller, highlights, stock, rating). When OFF, search returns only the lightweight listing card (title, price, MRP, thumbnail, URL) — faster and cheaper but fewer fields. Has no effect on 'Product URLs', which are always scraped in full. Turn OFF for quick price-list scans.

## `sortBy` (type: `string`):

Sort order applied to 'Search' results before scraping (e.g. 'price\_asc' for cheapest first). One of: relevance, price\_asc, price\_desc, newest, popularity. Defaults to 'relevance' (Flipkart's default ranking). Ignored for 'Product URLs'.

## `minPrice` (type: `integer`):

Lower bound of the Flipkart price-range filter for 'Search', in Indian Rupees (e.g. 10000). Flipkart may round the range to its own buckets. Leave empty for no lower bound. Ignored for 'Product URLs'.

## `maxPrice` (type: `integer`):

Upper bound of the Flipkart price-range filter for 'Search', in Indian Rupees (e.g. 50000). Flipkart may round the range to its own buckets. Leave empty for no upper bound. Ignored for 'Product URLs'.

## `maxSearchPages` (type: `integer`):

Safety cap on how many Flipkart search result pages to paginate through (~24 products per page). Defaults to 10. Lower it to bound runtime on very broad queries; the 'Max products' cap usually stops the run first.

## `proxyConfiguration` (type: `object`):

Proxy used for requests. Flipkart blocks datacenter IPs with reCAPTCHA, so a RESIDENTIAL proxy with country 'IN' (India) is strongly recommended and is the default. Override only if you know your proxy clears Flipkart. Apify Proxy residential is required for reliable results.

## Actor input object example

```json
{
  "search": "running shoes men",
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-blue-128-gb/p/itm6ac6485515ae4"
  ],
  "maxProducts": 20,
  "enrichProductDetails": true,
  "sortBy": "relevance",
  "maxSearchPages": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}
```

# Actor output Schema

## `products` (type: `string`):

All scraped Flipkart product records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "search": "iphone 15",
    "productUrls": [],
    "maxProducts": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/flipkart-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 = {
    "search": "iphone 15",
    "productUrls": [],
    "maxProducts": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/flipkart-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 '{
  "search": "iphone 15",
  "productUrls": [],
  "maxProducts": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call khadinakbar/flipkart-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Product Scraper",
        "description": "Scrape Flipkart product details and search results — price, MRP, discount, rating, specs, seller, offers, stock. URL or keyword in, structured JSON out. MCP-ready.",
        "version": "0.1",
        "x-build-id": "kUWXPybMf1510A8uS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~flipkart-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-flipkart-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/khadinakbar~flipkart-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-flipkart-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/khadinakbar~flipkart-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-flipkart-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": {
                    "search": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword searched on Flipkart, exactly as you would type it in the Flipkart search bar (e.g. 'iphone 15' or 'running shoes men'). Returns matching products from the search results, auto-paginating until 'Max products' is reached. Leave empty if you only want to scrape specific product URLs. NOT a product URL — put links in 'Product URLs' instead."
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Flipkart product page links to scrape in full detail (each must contain '/p/' — e.g. 'https://www.flipkart.com/apple-iphone-15/p/itm6ac6485515ae4'). Use this for exact products you already know. Can be combined with 'Search'. NOT search/category/listing URLs — those are ignored; use the 'Search' field for keyword discovery.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProducts": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of products to scrape and bill in this run, across search results and/or product URLs (e.g. 20). Caps cost: each product is charged once. Defaults to 20. When you pass more 'Product URLs' than this, the cap is automatically raised so all your URLs are scraped.",
                        "default": 20
                    },
                    "enrichProductDetails": {
                        "title": "Scrape full product details (search mode)",
                        "type": "boolean",
                        "description": "When ON (default), each product found via 'Search' is opened and scraped in full (specs, offers, seller, highlights, stock, rating). When OFF, search returns only the lightweight listing card (title, price, MRP, thumbnail, URL) — faster and cheaper but fewer fields. Has no effect on 'Product URLs', which are always scraped in full. Turn OFF for quick price-list scans.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort search results by",
                        "enum": [
                            "relevance",
                            "price_asc",
                            "price_desc",
                            "newest",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "Sort order applied to 'Search' results before scraping (e.g. 'price_asc' for cheapest first). One of: relevance, price_asc, price_desc, newest, popularity. Defaults to 'relevance' (Flipkart's default ranking). Ignored for 'Product URLs'.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum price (₹)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound of the Flipkart price-range filter for 'Search', in Indian Rupees (e.g. 10000). Flipkart may round the range to its own buckets. Leave empty for no lower bound. Ignored for 'Product URLs'."
                    },
                    "maxPrice": {
                        "title": "Maximum price (₹)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound of the Flipkart price-range filter for 'Search', in Indian Rupees (e.g. 50000). Flipkart may round the range to its own buckets. Leave empty for no upper bound. Ignored for 'Product URLs'."
                    },
                    "maxSearchPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Safety cap on how many Flipkart search result pages to paginate through (~24 products per page). Defaults to 10. Lower it to bound runtime on very broad queries; the 'Max products' cap usually stops the run first.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for requests. Flipkart blocks datacenter IPs with reCAPTCHA, so a RESIDENTIAL proxy with country 'IN' (India) is strongly recommended and is the default. Override only if you know your proxy clears Flipkart. Apify Proxy residential is required for reliable results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
