# Myntra Product Search Scraper (`khadinakbar/myntra-product-search-scraper`) Actor

Search Myntra by keyword or category/search URL and get fashion product cards: brand, product name, price, MRP, discount %, rating, rating count, sizes, colour, gender, category, sponsored flag, image and product URL. Auto-paginated, HTTP-only, MCP-ready.

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

## Pricing

from $3.00 / 1,000 myntra product scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Myntra Product Search Scraper

Search **Myntra** (India's largest fashion store) by keyword or category/search URL and get clean, structured product listing cards — **brand, price, MRP, discount %, rating, sizes, colour, category, image and product URL** — auto-paginated into one dataset. HTTP-only, fast, and **MCP-ready** for AI agents.

### What you get

One record per product, ready for spreadsheets, price monitors, or LLM agents:

| Field | Example | Notes |
|-------|---------|-------|
| `brand` | `Roadster` | Brand name |
| `productName` | `Roadster Oversized T-shirt` | Full title |
| `price` | `251` | Current selling price (INR) |
| `mrp` | `599` | List price / MRP (INR) |
| `discountAmount` | `348` | MRP − price |
| `discountPercent` | `58` | % off MRP |
| `discountLabel` | `58% OFF` | Myntra's label |
| `rating` | `4.13` | Average rating, 0–5 |
| `ratingCount` | `7533` | Number of ratings |
| `gender` | `Women` | Target gender |
| `primaryColour` | `Olive` | Primary colour |
| `category` / `subCategory` / `articleType` / `masterCategory` | `Tshirts` / `Topwear` / `Tshirts` / `Apparel` | Taxonomy |
| `sizes` | `["XS","S","M","L","XL"]` | Available size labels |
| `inStock` | `true` | Any size in stock |
| `colourOptions` | `2` | Colour variants |
| `isSponsored` | `false` | Sponsored / PLA flag |
| `image` | `https://assets.myntassets.com/...jpg` | Product image |
| `productUrl` | `https://www.myntra.com/.../26959458/buy` | Canonical product page |
| `position` | `1` | Rank within the run |
| `scrapedAt` | `2026-06-21T00:40:00.000Z` | ISO 8601 timestamp |

### When to use it

- Competitive **price & discount monitoring** across Myntra catalogs.
- **Assortment / market research** for fashion brands and resellers.
- Feeding **AI shopping agents** (Claude, GPT) a clean keyword → products tool.
- Building dashboards over brand, category, rating and stock.

**Not** for single product-detail pages — this is a search/listing scraper. Product-detail (`/buy`) URLs and non-Myntra URLs are skipped.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `searchQuery` | string | Keyword to search, e.g. `running shoes`, `blue jeans`, `kurta`. |
| `startUrls` | string[] | Myntra search/category URLs, e.g. `https://www.myntra.com/men-tshirts`. Each is paginated independently. |
| `maxResults` | integer | Max products across all searches (default `100`, max `10000`). |
| `sortBy` | enum | `relevance` (default), `new`, `price_asc`, `price_desc`, `discount`, `popularity`. |
| `proxyConfiguration` | object | Defaults to Apify Proxy (datacenter, US). Attach residential if you hit blocks. |

Provide `searchQuery`, `startUrls`, or both.

#### Example input

```json
{
  "searchQuery": "running shoes",
  "maxResults": 100,
  "sortBy": "discount",
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### Category URL example

```json
{
  "startUrls": [
    "https://www.myntra.com/men-tshirts",
    "https://www.myntra.com/women-dresses?sort=new"
  ],
  "maxResults": 200
}
```

### Pricing — pay per result

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| **Product scraped** | **$0.003** |

You are billed only for products actually returned. A typical 100-product run costs about **$0.30**. Products dropped before your `maxResults` cap are never charged. Both pay-per-event and pay-per-usage billing are available.

### How it works

Myntra is protected by **Akamai Bot Manager**. The actor warms up a browser-grade TLS session to obtain a valid sensor cookie, then reads Myntra's gateway search API directly — returning 50 products per page and auto-paginating by offset until your `maxResults` cap. No browser, so runs are fast and cheap. A consistent exit IP is kept per search so the anti-bot cookie stays valid; on a block it rotates the session and retries with backoff. If every request is blocked, the run fails honestly (with `$0` product charges) rather than silently returning an empty dataset.

### Use with AI agents (MCP)

This actor is MCP-ready. Connect it through the Apify MCP server (`https://mcp.apify.com`) and an agent can call it as a tool: pass a `searchQuery`, get back structured product records. Inputs and outputs are described for LLM consumption.

### Reliability notes

- Default proxy is Apify datacenter (US), which clears Myntra's anti-bot in testing. If you run very large or highly concurrent jobs and see blocks, attach residential proxies in `proxyConfiguration`.
- `maxResults` caps spend; deep pagination is bounded for safety.
- Currency is INR (Myntra is an India store).

### Legal

Use this actor responsibly and in compliance with Myntra's Terms of Service and applicable laws. It collects only publicly available listing data and does not access private accounts or bypass authentication. You are responsible for how you use the scraped data, including data-protection and intellectual-property obligations. This actor is not affiliated with, endorsed by, or sponsored by Myntra.

### FAQ

**Does it return more than one page of results?** Yes — it auto-paginates the gateway API (50/page) up to your `maxResults`.

**Can I scrape a specific category?** Yes — pass the category page URL in `startUrls` (e.g. `https://www.myntra.com/women-kurtas`).

**Why are some products sponsored?** Myntra injects PLA (sponsored) cards into results; they're flagged with `isSponsored: true`.

**What currency are prices in?** Indian Rupees (INR).

**Do I pay for blocked runs?** No — if the run can't reach Myntra, it fails honestly with `$0` product charges.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword searched on Myntra, exactly as a shopper would type it (e.g. 'running shoes', 'blue jeans', 'kurta'). Returns fashion product listing cards ranked by the chosen sort. Leave blank if you instead supply 'startUrls'. This is NOT a product-detail URL — for that use a Myntra product scraper.

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

One or more Myntra search or category page URLs to scrape (e.g. 'https://www.myntra.com/men-tshirts' or 'https://www.myntra.com/blue-jeans?rawQuery=blue%20jeans'). Each URL is paginated independently. Product-detail pages ending in '/buy' and non-Myntra URLs are skipped. Use this for category browsing; use 'searchQuery' for a plain keyword.

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

Maximum number of products to return across all searches and URLs combined. Pagination stops once this cap is reached. Defaults to 100; accepts 1 to 10000. You are billed only for products actually returned (one 'product' event each).

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

How Myntra orders the results before scraping. 'relevance' is Myntra's default ranking; 'discount' surfaces the biggest markdowns; 'price\_asc'/'price\_desc' sort by price; 'new' is freshest arrivals; 'popularity' is best-selling. Applies to 'searchQuery'; a 'sort' param inside a startUrl overrides this for that URL.

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

Proxy used for all requests. Defaults to Apify Proxy (datacenter, US). Myntra is protected by Akamai Bot Manager; if runs get blocked, attach residential proxies here. A consistent exit IP is used per search so the anti-bot cookie stays valid.

## Actor input object example

```json
{
  "searchQuery": "blue jeans",
  "startUrls": [
    "https://www.myntra.com/men-tshirts",
    "https://www.myntra.com/women-dresses"
  ],
  "maxResults": 100,
  "sortBy": "relevance",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All product listing records found across the searches and category/search URLs. Download as JSON, CSV, Excel, HTML, or RSS.

# 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 = {
    "searchQuery": "running shoes",
    "maxResults": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/myntra-product-search-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 = {
    "searchQuery": "running shoes",
    "maxResults": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/myntra-product-search-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 '{
  "searchQuery": "running shoes",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/myntra-product-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Myntra Product Search Scraper",
        "description": "Search Myntra by keyword or category/search URL and get fashion product cards: brand, product name, price, MRP, discount %, rating, rating count, sizes, colour, gender, category, sponsored flag, image and product URL. Auto-paginated, HTTP-only, MCP-ready.",
        "version": "1.2",
        "x-build-id": "NL4ULK05NwFDlyyq4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~myntra-product-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-myntra-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~myntra-product-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-myntra-product-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~myntra-product-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-myntra-product-search-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": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "type": "string",
                        "description": "Free-text keyword searched on Myntra, exactly as a shopper would type it (e.g. 'running shoes', 'blue jeans', 'kurta'). Returns fashion product listing cards ranked by the chosen sort. Leave blank if you instead supply 'startUrls'. This is NOT a product-detail URL — for that use a Myntra product scraper."
                    },
                    "startUrls": {
                        "title": "Myntra search / category URLs",
                        "type": "array",
                        "description": "One or more Myntra search or category page URLs to scrape (e.g. 'https://www.myntra.com/men-tshirts' or 'https://www.myntra.com/blue-jeans?rawQuery=blue%20jeans'). Each URL is paginated independently. Product-detail pages ending in '/buy' and non-Myntra URLs are skipped. Use this for category browsing; use 'searchQuery' for a plain keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max products",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of products to return across all searches and URLs combined. Pagination stops once this cap is reached. Defaults to 100; accepts 1 to 10000. You are billed only for products actually returned (one 'product' event each).",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "new",
                            "price_asc",
                            "price_desc",
                            "discount",
                            "popularity"
                        ],
                        "type": "string",
                        "description": "How Myntra orders the results before scraping. 'relevance' is Myntra's default ranking; 'discount' surfaces the biggest markdowns; 'price_asc'/'price_desc' sort by price; 'new' is freshest arrivals; 'popularity' is best-selling. Applies to 'searchQuery'; a 'sort' param inside a startUrl overrides this for that URL.",
                        "default": "relevance"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for all requests. Defaults to Apify Proxy (datacenter, US). Myntra is protected by Akamai Bot Manager; if runs get blocked, attach residential proxies here. A consistent exit IP is used per search so the anti-bot cookie stays valid.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
