# Flipkart Reviews Scraper (`solidcode/flipkart-scraper`) Actor

\[💰 $1.5 / 1K] Extract customer reviews and ratings from any Flipkart product — review text, star rating, reviewer name, certified-buyer status, helpful votes, photos, and date. Filter by rating, sort by most helpful or most recent, and cap reviews per product.

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

## Pricing

from $1.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

## Flipkart Reviews Scraper

Pull customer reviews from any Flipkart product at scale — star ratings, full review text, certified-buyer verification, reviewer photos, helpful/not-helpful vote counts, and reviewer location, all in clean structured rows. Built for product managers, brand analysts, and e-commerce teams who need the unfiltered voice of India's largest online marketplace without copying reviews off the page one at a time.

### Why This Scraper?

- **18 data points on every review** — review text, 1–5 star rating, headline, reviewer name, reviewer location (city + state), certified-buyer flag, helpful and not-helpful vote counts, review date, attached reviewer photos, and direct review URL.
- **Reviewer photos included** — every photo a customer attached to their review is returned as a high-resolution image URL, so you can mine real product-in-use shots, not just text.
- **Certified-buyer verification on every row** — each review carries Flipkart's verified-purchase badge as a true/false field, so you can separate confirmed buyers from the rest in one filter.
- **Four sort orders** — collect reviews as Most Helpful, Most Recent, Positive First, or Negative First to pull exactly the slice you need (top complaints, freshest feedback, or best praise).
- **Star-rating and certified-buyer filters** — narrow a run to only 1, 2, 3, 4, or 5-star reviews (any combination), and optionally keep verified purchasers only.
- **Full review history** — set the cap to 0 and the scraper walks the full review history (up to about 100,000 reviews per product); flagship phones and bestsellers carry 9,000+ reviews and it collects the complete set, deduplicating as it goes.
- **Every review is self-describing** — each row carries its parent product's name, ID, URL, average rating, total rating count, and total review count, so a single spreadsheet needs no joins.
- **Paste product OR review-page URLs** — works with the normal product page (the one with the price and Add to Cart) or the dedicated All Reviews page; no need to hunt down the reviews link first.

### Use Cases

**Product & Market Research**
- Surface the features customers praise and complain about across a product line
- Compare sentiment on your product versus competing listings side by side
- Track how ratings shift after a relaunch, price change, or new variant
- Mine feature requests and recurring pain points straight from buyers

**Brand & Reputation Monitoring**
- Watch new negative reviews on your flagship products as they land
- Quantify the share of 1 and 2-star reviews over time
- Spot quality or counterfeit complaints early through Negative First sorting

**E-commerce & Seller Intelligence**
- Benchmark a catalog of competitor SKUs by average rating and review volume
- Identify high-converting products by review depth and helpful-vote counts
- Gauge demand and satisfaction before sourcing or listing a new product

**Voice-of-Customer & CX Analytics**
- Feed certified-buyer reviews into sentiment and topic-modeling pipelines
- Segment feedback by reviewer location to spot regional satisfaction gaps
- Prioritize support and roadmap work by helpful-vote-weighted complaints

**AI & LLM Training Data**
- Build labeled review datasets with ratings, verified-purchase flags, and vote counts
- Assemble image-plus-text pairs from reviews that include reviewer photos
- Create domain-specific corpora for e-commerce recommendation and summarization models

### Getting Started

#### Scrape a Single Product

Paste a product URL and take the defaults (100 most-helpful reviews):

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

#### Newest Negative Reviews Only

Pull the freshest 1 and 2-star reviews — ideal for catching emerging complaints:

```json
{
    "productUrls": ["https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"],
    "sortBy": "MOST_RECENT",
    "ratingFilter": ["1", "2"],
    "maxReviewsPerProduct": 200
}
```

#### Full Catalog Sweep

Collect every review from several products, verified buyers only, photos included:

```json
{
    "productUrls": [
        "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4",
        "https://www.flipkart.com/samsung-galaxy-s24/p/itm7bd1234567890",
        "https://www.flipkart.com/boat-airdopes-141/product-reviews/itm9ce0987654321"
    ],
    "maxReviewsPerProduct": 0,
    "sortBy": "MOST_HELPFUL",
    "certifiedBuyersOnly": true,
    "includeImages": true
}
```

### Input Reference

#### Products

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `productUrls` | array | `[]` | One or more Flipkart product page or review page URLs. Both the product page (with price and Add to Cart) and the dedicated All Reviews page work. Each URL is processed independently. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviewsPerProduct` | integer | `100` | Maximum reviews to collect per product. Set to `0` to collect every available review. A sensible cap (200–1000) keeps runs fast and predictable. |
| `sortBy` | select | `Most Helpful` | Order reviews are collected in: Most Helpful, Most Recent, Positive First, or Negative First. |
| `ratingFilter` | array | `[]` (all) | Keep only reviews with the chosen star ratings: 5 stars, 4 stars, 3 stars, 2 stars, 1 star. Leave empty to keep every rating. |
| `certifiedBuyersOnly` | boolean | `false` | When on, keep only reviews written by Flipkart Certified Buyers (verified purchasers). |
| `includeImages` | boolean | `true` | Include the URLs of any photos reviewers attached. Turn off for lighter output. |

### Output

Each row is one review, enriched with its parent product's context. Here is a representative result:

```json
{
    "productName": "Apple iPhone 15 (Black, 128 GB)",
    "productId": "MOBGTAGPTB3VS24W",
    "productUrl": "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4",
    "productRating": 4.6,
    "productRatingCount": 184250,
    "productReviewCount": 12480,
    "reviewId": "a1b2c3d4e5f6",
    "rating": 5,
    "title": "Superb camera and battery",
    "reviewText": "Using it for two weeks now. The camera quality is excellent in daylight and the battery easily lasts a full day of heavy use.",
    "author": "Rahul Sharma",
    "reviewLocation": "Pune, Maharashtra",
    "certifiedBuyer": true,
    "helpfulCount": 342,
    "downvoteCount": 18,
    "reviewDate": "Aug, 2024",
    "reviewImages": [
        "https://rukminim2.flixcart.com/image/720/720/review/example.jpg?q=90"
    ],
    "reviewUrl": "https://www.flipkart.com/apple-iphone-15-black-128-gb/product-reviews/itm6ac6485515ae4"
}
```

#### Review Fields

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique review identifier (used for deduplication) |
| `rating` | number | This review's star rating, 1 to 5 |
| `title` | string | Review headline |
| `reviewText` | string | Full review body |
| `author` | string | Reviewer's display name |
| `reviewLocation` | string | Reviewer's city and state, when stated |
| `certifiedBuyer` | boolean | Whether the reviewer is a Flipkart Certified Buyer |
| `helpfulCount` | number | Count of "helpful" upvotes |
| `downvoteCount` | number | Count of "not helpful" downvotes |
| `reviewDate` | string | Review date as shown on Flipkart (e.g. "Aug, 2024") |
| `reviewImages` | array | High-resolution URLs of photos attached to the review |
| `reviewUrl` | string | Direct link to this review |

#### Product Context

Attached to every review row, so each row stands on its own.

| Field | Type | Description |
|-------|------|-------------|
| `productName` | string | Parent product title |
| `productId` | string | Flipkart product identifier |
| `productUrl` | string | Canonical product page URL |
| `productRating` | number | Product's overall average star rating |
| `productRatingCount` | number | Total number of ratings on the product |
| `productReviewCount` | number | Total number of text reviews on the product |

### Tips for Best Results

- **Start with a cap of 50–100** to confirm the data fits your needs, then raise `maxReviewsPerProduct` or set it to `0` for the full history.
- **Set `maxReviewsPerProduct` to 0 for a complete review export** — the scraper paginates to the very last review and deduplicates by review ID, so a bestseller with thousands of reviews comes back complete with no repeats.
- **Pair `ratingFilter` with `sortBy` for sharp slices** — for example, `["1", "2"]` with Most Recent surfaces the newest complaints first; `["5"]` with Most Helpful surfaces your strongest testimonials.
- **Narrow rating filters scan more reviews to reach the cap** — asking for only 1-star reviews means the scraper reads past many higher-rated ones to fill your requested count, so allow a slightly higher cap when filtering tightly.
- **Almost all Flipkart text reviews are already from certified buyers**, so `certifiedBuyersOnly` rarely changes the result set — leave it off unless you specifically need to drop the rare non-certified review.
- **Batch many products in one run** — add every product or review URL to `productUrls`; each is processed independently and every row is tagged with its own product context.
- **Turn off `includeImages`** when you only need text and ratings to keep the output lighter and faster to process.

### Pricing

**From $1.5 per 1,000 results** — one of the most affordable Flipkart review extractors available, and cheaper at every volume than comparable tools. No compute charges — you only pay per result returned. 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.18 | $0.17 | $0.16 | $0.15 |
| 1,000 | $1.80 | $1.70 | $1.60 | $1.50 |
| 10,000 | $18.00 | $17.00 | $16.00 | $15.00 |
| 100,000 | $180.00 | $170.00 | $160.00 | $150.00 |

A "result" is one review row in the output dataset. There are no compute-time charges — you pay only for the reviews returned. Platform fees (storage and data transfer) depend on your Apify plan.

### 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 actor is designed for legitimate product research, market analysis, and customer-experience work. You are responsible for complying with applicable laws and Flipkart's Terms of Service. Treat reviewer names, locations, and photos as personal data: do not use them for spam, harassment, profiling, or any unlawful purpose, and respect data-protection regulations that apply to you.

# Actor input Schema

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

Paste one or more Flipkart product page or review page URLs. Both the product page (the one with a price and 'Add to Cart') and the dedicated 'All Reviews' page work — for example https://www.flipkart.com/apple-iphone-15/p/itm6ac6485515ae4 or its /product-reviews/ link.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to collect for each product. Set to 0 to collect every review on the product (up to a safety ceiling of about 100,000 reviews per product). Popular products can have tens of thousands of reviews, so a sensible cap (for example 200–1000) keeps runs fast and predictable.

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

The order in which reviews are collected from each product.

## `ratingFilter` (type: `array`):

Only collect reviews that have one of these star ratings. Leave empty to collect reviews of every rating. Reviews are scanned in your chosen sort order and only matching ratings are kept, so a narrow filter (for example only 1-star reviews) may need to scan many reviews to reach your requested count.

## `certifiedBuyersOnly` (type: `boolean`):

When enabled, only collect reviews written by Flipkart Certified Buyers (people who actually purchased the product). Reviews are scanned and only those marked as Certified Buyer are kept. Note: on Flipkart almost all text reviews are already from Certified Buyers, so this rarely changes the results. Leave off to include all reviews.

## `includeImages` (type: `boolean`):

Include the URLs of any photos that reviewers attached to their reviews. Turn off to keep the output lighter.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.flipkart.com/apple-iphone-15-black-128-gb/p/itm6ac6485515ae4"
  ],
  "maxReviewsPerProduct": 100,
  "sortBy": "MOST_HELPFUL",
  "ratingFilter": [],
  "certifiedBuyersOnly": false,
  "includeImages": true
}
```

# Actor output Schema

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

Table of scraped reviews with the key fields.

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

Detailed review data including review text, images, and product context.

# 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"
    ],
    "maxReviewsPerProduct": 100,
    "sortBy": "MOST_HELPFUL",
    "ratingFilter": [],
    "certifiedBuyersOnly": false,
    "includeImages": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/flipkart-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"],
    "maxReviewsPerProduct": 100,
    "sortBy": "MOST_HELPFUL",
    "ratingFilter": [],
    "certifiedBuyersOnly": False,
    "includeImages": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/flipkart-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"
  ],
  "maxReviewsPerProduct": 100,
  "sortBy": "MOST_HELPFUL",
  "ratingFilter": [],
  "certifiedBuyersOnly": false,
  "includeImages": true
}' |
apify call solidcode/flipkart-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Reviews Scraper",
        "description": "[💰 $1.5 / 1K] Extract customer reviews and ratings from any Flipkart product — review text, star rating, reviewer name, certified-buyer status, helpful votes, photos, and date. Filter by rating, sort by most helpful or most recent, and cap reviews per product.",
        "version": "1.0",
        "x-build-id": "NwY9w3qA5F3ciwVel"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~flipkart-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-flipkart-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~flipkart-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-flipkart-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~flipkart-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-flipkart-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Paste one or more Flipkart product page or review page URLs. Both the product page (the one with a price and 'Add to Cart') and the dedicated 'All Reviews' page work — for example https://www.flipkart.com/apple-iphone-15/p/itm6ac6485515ae4 or its /product-reviews/ link.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews Per Product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect for each product. Set to 0 to collect every review on the product (up to a safety ceiling of about 100,000 reviews per product). Popular products can have tens of thousands of reviews, so a sensible cap (for example 200–1000) keeps runs fast and predictable.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "MOST_HELPFUL",
                            "MOST_RECENT",
                            "POSITIVE_FIRST",
                            "NEGATIVE_FIRST"
                        ],
                        "type": "string",
                        "description": "The order in which reviews are collected from each product.",
                        "default": "MOST_HELPFUL"
                    },
                    "ratingFilter": {
                        "title": "Star Rating Filter",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect reviews that have one of these star ratings. Leave empty to collect reviews of every rating. Reviews are scanned in your chosen sort order and only matching ratings are kept, so a narrow filter (for example only 1-star reviews) may need to scan many reviews to reach your requested count.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "5",
                                "4",
                                "3",
                                "2",
                                "1"
                            ],
                            "enumTitles": [
                                "5 stars",
                                "4 stars",
                                "3 stars",
                                "2 stars",
                                "1 star"
                            ]
                        },
                        "default": []
                    },
                    "certifiedBuyersOnly": {
                        "title": "Certified Buyers Only",
                        "type": "boolean",
                        "description": "When enabled, only collect reviews written by Flipkart Certified Buyers (people who actually purchased the product). Reviews are scanned and only those marked as Certified Buyer are kept. Note: on Flipkart almost all text reviews are already from Certified Buyers, so this rarely changes the results. Leave off to include all reviews.",
                        "default": false
                    },
                    "includeImages": {
                        "title": "Include Review Images",
                        "type": "boolean",
                        "description": "Include the URLs of any photos that reviewers attached to their reviews. Turn off to keep the output lighter.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
