# Flipkart Products Scraper — No Login Required (`crowdpull/flipkart-products-scraper`) Actor

Extract product listings from Flipkart search, category, and product pages. No login or cookies needed. Supports search queries, category URLs, product URLs, filters, optional detail and review enrichment, image URL resolution, Smart Scrape, and diagnostics.

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

## Pricing

from $2.20 / 1,000 product listing extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Products Scraper

Extract Flipkart product records from search queries, search/category URLs, and direct product URLs. No login or cookies needed.

This actor follows the Browse.sh Flipkart skill path: fetch the server-rendered search or product page, parse `window.__INITIAL_STATE__`, and extract product cards from `PRODUCT_SUMMARY` widgets. Search-card mode is the default because it is faster and cheaper than browser automation and already contains price, MRP, discount, rating, review count, key specs, images, product IDs, listing IDs, and product URLs.

### Features

- Search query mode using `https://www.flipkart.com/search?q=...`
- Search/category URL mode that preserves existing Flipkart URL filters
- Direct product URL mode for `/p/itm...` pages
- Pagination, sort controls, max item limits, and request retries
- Post-filters for minimum price, maximum price, minimum rating, and sponsored-only exclusion
- Optional product detail enrichment for best-effort full specs, description, warranty, seller, offers, and rating histogram
- Optional bounded review samples from Flipkart product-review pages, including reviewer, rating, title, text, certified-buyer flag, helpful count, media, and rating summary
- Optional sellers comparison fetch with explicit `ok`, `no_data`, or `failed` status when Flipkart exposes or withholds seller records in server-rendered state
- Resolved Flipkart CDN image URLs from templated `{@width}` / `{@height}` / `{@quality}` URLs
- Review and sellers comparison URLs generated for downstream review/seller workflows
- Run-level duplicate suppression
- Smart Scrape mode to emit only new or changed products on scheduled runs
- Run artifacts in key-value store: `SUMMARY`, `SEARCH_SPECS`, and `FAILED_TARGETS`
- Optional debug HTML capture for blocked or malformed Flipkart responses

### Example Input

```json
{
  "searchQueries": ["laptop", "iphone 15"],
  "sortBy": "popularity",
  "maxItemsPerInput": 50,
  "maxPagesPerInput": 3,
  "minRating": 4,
  "includeDetails": false,
  "includeReviews": false,
  "includeSellers": false,
  "onlyNew": false,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Category URL Example

```json
{
  "startUrls": [
    {
      "url": "https://www.flipkart.com/search?q=running%20shoes&sort=price_asc"
    }
  ],
  "maxItemsPerInput": 100,
  "organicOnly": true
}
```

### Smart Scrape

Set `onlyNew` to `true` and keep the same `cacheName` for scheduled monitoring. The actor stores a material hash for each product/listing and only emits rows that are new or meaningfully changed.

```json
{
  "searchQueries": ["gaming laptop"],
  "maxItemsPerInput": 100,
  "onlyNew": true,
  "cacheName": "flipkart-gaming-laptop-monitor"
}
```

### Output

Each dataset item is a normalized Flipkart product row:

```json
{
  "type": "product",
  "source": "flipkart",
  "status": "ok",
  "mode": "search",
  "query": "laptop",
  "page": 1,
  "sortBy": "popularity",
  "productId": "COMGZUYDFZXHWYWZ",
  "listingId": "LSTCOMGZUYDFZXHWYWZJ6V2KW",
  "url": "https://www.flipkart.com/samsung-galaxy-book4-.../p/itm...?pid=COMGZUYDFZXHWYWZ",
  "reviewUrl": "https://www.flipkart.com/samsung-galaxy-book4-.../product-reviews/itm...?pid=COMGZUYDFZXHWYWZ",
  "sellersUrl": "https://www.flipkart.com/sellers?pid=COMGZUYDFZXHWYWZ",
  "brand": "SAMSUNG",
  "title": "Samsung Galaxy Book4 Metal Intel Core i5...",
  "subtitle": "15.6 Inch, Gray, 1.55 Kg, With MS Office",
  "sellingPriceInr": 56990,
  "mrpInr": 78189,
  "discountPercent": 27,
  "currency": "INR",
  "rating": 4.4,
  "ratingBase": 5,
  "ratingCount": 18987,
  "reviewCount": 1791,
  "keySpecs": ["Intel Core i5 Processor", "8 GB RAM", "512 GB SSD"],
  "primaryImageUrl": "https://rukminim2.flixcart.com/image/416/416/...",
  "imageUrls": ["https://rukminim2.flixcart.com/image/416/416/..."],
  "isSponsored": false,
  "detailStatus": "not_requested",
  "reviewStatus": "not_requested",
  "sellerStatus": "not_requested",
  "scrapedAt": "2026-06-02T00:00:00.000Z"
}
```

### Pricing Status

Pricing is not applied yet. Private hosted Apify validation is documented in `PRICING_RESEARCH.md`, and the recommended unapplied API payloads are preserved in `pricing-payload.recommended.json` and `publication-payload.recommended.json`. Before publication or PPE pricing, apply those payloads deliberately and run a paid public smoke that confirms charge events and dataset quality.

Expected event shape after validation:

- `apify-actor-start`: low one-time start event
- `product-listing`: primary event for each search/category/product row emitted
- `item-detail`: optional event for each successfully detail-enriched product
- `product-review`: optional event for each attached review sample
- `seller-offer`: optional event for each attached seller offer record

### Limitations

- Flipkart may return a reCAPTCHA shell instead of the SSR payload. The actor records this as a failed target and can save debug HTML when `saveDebugHtml` is enabled.
- Local non-proxy requests are likely to be blocked. Hosted validation should test residential proxy settings before parser changes.
- Product detail extraction is best-effort because Flipkart product-page `__INITIAL_STATE__` layouts vary by vertical.
- Review extraction is a bounded product-row add-on, not a standalone high-volume review actor replacement.
- Sellers comparison extraction is best-effort. Some Flipkart sellers pages return an initialized SSR reducer without seller records; these rows report `sellerStatus: "no_data"` instead of fabricating seller offers.
- AI custom-field extraction and AI product-quality scoring are intentionally out of scope for the first low-memory HTTP actor.

# Actor input Schema

## `searchQueries` (type: `array`):

Plain-text Flipkart search terms. Each query is issued as https://www.flipkart.com/search?q=...

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

Optional Flipkart search, category, browse, or product URLs. Existing URL filters are preserved where possible.

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

Direct Flipkart product URLs in the /p/itm... form. These are fetched as detail targets.

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

Flipkart search sort order. Relevance leaves the sort parameter unset.

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

Only emit products with selling price at or above this value.

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

Only emit products with selling price at or below this value.

## `minRating` (type: `number`):

Only emit products with an average rating at or above this value.

## `organicOnly` (type: `boolean`):

Skip sponsored/ad placements when Flipkart marks ad metadata in the search payload.

## `maxItemsPerInput` (type: `integer`):

Maximum product rows to emit per search query, search/category URL, or direct product URL group.

## `maxPagesPerInput` (type: `integer`):

Maximum Flipkart result pages to fetch for each search or category target.

## `includeDetails` (type: `boolean`):

Fetch product detail pages to add best-effort full specifications, description, seller, warranty, and offer fields. Search-card mode is faster and cheaper.

## `includeReviews` (type: `boolean`):

Fetch Flipkart product-review pages and attach bounded review samples with reviewer, rating, title, text, certified-buyer flag, helpful count, media, and rating histogram where available.

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

Maximum review records to attach to each product when Include Review Samples is enabled.

## `maxReviewPagesPerProduct` (type: `integer`):

Maximum Flipkart review pages to fetch per product. Review pages usually contain about 10 reviews.

## `reviewSortBy` (type: `string`):

Sort order for review page requests when Include Review Samples is enabled.

## `includeSellers` (type: `boolean`):

Fetch Flipkart's sellers comparison page for each product and attach seller offer records when Flipkart exposes them in server-rendered state. Rows report no\_data when the sellers page has no SSR seller records.

## `maxSellersPerProduct` (type: `integer`):

Maximum seller offer records to attach to each product when Include Seller Comparison is enabled.

## `resolveImageUrls` (type: `boolean`):

Replace Flipkart CDN placeholders such as {@width}, {@height}, and {@quality} with concrete image dimensions.

## `onlyNew` (type: `boolean`):

Emit only products that are new or materially changed since the last run with the same cacheName.

## `cacheName` (type: `string`):

Named key-value store used by onlyNew mode. Keep this stable for scheduled monitoring.

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

Upper bound on concurrent product detail fetches when includeDetails is enabled.

## `requestDelayMs` (type: `integer`):

Base delay between search/category page requests in milliseconds.

## `requestTimeoutMs` (type: `integer`):

Maximum time to wait for each Flipkart HTML request before retrying or recording a failed optional enrichment.

## `maxRequestRetries` (type: `integer`):

Retry blocked, empty, or malformed pages with a fresh proxy session.

## `saveDebugHtml` (type: `boolean`):

Save failed or blocked HTML responses into the default key-value store.

## `proxyConfig` (type: `object`):

Residential proxies are strongly recommended for Flipkart. Leave country unset first; add country IN only if your hosted smoke proves it improves availability.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "startUrls": [
    {
      "url": "https://www.flipkart.com/search?q=iphone%2015&sort=popularity"
    }
  ],
  "sortBy": "relevance",
  "organicOnly": false,
  "maxItemsPerInput": 50,
  "maxPagesPerInput": 3,
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerProduct": 5,
  "maxReviewPagesPerProduct": 1,
  "reviewSortBy": "MOST_HELPFUL",
  "includeSellers": false,
  "maxSellersPerProduct": 5,
  "resolveImageUrls": true,
  "onlyNew": false,
  "cacheName": "flipkart-products-scraper-cache",
  "maxConcurrency": 4,
  "requestDelayMs": 750,
  "requestTimeoutMs": 20000,
  "maxRequestRetries": 3,
  "saveDebugHtml": false,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `searchSpecs` (type: `string`):

No description

## `failedTargets` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "laptop"
    ],
    "startUrls": [
        {
            "url": "https://www.flipkart.com/search?q=iphone%2015&sort=popularity"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crowdpull/flipkart-products-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 = {
    "searchQueries": ["laptop"],
    "startUrls": [{ "url": "https://www.flipkart.com/search?q=iphone%2015&sort=popularity" }],
}

# Run the Actor and wait for it to finish
run = client.actor("crowdpull/flipkart-products-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 '{
  "searchQueries": [
    "laptop"
  ],
  "startUrls": [
    {
      "url": "https://www.flipkart.com/search?q=iphone%2015&sort=popularity"
    }
  ]
}' |
apify call crowdpull/flipkart-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Flipkart Products Scraper — No Login Required",
        "description": "Extract product listings from Flipkart search, category, and product pages. No login or cookies needed. Supports search queries, category URLs, product URLs, filters, optional detail and review enrichment, image URL resolution, Smart Scrape, and diagnostics.",
        "version": "0.1",
        "x-build-id": "kcedBcy0u9iWwkYFV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crowdpull~flipkart-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crowdpull-flipkart-products-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/crowdpull~flipkart-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crowdpull-flipkart-products-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/crowdpull~flipkart-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crowdpull-flipkart-products-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": {
                    "searchQueries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Plain-text Flipkart search terms. Each query is issued as https://www.flipkart.com/search?q=...",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Flipkart Search or Category URLs",
                        "type": "array",
                        "description": "Optional Flipkart search, category, browse, or product URLs. Existing URL filters are preserved where possible.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL",
                                    "description": "Flipkart search, category, browse, or product detail URL."
                                }
                            }
                        }
                    },
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Direct Flipkart product URLs in the /p/itm... form. These are fetched as detail targets.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "popularity",
                            "price_asc",
                            "price_desc",
                            "recency_desc"
                        ],
                        "type": "string",
                        "description": "Flipkart search sort order. Relevance leaves the sort parameter unset.",
                        "default": "relevance"
                    },
                    "minPrice": {
                        "title": "Minimum Price INR",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only emit products with selling price at or above this value."
                    },
                    "maxPrice": {
                        "title": "Maximum Price INR",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only emit products with selling price at or below this value."
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only emit products with an average rating at or above this value."
                    },
                    "organicOnly": {
                        "title": "Organic Results Only",
                        "type": "boolean",
                        "description": "Skip sponsored/ad placements when Flipkart marks ad metadata in the search payload.",
                        "default": false
                    },
                    "maxItemsPerInput": {
                        "title": "Max Items Per Input",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum product rows to emit per search query, search/category URL, or direct product URL group.",
                        "default": 50
                    },
                    "maxPagesPerInput": {
                        "title": "Max Pages Per Search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum Flipkart result pages to fetch for each search or category target.",
                        "default": 3
                    },
                    "includeDetails": {
                        "title": "Include Product Details",
                        "type": "boolean",
                        "description": "Fetch product detail pages to add best-effort full specifications, description, seller, warranty, and offer fields. Search-card mode is faster and cheaper.",
                        "default": false
                    },
                    "includeReviews": {
                        "title": "Include Review Samples",
                        "type": "boolean",
                        "description": "Fetch Flipkart product-review pages and attach bounded review samples with reviewer, rating, title, text, certified-buyer flag, helpful count, media, and rating histogram where available.",
                        "default": false
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews Per Product",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum review records to attach to each product when Include Review Samples is enabled.",
                        "default": 5
                    },
                    "maxReviewPagesPerProduct": {
                        "title": "Max Review Pages Per Product",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum Flipkart review pages to fetch per product. Review pages usually contain about 10 reviews.",
                        "default": 1
                    },
                    "reviewSortBy": {
                        "title": "Review Sort By",
                        "enum": [
                            "MOST_HELPFUL",
                            "MOST_RECENT",
                            "POSITIVE_FIRST",
                            "NEGATIVE_FIRST"
                        ],
                        "type": "string",
                        "description": "Sort order for review page requests when Include Review Samples is enabled.",
                        "default": "MOST_HELPFUL"
                    },
                    "includeSellers": {
                        "title": "Include Seller Comparison",
                        "type": "boolean",
                        "description": "Fetch Flipkart's sellers comparison page for each product and attach seller offer records when Flipkart exposes them in server-rendered state. Rows report no_data when the sellers page has no SSR seller records.",
                        "default": false
                    },
                    "maxSellersPerProduct": {
                        "title": "Max Sellers Per Product",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum seller offer records to attach to each product when Include Seller Comparison is enabled.",
                        "default": 5
                    },
                    "resolveImageUrls": {
                        "title": "Resolve Image URLs",
                        "type": "boolean",
                        "description": "Replace Flipkart CDN placeholders such as {@width}, {@height}, and {@quality} with concrete image dimensions.",
                        "default": true
                    },
                    "onlyNew": {
                        "title": "Smart Scrape Only New or Changed",
                        "type": "boolean",
                        "description": "Emit only products that are new or materially changed since the last run with the same cacheName.",
                        "default": false
                    },
                    "cacheName": {
                        "title": "Smart Scrape Cache Name",
                        "type": "string",
                        "description": "Named key-value store used by onlyNew mode. Keep this stable for scheduled monitoring.",
                        "default": "flipkart-products-scraper-cache"
                    },
                    "maxConcurrency": {
                        "title": "Max Detail Concurrency",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Upper bound on concurrent product detail fetches when includeDetails is enabled.",
                        "default": 4
                    },
                    "requestDelayMs": {
                        "title": "Delay Between Pages",
                        "minimum": 0,
                        "maximum": 60000,
                        "type": "integer",
                        "description": "Base delay between search/category page requests in milliseconds.",
                        "default": 750
                    },
                    "requestTimeoutMs": {
                        "title": "Request Timeout Ms",
                        "minimum": 5000,
                        "maximum": 45000,
                        "type": "integer",
                        "description": "Maximum time to wait for each Flipkart HTML request before retrying or recording a failed optional enrichment.",
                        "default": 20000
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Retry blocked, empty, or malformed pages with a fresh proxy session.",
                        "default": 3
                    },
                    "saveDebugHtml": {
                        "title": "Save Debug HTML",
                        "type": "boolean",
                        "description": "Save failed or blocked HTML responses into the default key-value store.",
                        "default": false
                    },
                    "proxyConfig": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended for Flipkart. Leave country unset first; add country IN only if your hosted smoke proves it improves availability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
