# Myntra Scraper: Fashion Products, Prices, Sizes (`automation_craft/myntra-scraper`) Actor

Myntra scraper, no login: products from search words, categories, brand pages, links or style ids, deep category walks. Price, MRP, discount, rating, sizes, buy box stock and coupon; add stock per size and seller, reviews and pincode delivery. JSON, CSV, Excel, API, schedules; pay per product.

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

## Pricing

from $0.76 / 1,000 products

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### Myntra Scraper: Fashion Products, Prices, Sizes

**Myntra scraper** for India's fashion store: products from search words, category pages, brand pages, product links or style ids, with price, MRP, discount, rating, every size, the buy box size with its stock count and seller, coupon and best price. No login and no Myntra account: nothing from you but the input. Add the full product record (stock per size and per seller, every seller), written reviews, delivery to a pincode, or a monitor that keeps only new products or watches prices and stock.

### Quick start

1. Open the Actor's **Input** tab. The prefilled input reads the first ten products of a "kurta" search.
2. Replace the words in **Search words**, or paste **Myntra links** (a category, brand, search or product page), **Style ids**, or pick a **Category**.
3. Narrow it if you like: **Gender**, **Brands**, **Colours**, **Sizes**, price range, **Minimum discount**, **Minimum rating** and Myntra's **Sort** orders.
4. Turn on the add-ons you need: **Product details**, **Reviews**, a **Delivery pincode**.
5. Set **Max products per search** (the form starts at 10; 100 when left empty, up to 500,000) and click **Start**.
6. Download the dataset as JSON, CSV, Excel or HTML, or read it through the Apify API. The **Products**, **Reviews** and **Price and stock watch** views show the columns of each kind of row; to keep one kind only, filter on the `type` field.

### What you get

Every product row (`type: "product"`) is one Myntra style, charged as one Product event. Review rows (`type: "review"`) come only when you turn reviews on, and watch rows (`type: "product_check"`) only under a monitor in `changes` mode. Each search, category or listing link also gets one free `coverage` row (Myntra's total, pages read, products delivered, repeats, filtered, and why the walk stopped), and every run ends with a free `summary` row, also stored as `RUN-SUMMARY` in the run's key-value store.

#### Main fields and measured fill rates

Measured on the platform on 2026-10-20 over 1,195 product rows from six runs of the live matrix on this Actor (build 0.1.4; the code that builds a row is unchanged since): a 1,000 product "saree" walk, two pages of the men-tshirts category, a "sneakers" search with sponsored products, a filtered "kurta" search, the prefilled input and an empty input. Field names are exactly what the dataset holds.

| Field | What it holds | Filled (measured) |
|---|---|---|
| `productId`, `url`, `name`, `brand` | Myntra's style id, the product link, name and brand | 100 percent |
| `price`, `mrp`, `discount`, `discountPercent` | Selling price and MRP in rupees, the discount in rupees and in percent | 100 percent |
| `inStock`, `sizes` | In stock or not, and every size Myntra lists for the style | 100 percent |
| `buyBoxSize` | The size Myntra's buy button sells first, with its `skuId`, `stock` count and `available` flag | 100 percent, stock count included |
| `buyBoxSellerPartnerId` | The seller of that buy box | 100 percent |
| `colour`, `gender`, `category`, `images`, `catalogDate` | Colour, gender, article type, image links, the date Myntra catalogued the style | 100 percent |
| `season` | Myntra's season label | 99.7 percent |
| `tags` | Myntra's product labels ("Deal of the Day", "Price Crash", "Bestseller in ATG") | 93.6 percent |
| `couponCode`, `bestPriceWithCoupon` | The coupon Myntra shows and the price with it (also `couponDiscount`, `couponEndsAt`) | 84.4 percent |
| `ratingCount` | Number of ratings | 100 percent (0 when unrated) |
| `rating` | Average stars | 66.9 percent (Myntra shows no rating on new products) |
| `colourVariantIds` | Style ids of the other colours of the same product | 62.3 percent |
| `deliveryPromise`, `deliveryDate`, `expressDelivery` | Myntra's delivery promise for your pincode | 0 without a pincode; with one, the rows Myntra sends a promise for (26 of 50 kurta rows with 560001 in the research, 1 of 5 sneakers rows with 110001 in the matrix) |
| `brandLogo` | The brand's logo image | 36.0 percent |
| `serviceableSizes` | Sizes Myntra marks serviceable | 0 of 1,195 (Myntra sends it empty on search rows) |
| `videos` | Product video links | 0 of 1,195 |
| `futureDiscountedPrice` | A coming price Myntra announces | 0 of 1,195 |
| `isSponsored`, `sponsoredRank`, `adSlotType`, `adCampaignId` | Sponsored flag, order among the sponsored tiles, Myntra's ad slot (`TOP_OF_SEARCH` or `SEARCH`) and campaign id | sponsored rows only, with **Include sponsored products** |
| `position`, `page`, `pagePosition` | Place among the organic results, the results page, and the tile's place on that page as Myntra lays it out (sponsored tiles counted, banners not) | `page` and `pagePosition` on every search row (`pagePosition` when Myntra sends its page layout), `position` on organic rows (98.8 percent of the 1,195, the rest sponsored) |
| `source` | Which input found the row: kind, input position, search words or page name | every row |

Also on every row: `discountLabel`, `currency` (`INR`), `subCategory`, `masterCategory`, `year`, `futureDiscountStartsAt`, `scrapedAt`.

#### Example row (real, trimmed)

The first product of the prefilled "kurta" search, read on the platform on 2026-10-20 (run 1Rk6hZUss8hlbFdui, build 0.1.5):

```json
{
  "type": "product",
  "productId": "34718633",
  "url": "https://www.myntra.com/Kurtas/Sangria/Sangria-Boys-Abstract-Printed-Mandarin-Collar-Cotton-Straight-Kurta/34718633/buy",
  "name": "Sangria Boys Abstract Printed Mandarin Collar Cotton Straight Kurta",
  "brand": "Sangria",
  "price": 589,
  "mrp": 2999,
  "discount": 2410,
  "discountPercent": 80,
  "discountLabel": "(80% OFF)",
  "currency": "INR",
  "rating": 4.43,
  "ratingCount": 1210,
  "inStock": true,
  "sizes": ["1-2Y", "2-3Y", "3-4Y", "4-5Y", "5-6Y", "6-7Y", "7-8Y", "8-9Y"],
  "buyBoxSize": { "label": "8-9Y", "skuId": "111642195", "stock": 10011, "available": true },
  "buyBoxSellerPartnerId": "23128",
  "colour": "Blue",
  "colourVariantIds": ["32597461", "36802245"],
  "gender": "Boys",
  "category": "Kurtas",
  "subCategory": "Topwear",
  "masterCategory": "Apparel",
  "images": ["http://assets.myntassets.com/assets/images/2025/JUNE/4/g16xuxwY_53af57508f4f4c8b9bf3aa26aa7829f5.jpg", "..."],
  "couponCode": "BFF50OFF",
  "couponDiscount": 150,
  "bestPriceWithCoupon": 439,
  "couponEndsAt": "2026-10-25T18:29:00.000Z",
  "tags": ["New Buyers Choice", "Reviews with Images", "House of Brands"],
  "catalogDate": "2025-05-29T00:00:00.000Z",
  "season": "Summer",
  "year": "2025",
  "isSponsored": false,
  "adSlotType": null,
  "adCampaignId": null,
  "position": 1,
  "page": 1,
  "pagePosition": 1,
  "source": { "kind": "search", "input": "searchTerms 1", "searchWords": "kurta", "slug": "kurta" },
  "scrapedAt": "2026-10-20T08:30:51.358Z"
}
```

#### Speed and depth

A 1,000 product search walk took 21 to 110 seconds on the platform at 256 MB (the India evening is the slow end). Myntra pages its results with a cursor that the Actor chains from page to page, 100 products a page: the men-tshirts category was walked to 10,000 products over 101 pages in 11 minutes, and a probe walked it on to 260 pages (25,783 distinct products of 457,071 listed) with more pages still announced: no cap was met, so one walk goes as deep as the run's memory allows (about 235,000 products at 256 MB, 434,000 at 512 MB). A long walk reads about 15 products a second: raise the run's timeout for one. Myntra refuses the platform's own addresses, so every call goes through the Apify proxy: datacenter sessions first, residential India after them.

### Product details (add-on)

Turn on **Product details** and each product row gets its full record nested as `details` (one Product detail event per row that carries it):

- `sizes`: every size with its `skuId`, `available`, `stock`, garment `measurements` and, per seller, `price`, `mrp`, `stock`, `sellableStock`, `supplyType` and `procurementDays`; plus `totalStock`.
- `sellers` (with `sellerCount`): every seller's name, display name and full address.
- `ratingHistogram` (1 to 5 stars), `reviewCount`, `reviewImageCount`, `colourSiblings`, `attributes` (fabric, fit, pattern and the rest Myntra lists), `description`, `materialAndCare`, `sizeAndFit`, `manufacturer`, `importer`, `countryOfOrigin`, `returnPeriodDays`, `returnable`, `exchangeable`, `cashOnDeliveryEnabled`, `tryAndBuy`, `bankOffers`, `discountEndsAt`, `sizeChartImage`, and `coupons` (the best coupon and the list for the buy box seller).

Stock per size and per seller and the seller names were present on every product that has a seller (30 of 31 products read in the research probe; an old sold out style has none), and the star breakdown on 27 of 31. With details on, the row's price, MRP, discount, stock and rating come from the record, which is newer than the search row, and every filter is checked again on them (a product that no longer passes is free). A record that could not be read is not charged (`detailsStatus` says why). A record whose offers or delivery to your pincode could not be read is still delivered, free, with `detailsStatus: "partial"` and `detailsMissing` naming the part.

### Reviews (add-on)

Turn on **Reviews** and each product gets its written reviews as rows of their own (one Review event each): `reviewId`, `productId`, `reviewedProductId`, `rating`, `text`, `sizeBought`, `images`, `videoCount`, `upvotes`, `downvotes`, `reviewerName`, `reviewedAt`. Choose newest first (default) or most helpful first, all stars or one star value, and up to 2,000 reviews a product (20 by default). Myntra pools reviews across the colour versions of a product, so `reviewedProductId` names the colour that was reviewed. The product row says how many came (`reviewsDelivered`) and whether they were read (`reviewsStatus`); a product whose reviews run past the 200 review pages one product reads (4,000 reviews, only reached when a monitor already knows most of them) is marked `partial` with `reviewsLeftOut: "review_page_bound"`.

### Delivery to a pincode

Give an Indian **Delivery pincode** (six digits). Search, category and listing rows then carry Myntra's `deliveryPromise`, `deliveryDate` and `expressDelivery` for it (measured: 26 of 50 rows of a kurta search with 560001 in the research, 1 of 5 rows of a sneakers search with 110001 in the platform matrix: Myntra sends a promise for some rows only). With **Product details** on, `details.pincodeDelivery` says whether the product can be delivered there, whether cash on delivery is offered, and for every size and seller whether it is deliverable and with which payment modes. The pincode itself is free.

### Monitor: new products only, or a price and stock watch

Set **Monitor name** and schedule the run. The Actor remembers what it delivered under that name in a key-value store it creates itself.

- **`new_only` (default)**: searches, categories, links and style ids deliver and charge only products, and reviews, not delivered before under this name. Known products are skipped before anything is read for them, free.
- **`changes`**: for product links and style ids only. Every watched product is read each run and delivered as one `product_check` row: `price`, `mrp`, `discountPercent`, `inStock`, `totalStock`, every size with its availability, stock and price, `changeType` (`baseline` the first time, then `changed` or `unchanged`) and `changes` (each with `field`, `from` and `to` for price, MRP and total stock, and a `sizes` entry when any size's availability, stock or seller price moved). Each row is one Product check event, the first run included. Give searches and categories their own `new_only` run.
- **Reset the monitor** forgets the memory and starts again.

### How much does it cost to scrape Myntra?

You pay per event, per 1,000 events, by your Apify plan:

| Event | What it is | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|---|
| Product (primary) | One Myntra product row | $1.06 | $0.97 | $0.88 | $0.76 |
| Product detail | The full record of one delivered product (add-on) | $1.95 | $1.90 | $1.85 | $1.75 |
| Review | One written review row (add-on) | $0.95 | $0.70 | $0.48 | $0.45 |
| Product check | One watched product read again by a `changes` monitor | $0.90 | $0.85 | $0.80 | $0.70 |

Platinum and Diamond plans pay the Gold price. The Actor start is $0.006 per run, flat on every plan, with no discount; it is charged per GB of run memory, and this Actor runs at 256 MB by default and at most 512 MB, so a run pays it once.

The Store pricing card shows these same prices per 1,000 events: "$0.76 / 1,000" on the Product row means one product costs $0.00076, less than a tenth of a cent.

#### Worked examples (GOLD)

- **1,000 products from one search**: 1,000 x $0.00076 = $0.76, plus the $0.006 start = **$0.766** (on the FREE plan: $1.06 + $0.006 = $1.066).
- **100 products with Product details and 20 reviews each**: 100 x $0.00076 = $0.076, plus 100 x $0.00175 = $0.175, plus 2,000 x $0.00045 = $0.90, plus the $0.006 start = **$1.157**.
- **A daily price and stock watch of 200 product links**: 200 x $0.0007 = $0.14, plus the $0.006 start = **$0.146** a run.

#### What is free

Style ids Myntra does not have, searches Myntra rewrote into something else, typed or pasted as a search link (unless you turn on **Take Myntra's results for words it rewrote**), a search page on which Myntra did not apply a filter that was sent (the search stops there), products left out by your filters, products found twice in a run, products and reviews a `new_only` monitor delivered before, pages read only to reach the start page, failed calls, product records that could not be read, partial product records, and every `status`, `coverage` and `summary` row. If you set a maximum charge for the run, add-on rows are cut first and the run stops before it passes the limit.

### Input

An input that names nothing to read runs the sample: the first ten products of a "kurta" search.

#### What to read

- `searchTerms`: search words, one search per entry (up to 200), each up to 100 characters.
- `startUrls`: myntra.com links (up to 1,000): a category, brand or search page (its filters, price range, sort and page are kept unless you set your own) or a product page (`https://www.myntra.com/18389666` or the long `.../18389666/buy` form).
- `productIds`: style ids, the number in a product link (up to 5,000).
- `category`: one of 40 common category pages (men-tshirts, sarees, women-kurtas-kurtis-suits, lipstick and more); any other category page can be pasted as a link.

#### Filters

`genders` (men, women, boys, girls, unisex), `brands`, `colours`, `sizes` (several values each, as Myntra writes them), `minPrice` and `maxPrice` in rupees, `minDiscount` (1 to 90 percent), `minRating` (0 to 5, applied to every row; a search stops after three pages in a row without a match), `sort` (relevance, new, popularity, price_low_to_high, price_high_to_low, discount, customer_rating), `includeSponsored` (sponsored products flagged with their slot, each checked against every filter) and `includeRewrittenSearches`. Myntra applies the filters itself and the Actor checks that Myntra's answer confirms each one, price and discount ranges with their bounds (where it does not, the search stops there and that page is free). Brand, colour, gender, price, discount and rating are also checked on every row, a pasted link's own filters included; sponsored rows are checked on their sizes too, and are left out when a link carries a filter no row field shows (fabric, for example). They apply to searches, categories and listing links; product links and style ids are read as given.

#### Limits

`maxItemsPerSearch` (1 to 500,000, default 100), `maxItems` (the whole run, up to 500,000), `startPage` (1 to 20, Myntra's own pages of 50 products: page 3 starts at product 101, as on myntra.com; a link's `p` reads the same way) and `maxPagesPerSearch` (1 to 5,000, counted from the start page; pages of 100 products, or of the per search cap when it is smaller, and Myntra's pages of 50 when a start page is set). Turn on `expandSubcategories` to read a search, category or listing one subcategory at a time: the Actor reads Myntra's own list of the categories under it (for men-clothing, 69 of them from Blazers to Track Pants, with their counts) and walks each as its own search, with its own coverage row and its own `maxItemsPerSearch`; a free note row lists the subcategories and counts, and names any products Myntra counts under none of them (for men-clothing 7 of 1,411,766 on 2026-10-20), which the split does not read. When the listed counts fall more than 0.1 percent short of the total, the search is read whole instead. Without `maxPagesPerSearch` a search reads at most 5,000 pages; a search that still has more is reported partial in its coverage row. A very large run (hundreds of thousands of products or reviews in one run) keeps every product and review it met in memory to never deliver one twice; before its memory fills it stops cleanly (`memory_bound`, with its coverage and summary rows). A 256 MB run holds about 235,000 products or 470,000 reviews; a 512 MB run about 434,000 products or 868,000 reviews. For a large category give the run 512 MB; a category larger than that (men-tshirts lists about 457,000) is read across runs, by subcategory or price range.

#### Add-ons

`includeDetails`, `includeReviews`, `maxReviewsPerProduct` (1 to 2,000, default 20), `reviewsSort` (`newest` or `helpful`), `reviewsRating` (`all` or 1 to 5), `pincode`.

#### Monitor

`monitorName`, `monitorMode` (`new_only` or `changes`), `resetMonitor`.

#### Run

`maxRequestRetries` (1 to 5, default 3), `requestTimeoutSecs` (5 to 60, default 15; a proxy session that runs into it, or answers two calls slower than 8 seconds, is replaced by a fresh one), `requestDelayMs` (a pause before every request to Myntra, 0 to 10,000 milliseconds, default none), `maxCallsPerSession` (move to a fresh proxy session after that many requests, 1 to 1,000; left empty, a session is kept while Myntra answers it, the cheapest and fastest way), `proxyConfiguration` (default: Apify datacenter sessions on networks Myntra lets in, then residential India only when those are spent; Apify proxy groups picked here are not used, and the run says so in a note; your own proxy links are used as given; a run with every proxy turned off is refused, because Myntra refuses the platform's own addresses).

#### Examples

A category with filters, cheapest first:

```json
{ "category": "women-kurtas-kurtis-suits", "brands": ["Libas", "Anouk"], "minPrice": 500, "maxPrice": 2000, "minDiscount": 30, "sort": "price_low_to_high", "maxItemsPerSearch": 500 }
```

Style ids with details, reviews and a pincode:

```json
{ "productIds": ["18389666"], "includeDetails": true, "includeReviews": true, "maxReviewsPerProduct": 100, "pincode": "560001" }
```

A daily price and stock watch:

```json
{ "productIds": ["18389666", "41666539"], "monitorName": "my-watchlist", "monitorMode": "changes" }
```

### Use it from the API

Each call runs the Actor and returns its dataset (product rows plus the free coverage and summary rows; filter on `type`). The synchronous endpoint waits up to 300 seconds, so keep these runs small or start a normal run for large ones. Replace `<YOUR_API_TOKEN>` with your Apify API token.

#### curl

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~myntra-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["levis jeans"], "maxItemsPerSearch": 50}'
```

#### Node.js

```js
const res = await fetch('https://api.apify.com/v2/acts/automation_craft~myntra-scraper/run-sync-get-dataset-items', {
    method: 'POST',
    headers: { Authorization: 'Bearer <YOUR_API_TOKEN>', 'Content-Type': 'application/json' },
    body: JSON.stringify({ startUrls: [{ url: 'https://www.myntra.com/roadster' }], maxItemsPerSearch: 50 }),
});
const rows = await res.json();
const products = rows.filter((row) => row.type === 'product');
console.log(products.length, products[0]?.price);
```

#### Python

```python
import requests

rows = requests.post(
    "https://api.apify.com/v2/acts/automation_craft~myntra-scraper/run-sync-get-dataset-items",
    headers={"Authorization": "Bearer <YOUR_API_TOKEN>"},
    json={"searchTerms": ["red saree"], "minDiscount": 40, "maxItemsPerSearch": 50},
    timeout=320,
).json()
products = [row for row in rows if row["type"] == "product"]
print(len(products))
```

### Use it from AI agents (MCP)

An AI agent connected to the Apify MCP server can call this Actor by its name, `automation_craft/myntra-scraper`, with the same input JSON as above. The dataset's field descriptions and views tell the agent what each column holds, and the free coverage row tells it what was read and why each search stopped.

### FAQ

#### Can you scrape Myntra product variants like sizes and colors?

Yes. Every product row lists all its sizes, the buy box size with its stock count, its colour and the style ids of its other colours (`colourVariantIds`). **Product details** adds every size with its stock and price per seller, its garment measurements, and each colour sibling with its colour, link and image.

#### Why are there different prices for the same product on Myntra?

One style can be sold by several sellers, and each size and seller can carry its own price and stock. **Product details** shows exactly that: per size, every seller's price, MRP and stock, next to the buy box price on the row.

#### Can you monitor Myntra discounts and price changes?

Yes. Put the products in **Style ids** or **Myntra links**, set a **Monitor name** with mode `changes` and schedule the run: each run delivers one row per product with its price, MRP, stock per size and what changed since the last run, with the old and new values. For a search or category, mode `new_only` delivers only products not seen before.

#### How to search Myntra price history?

Myntra shows only today's price. A scheduled `changes` monitor builds the history from its own runs: every run's rows keep the price, MRP and stock of that day, and `changes` gives the previous value. History starts with the first run of the monitor.

#### Is scraping Myntra data legal?

This Actor reads only what myntra.com shows a logged out visitor: no login, no account, no cart or checkout. Review rows carry the reviewer's name as Myntra shows it, which is personal data. Whether your use is lawful depends on your purpose, your country and Myntra's terms of use, so check them for your case.

#### Why does this Actor run with limited permissions?

It follows least privilege: it only writes its own run's dataset and key-value store. A monitor's memory is a named key-value store the Actor creates itself under your account.

### What this Actor does not do

- **No price slices**: it does not split a category into price ranges, because none are needed: it walks Myntra's own paging cursor, on which no result cap was met (a probe walked men-tshirts 260 pages deep, 25,783 products, with more announced), so one walk goes as deep as the run's memory allows (about 235,000 products at 256 MB, 434,000 at 512 MB); for a larger category, or to cut it into parts, use the subcategory split or the price filters.
- **No login data**: no account, wishlist, order, cart or checkout data, and no seller dashboard data. Prices are those myntra.com shows a logged out visitor at read time; some coupons are for new buyers only.
- **No size recommendation**: Myntra answers it with HTTP 503 to a logged out visitor.
- **No product videos on most rows**: the `videos` field was empty on 1,195 of 1,195 measured rows.
- **No price history before your first run**: history comes only from the runs of a monitor.
- **No "similar products" or "frequently bought together" lists.**

### Changelog

See the Changelog tab. 0.1 (2026-10-15): first release.

### More data tools by Automation Craft

- [Amazon Product Scraper - Search, Best Sellers](https://apify.com/automation_craft/amazon-data-scraper)
- [Amazon Sponsored Products Scraper - Ads by Keyword](https://apify.com/automation_craft/amazon-sponsored-products-scraper)
- [Zalando Ads Library Scraper - Sponsored Products](https://apify.com/automation_craft/zalando-ads-library-scraper)
- [Mercari US Scraper: Listings, Sold Prices](https://apify.com/automation_craft/mercari-us-scraper)
- [Facebook Marketplace Scraper with Sold Tracker](https://apify.com/automation_craft/facebook-marketplace-scraper)
- [ShopBack Scraper: Cashback, Gift Cards, Affiliates](https://apify.com/automation_craft/affiliate-network-detector)

# Changelog

This Actor's version history is a separate document: https://apify.com/automation_craft/myntra-scraper/changelog.md

# Actor input Schema

## `searchTerms` (type: `array`):

Words to search on Myntra, one search per entry (kurta, levis jeans, red saree). Each search delivers up to Max products per search. When Myntra does not recognise the words and shows something else instead (a misspelt or made up word), that search delivers nothing and is not charged; a free status row says how Myntra read it.

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

Links copied from myntra.com: a category, brand or search page (https://www.myntra.com/men-tshirts, https://www.myntra.com/roadster, https://www.myntra.com/kurta?rawQuery=kurta; its filters, price range and sort are kept unless you set your own below) or a product page (https://www.myntra.com/18389666 or the long .../18389666/buy form).

## `productIds` (type: `array`):

Myntra style ids (the number in a product link, as in myntra.com/18389666). Each is read from its product record. An id Myntra does not have gets a free status row.

## `category` (type: `string`):

One common category page to read whole (any other category page can be pasted as a link above).

## `expandSubcategories` (type: `boolean`):

Read each search, category or listing link one subcategory at a time: the Actor reads Myntra's own list of the categories under it (T-shirts, Shirts, Jeans ... with their counts) and walks each one as its own search, with its own coverage row and its own Max products per search. Every row still carries its category, sub category and master category.

## `genders` (type: `array`):

Only products for these groups. Several values match any of them.

## `brands` (type: `array`):

Only these brands, written as Myntra lists them (Roadster, Libas, Levis). Several brands match any of them.

## `colours` (type: `array`):

Only these colours as Myntra names them (Black, Navy Blue, Off White). Several colours match any of them.

## `sizes` (type: `array`):

Only products offered in these sizes as Myntra writes them (S, M, XL, 32, 8-9Y).

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

Only products priced at or above this many rupees.

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

Only products priced at or below this many rupees.

## `minDiscount` (type: `integer`):

Only products discounted by at least this percent (1 to 90).

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

Only products rated at or above this many stars (0 to 5). Products without a rating are left out. Myntra has no such filter, so it is applied to every row; a search stops after three pages in a row without a match (sort by customer rating to reach rated products first).

## `sort` (type: `string`):

Myntra's order: relevance (its default), new arrivals, popularity, price low to high, price high to low, discount or customer rating.

## `includeSponsored` (type: `boolean`):

Also deliver the sponsored products Myntra mixes into a search page, flagged isSponsored with their ad slot and campaign id. Each sponsored product is checked against every filter above. (Every search row says where its tile sits on the page, pagePosition, with or without this switch.)

## `includeRewrittenSearches` (type: `boolean`):

By default a search Myntra did not recognise (it rewrote the words or showed products that do not name them), typed or pasted as a search link, delivers nothing and is free. Turn this on to deliver and pay for Myntra's results anyway.

## `maxItemsPerSearch` (type: `integer`):

The most products one search, category or listing link delivers (1 to 500,000: a whole category, men-tshirts lists about 457,000; a 256 MB run holds about 235,000 products in all and stops cleanly past that, a 512 MB run about twice). The form starts at 10 for a quick first run; left empty (or through the API without it) the default is 100. A long walk reads about 15 products a second, so raise the run's timeout for one.

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

The most products the whole run delivers (searches are read in order). Leave empty for no total cap.

## `startPage` (type: `integer`):

Start each search at this page of Myntra's results (1 to 20), Myntra's own pages of 50 products as on myntra.com: page 3 starts at product 101. Myntra pages with a cursor, so the pages before it are read to reach it; they are not delivered and not charged.

## `maxPagesPerSearch` (type: `integer`):

The most result pages one search, category or listing link reads, counted from the start page (1 to 5,000; 100 products a page, or the per search cap when it is smaller, and Myntra's pages of 50 when a start page is set). Left empty, a search reads up to 5,000 pages, and one that still has more is marked partial in its coverage row.

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

Add each product's full record (the Product detail event): every size with its stock count and price per seller, every seller with name and address, the star breakdown, colour versions, attributes, description, material and care, size and fit, manufacturer, importer, country of origin, return period, cash on delivery, bank offers and the coupons of the buy box seller. A record whose offers or pincode delivery could not be read is delivered free, marked partial.

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

Add each product's written reviews as rows of their own (the Review event): rating, text, size bought, photos, votes, reviewer name and date. Myntra pools reviews across the colour versions of a product.

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

The most reviews delivered per product (1 to 2,000). Default 20.

## `reviewsSort` (type: `string`):

newest (default) or helpful (Myntra's most helpful first).

## `reviewsRating` (type: `string`):

all (default), or only reviews with this many stars.

## `pincode` (type: `string`):

An Indian pincode (six digits, 560001). Search rows then carry Myntra's delivery promise and express tag for it, and Product details carry whether each size can be delivered there and with which payment modes (cash on delivery included).

## `monitorName` (type: `string`):

A name for a memory this Actor keeps between runs (one per name, per Actor). With it, a scheduled run delivers and charges only products (and reviews) it has not delivered before (mode new_only), or watches product links and style ids for price and stock changes (mode changes).

## `monitorMode` (type: `string`):

new_only (default): only products and reviews not delivered before under this name. changes: every product link or style id is read each run and delivered as one Product check row saying what changed since the last run (price, MRP, stock, sizes).

## `resetMonitor` (type: `boolean`):

Forget what the monitor delivered before and start again from this run.

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

How often a call Myntra did not answer is asked again (1 to 5, default 3). A refused proxy session is replaced at once and does not count.

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

How long one call to Myntra may take before it is asked again on a fresh proxy session (5 to 60, default 15). A session that runs into it, or answers two calls slower than 8 seconds, is replaced.

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

Wait this long before every request to Myntra (0 to 10,000 milliseconds, default none). The pause is run time, so a long pause on a large run makes it slower and uses more of its unpaid work allowance.

## `maxCallsPerSession` (type: `integer`):

Move to a fresh proxy session after this many requests to Myntra (1 to 1,000; the page load that sets Myntra's anonymous token counts as one). Left empty, the Actor keeps a session while Myntra answers it and moves on only when it is refused or slow, which is the cheapest and fastest. Each fresh datacenter session is checked before use, so a small value spends more of the run's unpaid work allowance.

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

Myntra refuses the platform's own addresses, so every call goes through a proxy. Default: Apify datacenter sessions on networks Myntra lets in (a session Myntra refuses is replaced), and Apify residential India only when those are spent. Apify proxy groups you pick here are not used (the Actor picks its own and says so); your own proxy links are used as given.

## Actor input object example

```json
{
  "searchTerms": [
    "kurta"
  ],
  "expandSubcategories": false,
  "includeSponsored": false,
  "includeRewrittenSearches": false,
  "maxItemsPerSearch": 10,
  "includeDetails": false,
  "includeReviews": false,
  "resetMonitor": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `items` (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 = {
    "searchTerms": [
        "kurta"
    ],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/myntra-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 = {
    "searchTerms": ["kurta"],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation_craft/myntra-scraper").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 '{
  "searchTerms": [
    "kurta"
  ],
  "maxItemsPerSearch": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation_craft/myntra-scraper --silent --output-dataset

```

## MCP server setup

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

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/3G8msaLDTP5ihTng0/builds/6zjMXA6yelwoMsrMV/openapi.json