# Myntra Listings Extractor (`kawsar/myntra-listings-extractor`) Actor

Myntra Listings Extractor scrapes product listings from Myntra search and category pages, returning brand, price, discount, rating, sizes, and images so you can track pricing, build product feeds, and run market research fast.

- **URL**: https://apify.com/kawsar/myntra-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Listings Extractor

Myntra Listings Extractor pulls product data straight from Myntra's search and category pages. Give it a keyword like `t-shirt` or `nike shoes`, or paste a listing URL, and it returns a clean dataset: brand, current price, MRP, discount, rating, colour, sizes, stock status, and every listing image, one row per product.

No login, no browser extension, no manual copying from the page. Set how many products you want and run it.

### Why use it

Myntra is one of India's largest fashion marketplaces, which makes it a common source for price tracking, catalog building, and competitor research, but the site has no public API and copying listings by hand does not scale past a handful of products. This actor automates that: point it at a search term or category, and it hands back structured data you can filter, sort, or load straight into a spreadsheet, BI tool, or your own database.

### What it does

- Searches Myntra by one or more keywords, or extracts from direct listing and category URLs
- Paginates automatically to reach the number of products you ask for, up to 1,000 per run
- Returns full product details: name, brand, price, MRP, discount amount and label, rating, review count, colour, sizes, category, and stock status
- Collects every listing image plus the direct product page link for each item
- Keeps going if one keyword or URL fails; a failed source gets an error row instead of stopping the whole run
- Exports to JSON, CSV, Excel, or HTML through the Apify dataset, ready for spreadsheets, dashboards, or a database import

### How pagination works

Each keyword or URL you provide is one source. The actor fetches results a page at a time and keeps requesting more pages from that source until one of these happens:

- it has collected your `maxItems` share for that run,
- the listing itself reports there is nothing more to show, or
- several pages in a row return nothing new (the listing has been exhausted)

Products are de-duplicated by their Myntra product ID as they come in, so you will not see the same item twice from a single source. `maxItems` is a shared budget across every keyword and URL in the input, spent in the order they are listed, so put your highest-priority searches first if you are close to the limit.

### Input

You need at least one search keyword or one listing URL. Everything else is optional.

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `search` | array of strings | — | Search terms to look up on Myntra, e.g. `t-shirt`, `nike shoes`, `women kurta`. Each keyword is treated as its own paginated source. |
| `startUrls` | array of strings | — | Direct Myntra search or category page URLs, e.g. a filtered results page copied from your browser's address bar. |
| `maxItems` | integer | 100 | Maximum number of products to extract per run, shared across all keywords and URLs. Max 1,000. |
| `requestTimeoutSecs` | integer | 30 | Per-request timeout in seconds. Max 120. |

#### Example input

```json
{
  "search": ["t-shirt", "running shoes"],
  "startUrls": ["https://www.myntra.com/men-tshirts"],
  "maxItems": 300,
  "requestTimeoutSecs": 30
}
```

This pulls up to 300 products total, split across the two keyword searches and the category URL, in that order.

### Output

Each dataset item is one product. Example:

```json
{
  "productId": 40651844,
  "productName": "Marks & Spencer Pure Cotton Plain T-Shirt",
  "brand": "Marks & Spencer",
  "productUrl": "https://www.myntra.com/tshirts/marks+%26+spencer/marks--spencer-pure-cotton-plain-t-shirt/40651844/buy",
  "price": 679,
  "mrp": 799,
  "discount": "(15% OFF)",
  "discountAmount": 120,
  "rating": 4.375,
  "ratingCount": 48,
  "gender": "Unisex Kids",
  "primaryColour": "Pink",
  "sizes": ["6-7Y", "7-8Y", "9-10Y", "11-12Y", "13-14Y"],
  "category": "Tshirts",
  "articleType": "Tshirts",
  "subCategory": "Topwear",
  "masterCategory": "Apparel",
  "inStock": true,
  "mainImage": "https://assets.myntassets.com/assets/images/2026/MARCH/23/iay9wVp1_156b12bdab4646d283cb09a4442c18ed.jpg",
  "images": [
    "https://assets.myntassets.com/assets/images/2026/MARCH/23/iay9wVp1_156b12bdab4646d283cb09a4442c18ed.jpg",
    "https://assets.myntassets.com/assets/images/2026/MARCH/23/86XmRa6A_f6cb9d0220c44b3e8c9a73302d2d31d7.jpg"
  ],
  "searchQuery": "t-shirt",
  "sourceUrl": "https://www.myntra.com/t-shirt?rawQuery=t-shirt",
  "scrapedAt": "2026-08-15T05:12:25.087500+00:00",
  "error": null
}
```

#### Field reference

| Field | Description |
|-------|-------------|
| `productId` | Myntra's internal product identifier |
| `productName` | Full product name, including brand |
| `brand` | Brand name |
| `productUrl` | Direct link to the product detail page |
| `price` | Current selling price in INR |
| `mrp` | Maximum retail price in INR, before discount |
| `discount` | Discount label as shown on the listing, e.g. `(15% OFF)` |
| `discountAmount` | Absolute discount amount in INR |
| `rating` | Average customer rating out of 5 |
| `ratingCount` | Number of customer ratings |
| `gender` | Target audience, e.g. Men, Women, Unisex Kids |
| `primaryColour` | Primary colour of the product |
| `sizes` | Available sizes |
| `category` / `articleType` / `subCategory` / `masterCategory` | Myntra's category hierarchy for the product |
| `inStock` | `true` if at least one size currently has inventory |
| `mainImage` | Primary listing image URL |
| `images` | All listing image URLs |
| `searchQuery` | The keyword that produced this item, if a keyword was used |
| `sourceUrl` | The listing URL the item was extracted from |
| `scrapedAt` | UTC timestamp of when the item was collected |
| `error` | Populated only on a failed source row; `null` on success |

### Common uses

- **Price and discount tracking** against competitor listings or your own catalog
- **Product feeds** for marketplaces, ads, or a comparison site
- **Stock monitoring** on specific brands, categories, or SKUs
- **Market and SEO research** on Myntra's fashion catalog
- **Image sourcing** for catalog or design reference work

### Performance notes

Run time scales with how many keywords and URLs you provide and how high you set `maxItems`, since each additional page is a separate fetch. A single keyword pulling 100 products typically finishes in well under a minute; requests near the 1,000 item cap across several sources will take longer. If a keyword or URL turns out to have fewer matching products than your limit, the actor recognizes this automatically and moves on rather than retrying indefinitely.

# Actor input Schema

## `search` (type: `array`):

Search terms to look up on Myntra, for example "t-shirt", "nike shoes", or "women kurta". Each keyword returns its matching product listings.

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

Direct Myntra search or category page URLs to extract, for example a filtered results page copied from your browser.

## `maxItems` (type: `integer`):

Maximum number of products to extract per run, shared across all keywords and URLs. Each source is paginated automatically until this many products are collected or that listing runs out of new products.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "search": [
    "t-shirt",
    "running shoes"
  ],
  "startUrls": [
    "https://www.myntra.com/men-tshirts"
  ],
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

## `results` (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 = {
    "search": [
        "t-shirt"
    ],
    "startUrls": [
        "https://www.myntra.com/t-shirt?rawQuery=t-shirt"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/myntra-listings-extractor").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "search": ["t-shirt"],
    "startUrls": ["https://www.myntra.com/t-shirt?rawQuery=t-shirt"],
}

# Run the Actor and wait for it to finish
run = client.actor("kawsar/myntra-listings-extractor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "search": [
    "t-shirt"
  ],
  "startUrls": [
    "https://www.myntra.com/t-shirt?rawQuery=t-shirt"
  ]
}' |
apify call kawsar/myntra-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/myntra-listings-extractor"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jwvfRo2YOpFpKvTl7/builds/738YiowEMBNcjAPi6/openapi.json