# Nykaa Scraper: Beauty Products, Prices, Reviews (`automation_craft/nykaa-scraper`) Actor

Scrape Nykaa categories, brand pages, searches or product links with no login. Get price, MRP, discount, rating, stock, offers, every shade with its own price and stock, ingredients and verified reviews. Export JSON, CSV or Excel, schedule a price watch, pay per product.

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

## Pricing

from $1.90 / 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

### Nykaa Scraper: Beauty Products, Prices, Reviews

**Nykaa scraper** for India's largest beauty store: get every product of a Nykaa category, brand page or search as clean rows
with price, MRP, discount, rating, stock and shade count, and on request the full product page with every shade or size at its
own price and stock, the ingredients, how to use, expiry and offers, plus the verified buyer reviews. No login, no cookies, no
API key. You pay per product delivered; misses, repeats and filtered products are free.

Use it to watch your own and competing brands' prices and discounts on Nykaa, to build a beauty catalogue with shades and
ingredients, to study reviews at scale, or to run a price and stock watch that reports what changed since the last run.

### Quick start

1. Open the Actor's **Input** tab.
2. Pick one or more **Categories** (lipstick, face moisturizer, shampoo ...), type **Search words** (vitamin c serum,
   maybelline), or paste **Nykaa links**: a category, brand or search page, or a product page.
3. Optionally set Nykaa's own filters: brands, price range, minimum discount, minimum rating, and any other filter of Nykaa's panel
   such as "Skin type: Oily".
4. Set **Max products per search** (the form starts at 10; an API call that leaves it out gets 100) and turn on **Product details** or **Reviews** if you want them.
5. Click **Start**. Download the results as JSON, CSV or Excel, or read them through the Apify API.

### What you get

#### Product rows (the Product event)

One row per Nykaa product. Example values are from a real run on 2026-10-16.

| Field | Example | Notes |
|---|---|---|
| `productId` | `683166` | Nykaa's product id, the number after `/p/` in its link |
| `name` | Nykaa Cosmetics So Creme! Creamy Matte Lipstick | |
| `brand`, `brandId`, `brandIds` | Nykaa Cosmetics, `1937` | |
| `url` | https://www.nykaa.com/nykaa-so-creme-creamy-matte-lipstick/p/683166 | |
| `sku`, `parentSku` | NYK_SCCMLT | |
| `price`, `mrp`, `discount`, `discountPercent`, `currency` | 197, 329, 132, 40, INR | price is the selling price |
| `rating`, `ratingCount` | 4.3, 4347942 | |
| `inStock`, `quantity`, `isBackorder` | true, 9634, false | `quantity` is the stock count Nykaa reports |
| `productType`, `shadeType`, `shadeCount`, `packSize` | configurable, shade, 35 | |
| `offers`, `offerCount`, `offerMessage`, `offerId`, `priceDropText` | "Extra 5% off ..." | Nykaa's offers on the product |
| `image`, `images` | image links | |
| `category`, `categoryIds` | `{ "l1": { "id": "12", "name": "Makeup" }, "l2": { "id": "15", "name": "Lips" }, "l3": ... }`, and every category id Nykaa files the product under | |
| `tags`, `secondaryTags`, `attributeNudges` | bestseller, featured; finish: Matte | Nykaa's own labels |
| `isLuxe`, `isFlashSale`, `isEarlyAccess`, `isMini`, `isFreeSample`, `proFlag`, `prEnabled`, `buttonText`, `popularityScore`, `searchScore`, `badge` | | Nykaa's own flags and scores; `badge` is the stock note Nykaa shows on the card ("Only a few left") |
| `isSponsored`, `isFeatured`, `position`, `page` | false, false, 41, 3 | a paid placement, a pinned product, its place on the page (a product shown both as a paid placement and as an ordinary row in one walk is delivered once, as the first of the two) |
| `matchedShadeId` | | the shade a search matched |
| `shadeId` | `683149` | on a row read for one shade (a shade id, or a product link with `skuId`) |
| `source` | `{ "kind": "listing", "input": "categories 1", "categoryId": "249" }` | which input found it |
| `scrapedAt` | 2026-10-16T00:16:10.214Z | |

Fill measured on 1,000 rows of the Skin category (2026-10-22): name, price, MRP, discount, rating count, stock flag, image, link,
category and SKU on 1,000 of 1,000 rows, brand and rating on 999, `quantity` on 960.

#### Product details (the Product detail event, optional)

With **Product details** on, each product row carries `details`, Nykaa's full product page:

| Field | What it holds | Fill on 20 products of different kinds |
|---|---|---|
| `shades` | every shade or size: `shadeId`, `name`, `sku`, `gtin`, `price`, `mrp`, `discountPercent`, `inStock`, `quantity`, `expiry`, `isBestseller`, `image`, `url` | 9 of 20 products have shades; 127 of 127 shades carry price, MRP and stock; 7 of the 9 price their shades differently |
| `description` | the description as text | 20 of 20 |
| `ingredients` | the ingredient list | 9 of 20 |
| `howToUse` | Nykaa's how to use text | 12 of 20 |
| `highlights` | Nykaa's attribute table (concern, finish, formulation, preference ...) | |
| `countryOfOrigin`, `manufacturer`, `manufacturerAddress`, `packer`, `importer`, `seller` | origin and the legal names | on 200 lipsticks (2026-10-22): origin and seller 200 of 200, manufacturer 140 (Nykaa leaves it empty on the rest), importer 74, packer 60 |
| `expiry` | the expiry date shown | 18 of 20 |
| `gtin` | the barcode | 15 of 20 on the product, 19 of 20 counting the shades' own `gtin`; on 200 lipsticks (2026-10-22) 72 on the product, 190 counting shades |
| `ratingHistogram` | ratings per star, 1 to 5 | 19 of 20 |
| `reviewCount`, `reviewSummary`, `reviewTopics` | Nykaa's review count, its "Customers Say" summary and its review topics with sentiment | review count above 0 on 18 of 20, summary on 15 of 20 |
| `returnPeriodDays`, `returnable`, `returnPolicy`, `cashOnDelivery`, `deliveryNote`, `bestsellerRank`, `questionCount` | policy and rank texts | |
| `offers`, `images`, `videos`, `metaKeywords` | | offers on 10 of 20 |
| `pincodeDelivery` | with a **Delivery pincode**: whether Nykaa ships there, city, state, cash on delivery and Nykaa's delivery messages | |

With details on, the row's price, MRP, discount, stock and rating are read from the product page (newer than the listing) and
every filter is checked on them again; a value the product page does not carry fails a filter that needs it. A product page whose
pincode check could not be read is delivered with `detailsStatus: "partial"` and `detailsMissing`, without the Product detail
event.

#### Review rows (the Review event, optional)

With **Reviews** on, each product's verified reviews arrive as rows of their own: `reviewId`, `productId`, `shadeId`,
`productUrl`, `productName`, `rating`, `title`, `text`, `reviewerName`, `isVerifiedBuyer`, `label`, `likeCount`, `images`,
`reviewerAttributes` (the reviewer's skin or hair profile, as Nykaa shows it), `aspects`, `reviewerReviewCount`,
`reviewerImageCount`, `isProReviewer`, `reviewedAt`, `reviewDateText`. Five orders (most useful, most helpful, newest, positive
first, negative first), a star filter, photos only, a start page, up to 1,200 per product (one count per product: a product read
as its own row and as a shade row shares it). With **Include personal data** on, the
reviewer's profile picture link and Nykaa's pseudonymous reviewer id are added (`reviewerProfileImage`, `reviewerId`; null when
off).

The product row says how its review read ended: `reviewsStatus` is `read` when the number you asked for arrived or every review
Nykaa counts was seen, and `partial` when the read was cut, with `reviewsEnd` naming why (`source_page_cap`: Nykaa shows no review
page past 40; `empty_page_before_count`: Nykaa answered an empty page before its count was reached; `invalid_page`). Nykaa's review
pages thin out in the middle of a walk, so a long read can end at page 40 before the count.

#### Product check rows (the Product check event, monitor in changes mode)

One row per watched product link or id each run: `productId`, `shadeId`, `name`, `brand`, `sku`, `price`, `mrp`,
`discountPercent`, `inStock`, `quantity`, `rating`, `ratingCount`, `changeType` (`baseline`, `unchanged` or `changed`),
`changes` (each field with its old and new value), `previousPrice`, `previousMrp`, `previousInStock`.

#### Free rows

- One `coverage` row per search, category or brand page: Nykaa's total with and without your filters, pages read, products
  delivered, already delivered, known to the monitor, filtered out, paid placements read and left out, the page a search was sent
  to, and why the walk stopped (`complete` true or false).
- `status` rows for every miss and stop: an id or category Nykaa does not have, a filter value Nykaa does not list for a page, a
  filter Nykaa did not apply, a page that could not be read, inputs not started.
- Past 600 status rows in one run, further misses of one kind are named together in one row per kind (`items`, up to 1,000 a row);
  inputs or ids a stopped run did not read are always named in full.
- One `summary` row, always last: counts, requests, the work allowance and what was charged.

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

Pay per event. Prices per 1,000 events:

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| Product (`product`) | $2.66 | $2.43 | $2.20 | $1.90 |
| Product detail (`product-details`) | $1.10 | $1.00 | $0.90 | $0.80 |
| Review (`review`) | $2.66 | $2.43 | $2.20 | $1.90 |
| Product check (`product-check`) | $0.40 | $0.37 | $0.34 | $0.30 |

Platinum and Diamond plans pay the Gold price. Each run also pays one **Actor start** event of $0.006 (per GB of memory; the
default 256 MB run pays one), with no discount by tier. The Store pricing card shows these same prices per 1,000 events: "$1.90 /
1,000" on the Product row means one product costs 0.19 cents at the Gold tier.

Free: products Nykaa does not have, products left out by your filters, products already delivered in the run (or by your monitor
before), paid placements left out, product pages or reviews that could not be read, a product page whose pincode check could not be
read (the Product detail event), and every status, coverage and summary row.

Worked examples (Actor start included):

| Run | GOLD | FREE |
|---|---|---|
| 10 products | $0.025 | $0.0326 |
| 1,000 products | $1.906 | $2.666 |
| 1,000 products with Product details | $2.706 | $3.766 |
| 100 products with 20 reviews each | $3.996 | $5.592 |
| a monitor run watching 100 products | $0.036 | $0.046 |

### Input

| Setting | What it does |
|---|---|
| `categories` | category pages to read: pick from the list (57 common pages) or type a Nykaa category id (`249` for lipstick) |
| `searchTerms` | words to search; Nykaa sends brand names and broad words to its own brand or category page, which is then read with the filters that page's link names |
| `startUrls` | nykaa.com links: category, brand and search pages (their filters, sort and page number kept), product pages (with `skuId` for one shade) and review pages; through the API as `[{"url": "..."}]` |
| `productIds` | product or shade ids, read 20 at a time |
| `brands`, `filters`, `minPrice`, `maxPrice`, `minDiscount`, `minRating` | Nykaa's own filters (see below) |
| `sort` | `default` (popularity on category and brand pages, relevance on searches), `customer_top_rated`, `new_arrival`, `discount`, `price_low_to_high`, `price_high_to_low`, `name` |
| `excludeSponsored` | leave out Nykaa's paid placements |
| `expandSubcategories` | when a category or brand page (or a search Nykaa sends to one) stops at its cap (`maxItemsPerSearch`) or at Nykaa's 10,000 product limit, also read each direct subcategory with the same filters and start page |
| `maxItemsPerSearch`, `maxItems`, `startPage`, `maxPagesPerSearch` | caps; Nykaa serves at most 10,000 products per search, page, filter set and order |
| `includeDetails`, `pincode` | the Product detail add-on and the delivery check of a pincode |
| `includeReviews`, `maxReviewsPerProduct`, `reviewsSort`, `reviewsRating`, `reviewsWithPhotosOnly`, `reviewsStartPage` | the Review add-on |
| `monitorName`, `monitorMode`, `resetMonitor` | the monitor (below) |
| `includePersonalData` | adds the reviewer's profile picture and pseudonymous id to review rows (off by default) |
| `maxRequestRetries`, `requestTimeoutSecs`, `proxyConfiguration` | how calls are made; with the Apify proxy (the default) the run reads from its own address first, then Apify datacenter sessions on networks Nykaa lets in; with the Apify proxy off and your own proxy links, through your links |

Example input through the API:

```json
{
    "categories": ["lipstick", "face_moisturizer_day_cream"],
    "startUrls": [{ "url": "https://www.nykaa.com/brands/lakme/c/604?sort=discount" }],
    "brands": ["Lakme", "Maybelline New York"],
    "minPrice": 200,
    "maxPrice": 1000,
    "maxItemsPerSearch": 200,
    "includeDetails": true,
    "pincode": "400001"
}
```

#### Filters: Nykaa's own names

Filters are Nykaa's own. Brands are written as Nykaa's brand filter lists them (Lakme, Maybelline New York, Nykaa Cosmetics).
Any other filter of Nykaa's panel goes into `filters` as "name: value": `Skin type: Oily`, `Concern: Acne & Blemishes`,
`Gender: Female`, `Color: Red`, `Finish: Matte`, `Ingredient: Niacinamide`, `Country Of Origin: India`. The same name twice
matches either value. Each page's own filter panel is read first and only names and values it lists are sent; a value it does not
list is noted on the coverage row, and a filter none of whose values it lists makes that page deliver nothing, free, rather than a
wider search. Brand, price, discount and rating are checked again on every row, paid placements included; when another filter is
set, paid placements are left out, since a row cannot be checked against it.

#### The monitor

Give a `monitorName` and schedule the run:

- `new_only` (default): each run delivers and charges only products and reviews it has not delivered before under that name.
- `changes`: each product link or id is read every run and delivered as one Product check row with what changed since the last
  run (price, MRP, stock; with Product details on, every shade's price and stock too). The first run sets the baseline.

The memory is a named store this Actor creates in your account, one per name.

### What this Actor does NOT do

- It does not read Nykaa Fashion (nykaafashion.com) or any other site: nykaa.com only.
- It does not deliver unverified reviews: Nykaa shows verified buyers' reviews only, and no option returns others.
- It does not deliver a delivery date: Nykaa's pincode check gives shipping, city, state and cash on delivery, no date.
- It reads at most 10,000 products per search, page, filter set and order (Nykaa's own limit; `expandSubcategories` and filters
  split larger pages) and at most 40 review pages of 50 per product and order (Nykaa shows no page past 40; its pages thin out,
  so one product gave 1,166 of the 1,849 reviews Nykaa counts on one order, another 1,200 of 1,200 asked for).
- It does not deliver whether the signed in reader liked a review, nor Nykaa's "2 years ago" age text: logged out the first is
  false on every review, and the second depends on the day of the read (`reviewedAt` and `reviewDateText` are delivered).
- It has no settings for its pace: it paces itself under the limits measured on Nykaa (reviews one call every 2 seconds) and keeps
  a door Nykaa answers.
- It does not switch to residential proxies before it has delivered a product: when Nykaa refuses the run's own address and the
  Apify datacenter sessions it draws, the run stops with a free status row (`residentialUnfunded`) instead of paying residential
  traffic for a run that has earned nothing. Run it again later, or give your own proxy links.
- It does not guess a misspelt setting: a setting name the input does not have (`maxitems` for `maxItemsPerSearch`, or another
  tool's names) refuses the run with a free status row, and only the run's start fee is charged.
- It does not confirm an endless list of ids Nykaa does not have: each unknown id costs a confirming call, so a list made only of
  unknown ids stops on its work allowance after about 28 of them, with the ids it did not reach named in a free "not read" row
  (60 unknown ids: 28 confirmed, 32 named). Real ids in the same list earn room for more (35 unknown ids and 5 real ones delivered
  all 5).

### API examples

```bash
curl -X POST "https://api.apify.com/v2/acts/automation_craft~nykaa-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["vitamin c serum"], "maxItemsPerSearch": 50}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation_craft/nykaa-scraper').call({ categories: ['lipstick'], maxItemsPerSearch: 100, includeDetails: true });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

```python
from apify_client import ApifyClient
client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("automation_craft/nykaa-scraper").call(run_input={"productIds": ["683166"], "includeReviews": True, "maxReviewsPerProduct": 100})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

### FAQ

#### Is there an API for Nykaa?

Nykaa offers no public product API. This Actor gives you one: call it through the Apify API with categories, search words, links
or product ids and get Nykaa's products as JSON, CSV or Excel.

#### How do I check the price history of a Nykaa product?

Run the Actor on a schedule with a `monitorName` and `monitorMode` `changes`: every run delivers each watched product's price, MRP
and stock with the previous values and what changed, so the dataset of the runs is the product's price history.

#### Can I compare Nykaa's selling price with the MRP?

Yes. Every product row carries `price` (the selling price), `mrp`, `discount` in rupees and `discountPercent`; with Product
details on, every shade carries its own price and MRP.

#### How do I scrape Nykaa reviews?

Turn on **Reviews**: each product's verified reviews arrive as rows of their own, up to 1,200 per product, in the order and with
the star filter you pick, for as many products as the run reads.

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

It needs nothing more: it reads Nykaa and writes only to its own run's storage and, for the monitor, to a named store it creates
itself. Limited permissions keep it from touching anything else in your account.

### Changelog

- 0.1 (2026-10): first release.

### More data tools by Automation Craft

- [Myntra Scraper: Fashion Products, Prices, Sizes](https://apify.com/automation_craft/myntra-scraper)
- [Flipkart Scraper: Products, Prices, Sellers](https://apify.com/automation_craft/flipkart-scraper)
- [IndiaMART Scraper: B2B Products, Prices, Suppliers](https://apify.com/automation_craft/indiamart-scraper)
- [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)
- [Mercari US Scraper: Listings, Sold Prices](https://apify.com/automation_craft/mercari-us-scraper)
- [ShopBack Scraper: Cashback, Gift Cards, Affiliates](https://apify.com/automation_craft/affiliate-network-detector)
- [Facebook Marketplace Scraper with Sold Tracker](https://apify.com/automation_craft/facebook-marketplace-scraper)
- [Zalando Ads Library Scraper - Sponsored Products](https://apify.com/automation_craft/zalando-ads-library-scraper)

# Changelog

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

# Actor input Schema

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

Words to search on Nykaa, one search per entry (vitamin c serum, kajal waterproof, maybelline). Nykaa sends broad words and brand names to its own category or brand page (lipstick goes to Lips, maybelline to the Maybelline New York brand page); that page is then read, and the coverage row says so. Each search delivers up to Max products per search.

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

Links copied from nykaa.com: a category page (https://www.nykaa.com/makeup/lips/lipstick/c/249), a brand page (https://www.nykaa.com/brands/lakme/c/604), a search page (https://www.nykaa.com/search/result/?q=niacinamide), with the filters, sort and page number Nykaa put in the link, or a product page (https://www.nykaa.com/nykaa-so-creme-creamy-matte-lipstick/p/683166, a skuId in it reads that shade) or its reviews page. Tracking parts such as utm_source are ignored. Through the API, give each link as {"url": "..."}.

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

Nykaa product ids (the number after /p/ in a product link, as in nykaa.com/.../p/683166) or shade ids. Read 20 at a time; an id Nykaa does not have gets a free status row. Product ids and product page links count together: at most 5,000 products a run.

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

Whole category pages to read: pick from the list, or type a Nykaa category id (the number after /c/ in a category link, as in nykaa.com/makeup/lips/lipstick/c/249).

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

Only these brands, written as Nykaa lists them in its brand filter (Lakme, Maybelline New York, Nykaa Cosmetics). Several brands match any of them. A brand Nykaa does not list for a page is noted on that page's coverage row; when it lists none of them, that page delivers nothing and is free.

## `filters` (type: `array`):

Any other filter of Nykaa's filter panel, one per entry as "<filter name>: <value>" (Skin type: Oily, Concern: Acne & Blemishes, Gender: Female, Color: Red, Finish: Matte, Ingredient: Niacinamide, Country Of Origin: Korea (the Republic of)). The same filter name twice matches either value. Names and values are matched against the page's own filter panel; a filter with no listed value makes that page deliver nothing, free.

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

Only products priced at or above this many rupees (Nykaa's price filter, and checked on every row).

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

Only products priced at or below this many rupees (Nykaa's price filter, and checked on every row).

## `minDiscount` (type: `string`):

Only products discounted by at least this percent, one of Nykaa's own steps (checked on every row).

## `minRating` (type: `string`):

Only products rated at least this many stars (Nykaa's rating filter, and checked on every row).

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

Nykaa's order. default is Nykaa's own: popularity on category and brand pages, relevance on searches.

## `excludeSponsored` (type: `boolean`):

Nykaa mixes paid placements into its default order (flagged isSponsored on each row). Turn this on to leave them out, free. They are always left out when a filter is set that a row cannot be checked against (skin type, concern and the like).

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

When a category or brand page (or a search Nykaa sends to one) stops at Max products per search or at Nykaa's own limit of 10,000 products, read each of its direct subcategories too, with the same filters and start page, each with its own cap and coverage row (a product found twice is delivered once).

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

The most products one search, category, brand page or link delivers (1 to 10,000, Nykaa's own limit per search and order). The form starts at 10; an API call that leaves it out gets 100.

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

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

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

Start each search or page at this page of Nykaa's results (1 to 500, 20 products a page); the pages before it are not read.

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

The most result pages one search, category or brand page reads (1 to 500, 20 products a page). Leave empty to stop only at Max products per search.

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

Add each product's full product page (the Product detail event): every shade or size with its own price, MRP, stock, SKU, GTIN and expiry, description, ingredients, how to use, highlights, country of origin, manufacturer, packer and importer, seller, expiry, return policy, the star breakdown, Nykaa's review summary and topics, offers, images and videos. The row then shows the page's own price, stock and rating.

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

An Indian pincode (six digits, 400001). With Product details on, each product's details carry whether Nykaa ships it there, the city and state, and whether cash on delivery is available.

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

Add each product's verified reviews as rows of their own (the Review event): rating, title, text, shade, reviewer name, photos, likes, the reviewer's skin or hair profile and the date. Nykaa shows verified buyers' reviews only.

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

The most reviews delivered per product (1 to 1,200; Nykaa shows at most 40 pages of 50 per product and order, often fewer). Default 20.

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

Nykaa's review orders: most useful (default), most helpful, newest, positive first, negative first.

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

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

## `reviewsWithPhotosOnly` (type: `boolean`):

Only reviews that carry the buyer's photos.

## `reviewsStartPage` (type: `integer`):

Start each product's reviews at this page of Nykaa's review list (1 to 40, 50 reviews a page); the pages before it are not read. Default 1.

## `includePersonalData` (type: `boolean`):

Off by default. Turn on to add, on review rows, the reviewer's profile picture link and Nykaa's pseudonymous reviewer id (both null when off; the reviewer's name, which Nykaa shows with every review, is always delivered). You are responsible for using personal data lawfully, GDPR and India's DPDP Act 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 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 id is read each run and delivered as one Product check row with its price, MRP and stock, the previous values and what changed since the last run (with Product details on, every shade's price and stock is watched too).

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

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

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

How many times in all a call Nykaa did not answer is tried, the first try included (1 to 5, default 3). A refused door is replaced at once and does not count.

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

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

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

Default: the run's own address first (Nykaa answered it on all but 1 of 262 platform runs; a refusal moves the run to the next door), then Apify datacenter sessions on networks Nykaa lets in, then Apify residential India. Turn the Apify proxy off to use the run's own address only (a refusal or a slow answer there ends the run, partial), or give your own proxy links.

## Actor input object example

```json
{
  "searchTerms": [],
  "categories": [
    "lipstick"
  ],
  "excludeSponsored": false,
  "expandSubcategories": false,
  "maxItemsPerSearch": 10,
  "includeDetails": false,
  "includeReviews": false,
  "reviewsWithPhotosOnly": false,
  "includePersonalData": 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": [],
    "categories": [
        "lipstick"
    ],
    "maxItemsPerSearch": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation_craft/nykaa-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/R54xpyMtGoJfM1uoP/builds/5AduY1cDdEVeFsfIu/openapi.json