# Myntra Fashion Catalog Finder by Category & Brand (`dataspryva/myntra-fashion-catalog-finder-by-category`) Actor

Search Myntra's fashion catalog by keyword, category, or brand, or fetch specific products, for MRP, price, discount, ratings, sizes, colors, and category detail.

- **URL**: https://apify.com/dataspryva/myntra-fashion-catalog-finder-by-category.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

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/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 Fashion Catalog & Review Scraper

Scrape **Myntra** fashion listings and product pages for pricing, discounts, coupons, sellers, size-level stock, specifications, and written reviews. Start from a keyword search, a category, a brand, a listing URL, or a list of product IDs, then export clean records that are ready for pricing research, catalog monitoring, or review analysis.

### What this actor does

- **Five input modes:** keyword search, category browse, brand browse, listing/product URLs, and numeric product IDs
- **Multiple inputs per run:** several queries, categories, brands, URLs, or IDs are fetched in one job and deduplicated by product
- **Real pagination:** walks past the first listing page and splits large searches by gender, price band, and sort order
- **Server-side filters:** gender, sort order, and price range are applied by Myntra before records are collected; discount, rating, and name keywords are checked on each record
- **Full product enrichment:** sellers and addresses, per-size stock and garment measurements, specifications, rating breakdown, return/COD policies, videos, tags, and coupons
- **Optional review rows:** written reviews with rating, text, size bought, photos, votes, and dates
- **Empty fields are omitted** — records never contain `null`, `""`, `[]`, or `{}`

### Output per product

Product rows have `recordType: "product"`.

- `productId`, `productName`, `brand`, `additionalInfo`
- `currency` — always `INR`
- `mrp`, `price`, `discountAmount`, `discountPercent`, `discountDisplayLabel`
- `couponCode`, `couponDiscount`, `priceWithCoupon`, `couponValidUntil`
- `rating`, `ratingCount`, `reviewsCount`, `reviewCount`, `ratingDistribution`
- `primaryColour`, `baseColour`, `gender`, `season`, `year`
- `sizes[]`, `availableSizes[]`, `sizeOptions[]` — per-size SKU, availability, stock, price, sellers, and measurements
- `hasMultipleSizes`, `inStock`, `totalStock`, `colourVariantImages[]`, `colours[]`, `relatedColoursCount`
- `sellerId`, `sellerName`, `sellerCity`, `sellerState`, `sellers[]` — partner ID, name, display name, and full address
- `description`, `materialCare`, `sizeFit`, `manufacturer`, `countryOfOrigin`
- `specifications` — garment attributes such as fabric, fit, pattern, sleeve, occasion, and wash care
- `tags[]`, `offers[]`, `videoUrls[]`, `brandLogoUrl`
- `imageUrl`, `imageUrls[]`
- `category`, `subCategory`, `masterCategory`, `categoryPath`, `listedAt`
- `isReturnable`, `isExchangeable`, `codAvailable`, `returnDays`, `tryAndBuy`
- `productUrl`, `sourceUrl`, `query`, `sourceKind`, `detailsFetched`, `position`, `scrapedAt`

### Output per review

Review rows have `recordType: "review"` and are saved only when `includeReviews` is enabled.

- `reviewId`, `productId`, `reviewedProductId`
- `rating`, `text`, `sizeBought`
- `images[]`, `videoUrl`
- `upvotes`, `downvotes`
- `reviewerName`, `reviewedAt`
- `productName`, `brand`, `productUrl`, `sourceUrl`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `browseByCategory` / `browseByBrand` / `byUrl` / `byProductIds` |
| `searchQueries` | array | `[]` | Keyword searches (mode=search) |
| `categories` | array | `[]` | Category listings (mode=browseByCategory) |
| `brands` | array | `[]` | Brand listings (mode=browseByBrand) |
| `startUrls` | array | `[]` | Myntra listing or product URLs (mode=byUrl) |
| `productIds` | array | `[]` | Numeric IDs or product URLs (mode=byProductIds) |
| `gender` | string | `""` | `""` / `men` / `women` / `boys` / `girls` |
| `sortBy` | string | `""` | Default relevance, newest, popularity, price, discount, or rating |
| `minPrice` | integer | `0` | Minimum selling price in INR; 0 means any |
| `maxPrice` | integer | `0` | Maximum selling price in INR; 0 means any |
| `minDiscount` | integer | `0` | Minimum discount percentage; 0 means any |
| `minRating` | number | `0` | Minimum product rating; products without a rating are excluded when set |
| `containsKeyword` | string | `""` | Keep only product names containing this text |
| `includeDetails` | boolean | `true` | Add sellers, stock, specifications, policies, media, and tags |
| `includeReviews` | boolean | `false` | Emit written-review rows |
| `maxReviewsPerProduct` | integer | `20` | Review rows per product when reviews are enabled |
| `maxItems` | integer | `100` | Total product rows across all inputs (1–10000) |
| `splitLargeSearches` | boolean | `true` | Split large searches by gender, price, and sort for more depth |
| `proxyConfiguration` | object | `{}` | Optional override; leave untouched for automatic connection selection |

### Examples

#### Example: keyword search with filters

```json
{
  "mode": "search",
  "searchQueries": ["running shoes", "polo tshirts"],
  "gender": "men",
  "minPrice": 500,
  "maxPrice": 3000,
  "minDiscount": 30,
  "sortBy": "price_asc",
  "maxItems": 200
}
```

#### Example: category and brand browse

```json
{
  "mode": "browseByCategory",
  "categories": ["sneakers", "watches"],
  "gender": "women",
  "includeDetails": true,
  "maxItems": 150
}
```

#### Example: product URLs and IDs with reviews

```json
{
  "mode": "byUrl",
  "startUrls": [
    "https://www.myntra.com/tshirts/puma/puma-unisex-train-all-day-essentials-slim-fit-drycell-polo-sports-t-shirt/36674095/buy",
    "36674095"
  ],
  "includeReviews": true,
  "maxReviewsPerProduct": 40,
  "maxItems": 20
}
```

#### Example: deep export from a listing URL

```json
{
  "mode": "byUrl",
  "startUrls": [
    "https://www.myntra.com/kurtas?f=Gender%3Amen%2Cwomen"
  ],
  "splitLargeSearches": true,
  "sortBy": "popularity",
  "maxItems": 1000
}
```

### Use cases

- **Price and discount monitoring** — track selling price, MRP, coupon price, and discount depth across a catalog
- **Seller intelligence** — see which seller owns the buy box, its location, and its stock position
- **Catalog enrichment** — add fabric, fit, pattern, occasion, and garment measurements to an internal product feed
- **Review analysis** — export ratings, review text, size feedback, photos, and helpfulness votes
- **Assortment research** — compare brands and categories by price band, rating, and available sizes
- **Stock and variant tracking** — monitor per-size availability and total inventory for key styles

### FAQ

#### Is any login or API key required?

No. The actor reads publicly available Myntra catalog pages and does not need cookies, accounts, or API keys.

#### Do I need to set up a proxy?

No. The actor selects a working connection to Myntra automatically, starting with the cheapest path and escalating only when needed.

#### Why do I get fewer products than I requested?

Myntra limits how deep a single listing can be paged. Enable `splitLargeSearches` to partition a large request by gender, price band, and sort order; the actor then removes duplicates. Extremely broad categories can still have practical limits.

#### Why are some fields missing on some products?

Fields are omitted when Myntra does not publish them for that product. For example, some listings have no rating yet, some have no video, and some have no coupon.

#### What is the difference between `price` and `priceWithCoupon`?

`price` is the current selling price. `priceWithCoupon` is the best price after applying the displayed coupon, and `couponCode` contains that coupon's code.

#### What does `detailsFetched` mean?

It is `true` when the product page was opened successfully and the detail fields came from that page. Listing-only modes can still return a product row without it if a detail page is temporarily unavailable.

#### Why do review rows not count toward `maxItems`?

`maxItems` controls product rows. Review rows are additional records so that enabling reviews does not reduce the number of products you receive.

#### Are the images and videos permanent?

The actor returns the media URLs published by Myntra. They are public links, but Myntra may change or remove media over time.

#### Is this affiliated with Myntra?

No. This is an independent third-party actor that reads publicly available catalog pages.

# Actor input Schema

## `mode` (type: `string`):

What to fetch. Each mode has its own input list below.

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

One or more keyword searches (mode=search), e.g. `tshirts`, `printed kurtas`, `nike running shoes`. Each query is fetched separately and duplicates are removed.

## `categories` (type: `array`):

One or more category listings (mode=browseByCategory).

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

One or more brands to browse (mode=browseByBrand), e.g. `nike`, `levis`, `tommy hilfiger`. Spaces and punctuation are normalized automatically.

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

Myntra listing, search, category, brand, or product URLs (mode=byUrl). Product URLs are fetched as products; everything else is fetched as a listing.

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

Numeric Myntra product IDs or product URLs (mode=byProductIds), e.g. `36674095`.

## `gender` (type: `string`):

Restrict listing results to one gender segment. Applied on Myntra's side.

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

How Myntra orders listing results.

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

Only products whose selling price is at least this amount. 0 means no minimum.

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

Only products whose selling price is at most this amount. 0 means no maximum.

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

Only products discounted by at least this percentage. 0 means no minimum.

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

Only products rated at least this value (0-5). Products without a rating are excluded when this is above 0.

## `containsKeyword` (type: `string`):

Only products whose name contains this keyword (case-insensitive). Leave empty for all products.

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

Open each product page to add sellers, addresses, per-size stock and measurements, specifications, rating breakdown, policies, videos, and tags. Slower but much richer. URL and product-ID modes always fetch details.

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

Emit one row per written review with recordType `review`, in addition to product rows.

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

Review rows to fetch for each product when written reviews are enabled (1-2000).

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

Total product rows to save across all queries, categories, brands, and URLs (1-10000). Review rows are additional.

## `splitLargeSearches` (type: `boolean`):

Go past the per-filter result cap by fetching gender, price-band, and sort slices, then removing duplicates. Recommended for deep exports.

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

Optional override. Leave untouched and the actor selects a working connection automatically.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "tshirts"
  ],
  "categories": [],
  "brands": [],
  "startUrls": [],
  "productIds": [],
  "gender": "",
  "sortBy": "",
  "minPrice": 0,
  "maxPrice": 0,
  "minDiscount": 0,
  "minRating": 0,
  "containsKeyword": "",
  "includeDetails": true,
  "includeReviews": false,
  "maxReviewsPerProduct": 1,
  "maxItems": 2,
  "splitLargeSearches": false,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `products` (type: `string`):

Dataset containing scraped Myntra products and written reviews, separated by recordType.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "tshirts"
    ],
    "categories": [],
    "brands": [],
    "startUrls": [],
    "productIds": [],
    "gender": "",
    "sortBy": "",
    "minPrice": 0,
    "maxPrice": 0,
    "minDiscount": 0,
    "minRating": 0,
    "containsKeyword": "",
    "includeDetails": true,
    "includeReviews": false,
    "maxReviewsPerProduct": 1,
    "maxItems": 2,
    "splitLargeSearches": false,
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/myntra-fashion-catalog-finder-by-category").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 = {
    "mode": "search",
    "searchQueries": ["tshirts"],
    "categories": [],
    "brands": [],
    "startUrls": [],
    "productIds": [],
    "gender": "",
    "sortBy": "",
    "minPrice": 0,
    "maxPrice": 0,
    "minDiscount": 0,
    "minRating": 0,
    "containsKeyword": "",
    "includeDetails": True,
    "includeReviews": False,
    "maxReviewsPerProduct": 1,
    "maxItems": 2,
    "splitLargeSearches": False,
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/myntra-fashion-catalog-finder-by-category").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 '{
  "mode": "search",
  "searchQueries": [
    "tshirts"
  ],
  "categories": [],
  "brands": [],
  "startUrls": [],
  "productIds": [],
  "gender": "",
  "sortBy": "",
  "minPrice": 0,
  "maxPrice": 0,
  "minDiscount": 0,
  "minRating": 0,
  "containsKeyword": "",
  "includeDetails": true,
  "includeReviews": false,
  "maxReviewsPerProduct": 1,
  "maxItems": 2,
  "splitLargeSearches": false,
  "proxyConfiguration": {}
}' |
apify call dataspryva/myntra-fashion-catalog-finder-by-category --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/myntra-fashion-catalog-finder-by-category"
        }
    }
}
```

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/VF1ZCnsosUQJo2e7b/builds/1mGy2E6jqPmXqgRby/openapi.json