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

Scrape any Flipkart product page for price, MRP, discount, full specifications, rating breakdown, and bank/EMI/exchange offers — plus F-Assured, GST, and COD flags. Paste up to 50 URLs and get clean rows in under a minute. $1 per 1,000 successful products.

- **URL**: https://apify.com/sourabhbgp/flipkart-product-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 product results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 — price, MRP, ratings, specs, offers & FSN

Pulls one row per Flipkart product URL with 35+ normalized fields: selling price, MRP, discount, rating breakdown, specifications, bank/EMI/exchange offers, F-Assured & GST flags — plus Flipkart's canonical FSN and listing ID, fields no other Apify scraper exposes structurally.

**$1 per 1,000 products. Failed/blocked rows are pushed to the dataset for traceability but you're not charged for them.**

Works on any `flipkart.com/.../p/itm…` URL across every Flipkart category — mobiles, fashion, large appliances, books, groceries, the lot.

---

### Why this scraper?

- 💰 **$1 per 1,000 products** — matches the cheapest credible Flipkart actor on the Store. No tiered pricing, no per-record-type splits.
- ⚡ **Fast.** Concurrent fetching with auto-route proxy: 5 URLs in ~15 s, 50 URLs in under a minute.
- 📦 **Failed rows don't get billed.** Block, 404, or parse failure? You get an error row in your dataset (so you know which URL) but only pay for the products you actually got.
- 🔑 **FSN + listingId on every row** — Flipkart's canonical product key (`MOBGTAGPTB3VS24W`) and seller-listing key (`LST…`) surfaced as their own fields. No other Flipkart scraper exposes them.
- 🎯 **35+ fields per product**, including rating breakdown bucketed 1–5 stars, highlights, specifications, bank/EMI/exchange offers, F-Assured, FBF, GST-invoice and COD booleans.
- 🌐 **HTTP-only, JSON-API path** — talks directly to Flipkart's mobile JSON API instead of scraping HTML, so payloads are 85% smaller than full PDP scrapes. No Playwright, no browser.
- 🛡️ **Auto-routed proxy.** Picks the cheapest proxy group your Apify plan exposes (datacenter on most plans) and falls back to residential only if datacenter is blocked. Flaky URLs come back as error rows instead of crashing the run.
- 🧯 **Strict input validation.** Non-Flipkart URLs are rejected at the gateway with a clear error — no surprise charges on a copy-paste mistake.

---

### What data can you extract?

<table>
<tr>
<td>💰 <b>Selling price</b></td>
<td>📜 <b>MRP</b></td>
<td>🏷️ <b>Discount %</b></td>
<td>🆔 <b>FSN (product ID)</b></td>
</tr>
<tr>
<td>📖 <b>Title</b></td>
<td>🏢 <b>Brand</b></td>
<td>📂 <b>Category tree</b></td>
<td>📝 <b>Description</b></td>
</tr>
<tr>
<td>⭐ <b>Rating</b></td>
<td>🔢 <b>Rating count</b></td>
<td>📊 <b>1–5 star breakdown</b></td>
<td>💬 <b>Review count</b></td>
</tr>
<tr>
<td>✨ <b>Highlights</b></td>
<td>📋 <b>Specifications</b></td>
<td>📅 <b>Warranty summary</b></td>
<td>🖼️ <b>Images & videos</b></td>
</tr>
<tr>
<td>💳 <b>Bank offers</b></td>
<td>📅 <b>EMI offers</b></td>
<td>🔄 <b>Exchange offers</b></td>
<td>🏦 <b>GST-invoice flag</b></td>
</tr>
<tr>
<td>📦 <b>Stock status</b></td>
<td>🚚 <b>COD available</b></td>
<td>🛡️ <b>F-Assured</b></td>
<td>📮 <b>Listing ID (lid)</b></td>
</tr>
</table>

---

### How to scrape Flipkart: step by step

1. Sign up — [free Apify account](https://console.apify.com/sign-up). Takes 30 seconds, no card needed.
2. Open [Flipkart Product Scraper](https://console.apify.com/actors/vldITUrP3GuzAvaQv?addFromActorId=vldITUrP3GuzAvaQv) in the Apify Console.
3. Paste Flipkart product URLs (the `/p/itm…` form, copied straight from the address bar).
4. Click **Start**. A 5-URL run finishes in ~15 seconds; a 50-URL run finishes in under a minute.
5. Export as JSON, CSV, or Excel — or fetch via the [Apify API](https://docs.apify.com/api/v2).

---

### How much does Flipkart Product Scraper cost?

Pay-per-result. **$1.00 for 1,000 successful product extractions**, plus a $0.005 actor-start fee per run (half a cent — negligible unless you do thousands of single-URL runs).

The Apify Free plan gives you $5 per month in usage credits, enough for around **5,000 products**. The $29/month Starter plan covers about **29,000 products**. Failed and blocked rows go to your dataset for visibility but are not billed.

No subscription lock-in. Pause whenever.

---

### Input

```json
{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4",
    "https://www.flipkart.com/samsung-galaxy-s23-5g-phantom-black-128-gb/p/itm1f3efe01d1c61"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8
}
````

| Field | Type | Default | Note |
|---|---|---|---|
| `productUrls` | `string[]` | required | Each item must match the `/p/itm…` pattern. Non-matching URLs are rejected at the gateway with a clear error. |
| `proxyConfiguration` | `object` | `{useApifyProxy: true}` | Leave the groups list empty (the default) and Apify routes you to the cheapest proxy group your plan exposes — datacenter on most plans, residential as fallback. To force residential explicitly, set `apifyProxyGroups: ["RESIDENTIAL"]`. Don't restrict country to IN — Flipkart blocks India-residential desktop traffic. |
| `maxConcurrency` | `integer` | 8 | Upper bound on parallel fetches (1–15). The default works well; lower it if you hit block spikes. |

***

### Output

One row per URL. Successful rows have ~35 populated fields; rows for blocked/failed URLs return `{url, error, statusCode, scrapedAt}` so you can retry them without re-scraping the whole batch.

```json
{
  "url": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4",
  "fsn": "MOBGTAGPTB3VS24W",
  "listingId": "LSTMOBGTAGPTB3VS24WKFODHL",
  "title": "Apple iPhone 15 (Black, 128 GB)",
  "description": "Buy Apple iPhone 15 online at best price with offers in India...",
  "brand": "APPLE",
  "category": "mobile",
  "subCategory": "Handset",
  "superCategory": "Mobile",
  "vertical": "Handset",
  "price": 54900,
  "mrp": 59900,
  "discountPercent": 8,
  "currency": "INR",
  "rating": 4.6,
  "ratingCount": 245114,
  "reviewCount": 9194,
  "ratingBreakdown": { "1": 10940, "2": 3637, "3": 7392, "4": 32216, "5": 190929 },
  "highlights": [
    "Store upto 3000 photos",
    "128 GB ROM",
    "A16 Bionic Chip, 6 Core Processor | Hexa Core",
    "DSLR Like Pictures & Great Zoom"
  ],
  "specifications": [
    { "key": "RAM | ROM", "value": "128 GB ROM" },
    { "key": "Processor", "value": "A16 Bionic Chip, 6 Core Processor | Hexa Core" },
    { "key": "Display", "value": "6.1 inch All Screen OLED Display" }
  ],
  "warrantySummary": "1 year warranty for phone and 1 year warranty for in Box Accessories.",
  "inStock": true,
  "availabilityStatus": "IN_STOCK",
  "isAssured": true,
  "isFulfilledByFlipkart": true,
  "isGstBillingAvailable": true,
  "codAvailable": false,
  "marketPlace": "FLIPKART",
  "offers": [
    { "type": "Bank Offer", "title": "Flipkart Axis Credit Card: ₹3,220 off" },
    { "type": "Bank Offer", "title": "Flipkart SBI Credit Card: ₹2,745 off" }
  ],
  "images": [
    "https://rukmini1.flixcart.com/image/1500/1500/xif0q/mobile/h/d/9/-original-imagtc2qzgnnuhxh.jpeg?q=70"
  ],
  "videos": ["YOUTUBE:jFQjXIK0nIA"],
  "scrapedAt": "2026-05-08T15:36:45.002Z"
}
```

(Trimmed for readability. A real iPhone PDP returns 5–10 spec entries, ~14 offers, ~9 images. Spec depth varies by category — see Limitations.)

***

### Use cases

- 📊 **Price monitoring** — Track selling price, MRP, and discount changes for products you care about. Schedule daily and feed Google Sheets or your BI tool.
- 🥇 **Competitor benchmarking** — Compare your products against competitors on price, rating distribution, F-Assured status, and offer mix.
- 💳 **Bank-offer aggregation** — Capture every HDFC, ICICI, Axis, SBI bank offer plus EMI plans and exchange offers per product, structured.
- 🛒 **Catalog enrichment** — Pull title, brand, full specifications, highlights, and warranty for an SKU list.
- 📈 **Sale-event tracking** — Snapshot pricing before, during, and after Big Billion Days; diff the rows to see which categories actually moved.
- 🏷️ **MAP enforcement** — Watch your brand's listings for unauthorized discounts.
- 🤖 **AI/RAG knowledge bases** — Pipe product specs and rating signals into a vector store for product-Q\&A bots.

***

### Limitations

- **Spec depth varies by category.** The actor talks to Flipkart's mobile JSON API, which exposes different spec shapes per category. Laptops and watches return the full attribute table (50–60 rows for laptops, 5–10 for watches). Mobiles, TVs, large appliances, mixers, and similar return only the 5–7 "key spec" highlights that show on the buy box. Description text is also category-dependent: present for laptops/watches, absent for mobiles/TVs/appliances.
- **Seller name needs a pincode.** Flipkart withholds the real seller name and rating on no-pincode requests. v1 returns `null` for `seller.*`. Multi-pincode delivery checks (and seller resolution) are coming in v2.
- **Public PDP data only.** No seller-portal, B2B-Trade, or Flipkart Plus member-only fields.
- **Reviews aren't in this actor.** This one returns rating *counts* and the 1–5 star breakdown, but not individual review text. Use a dedicated Flipkart reviews scraper for that.

***

### FAQ

#### How much does Flipkart Product Scraper cost?

Flipkart Product Scraper uses pay-per-result pricing. You pay **$1.00 for 1,000 products**, plus $0.005 per actor start. The Apify Free plan gives you $5 in usage credits a month, enough for around 5,000 products. If you run regularly, the $29/month Starter plan covers about 29,000 products.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Flipkart?

Scraping public data is generally allowed in the US, EU, and India, as long as you don't collect personal data covered by GDPR / CCPA / DPDPA without a lawful basis. This actor only touches publicly accessible product pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate Flipkart Product Scraper with other tools?

Yes. Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use Flipkart Product Scraper with the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~flipkart-product-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productUrls": ["https://www.flipkart.com/.../p/itm…"]}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use Flipkart Product Scraper through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call this scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

***

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/vldITUrP3GuzAvaQv/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

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

Array of Flipkart product detail URLs. Each must match the /p/itm… pattern.

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

Apify proxy settings. Leave blank (default) to use the cheapest group your plan exposes — paid plans get DATACENTER, free plans get the shared-DC BUYPROXIES\* group, in both cases at near-zero proxy cost. Pick RESIDENTIAL explicitly only if your account has DC restrictions and DC routing fails. Do NOT restrict country to IN — Flipkart aggressively blocks India-residential desktop traffic.

## `maxConcurrency` (type: `integer`):

Upper bound on concurrent product fetches. Apify's autoscaled pool ramps from 1 up to this limit based on actor pod load. Lower this if you hit block spikes; raise it (up to 15) if your proxy plan can absorb more parallel residential sessions.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 8
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset of product rows; failed/blocked URLs are pushed as error rows alongside successful products.

# 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 = {
    "productUrls": [
        "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/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 = {
    "productUrls": ["https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/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 '{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call sourabhbgp/flipkart-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Product Scraper",
        "description": "Scrape any Flipkart product page for price, MRP, discount, full specifications, rating breakdown, and bank/EMI/exchange offers — plus F-Assured, GST, and COD flags. Paste up to 50 URLs and get clean rows in under a minute. $1 per 1,000 successful products.",
        "version": "0.0",
        "x-build-id": "s3S6kebflZjcftJrY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~flipkart-product-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-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/sourabhbgp~flipkart-product-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-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/sourabhbgp~flipkart-product-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-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",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Flipkart product URLs",
                        "minItems": 1,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Array of Flipkart product detail URLs. Each must match the /p/itm… pattern.",
                        "items": {
                            "type": "string",
                            "pattern": "^https?://(www\\.)?flipkart\\.com/.+/p/itm[a-z0-9]+"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Leave blank (default) to use the cheapest group your plan exposes — paid plans get DATACENTER, free plans get the shared-DC BUYPROXIES* group, in both cases at near-zero proxy cost. Pick RESIDENTIAL explicitly only if your account has DC restrictions and DC routing fails. Do NOT restrict country to IN — Flipkart aggressively blocks India-residential desktop traffic.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Upper bound on concurrent product fetches. Apify's autoscaled pool ramps from 1 up to this limit based on actor pod load. Lower this if you hit block spikes; raise it (up to 15) if your proxy plan can absorb more parallel residential sessions.",
                        "default": 8
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
