# Nykaa Scraper \[Only $2.50/1K💰] | Products | Reviews | India (`ahmed_jasarevic/nykaa-scraper`) Actor

Scrape Nykaa beauty products — prices, MRP, discounts, shades, stock, ingredients, ratings and customer reviews — as clean JSON. Build India beauty price-monitoring, market-research and competitor datasets, then export to CSV, Excel, Google Sheets or your warehouse.

- **URL**: https://apify.com/ahmed_jasarevic/nykaa-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

Scrape **nykaa.com** — India's largest beauty & wellness marketplace — for product listings, search results, full product details (shades, prices, MRP, stock, offers, ingredients) and customer reviews as structured JSON. No browser: the Actor calls Nykaa's own JSON endpoints directly, so runs are fast and cheap.

Built for beauty brand pricing teams, D2C founders, market researchers and data teams tracking India's beauty and personal-care market — MRP vs selling price, shade-level stock, rating histograms and customer reviews in one dataset.

### Nykaa Beauty Price Monitoring & Market Research

- Nykaa price monitoring — track selling price vs MRP and discount depth per SKU
- India beauty and personal-care market research
- Competitor and share-of-shelf analysis across India beauty brands
- Product catalogue enrichment — ingredients, how-to-use, manufacturer and country of origin
- Customer review and sentiment analysis for one product or a whole category
- Bestselling SKU and ingredient trend tracking (niacinamide, retinol, vitamin C, hyaluronic acid and more)
- D2C beauty pricing intelligence, promotional and sale-window tracking

### How It Works

![How the Nykaa Scraper works: browser-fingerprinted JSON calls become product, variant and review rows with INR pricing and stock.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-nykaa-scraper)

Nykaa is protected by Akamai Bot Manager, so the Actor uses Apify's `impit` client to reproduce Chrome's TLS and HTTP/2 fingerprint over plain HTTP. It reads the site's own listing, product, variant and review JSON endpoints.

Products include brand, title, MRP, price, discount, rating histogram, stock, shade and size variants, ingredients and images; reviews are written to a separate dataset.

nykaa.com is protected by **Akamai Bot Manager**, which rejects any client whose TLS/HTTP-2 fingerprint is not a real browser. This Actor uses [`impit`](https://github.com/apify/impit) — Apify's Rust HTTP client that reproduces Chrome's TLS ClientHello and HTTP/2 fingerprint — and reads the same public JSON endpoints the site's own frontend calls. No browser, no DOM scraping, no cookies.

| Purpose | Endpoint |
| --- | --- |
| Listing / search | `GET /gludo/products/list?search=<q>` or `?category_id=<id>` (paginated) |
| Product detail | `GET /<slug>/p/<id>` → `window.__PRELOADED_STATE__` → `.productPage.product` |
| Variants (fallback) | `GET /gludo/listVariants?id=<parentId>` |
| Reviews | `GET /gateway-api/products/<id>/reviews?pageNo=<n>&filters=DEFAULT&domain=nykaa` |

Notes:

- The listing endpoint returns ~20 products per page plus `total_found`, so pagination is exact.
- Nykaa maps some search terms to a category instead of returning products; the Actor detects this and transparently re-issues the request as a category listing.
- A single product-page request returns the full product state — including every shade/size variant with its own price, discount and stock — so one request yields the whole product.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `searchQueries` | string\[] | No | — | Search terms to look up on Nykaa, e.g. `["lipstick", "cerave face wash"]`. Each query returns matching products. |
| `categoryIds` | string\[] | No | — | Nykaa category IDs (the number in a category URL such as `…/c/15`). |
| `startUrls` | array | No | — | Direct Nykaa URLs: product pages (`…/p/<id>`), category pages (`…/c/<id>`) or search result pages. |
| `maxItems` | integer | No | `50` | Maximum number of products to scrape. Free users are capped at 10 products. |
| `scrapeVariants` | boolean | No | `true` | Include every shade/size variant with its own price, discount and stock level. |
| `scrapeReviews` | boolean | No | `true` | Scrape customer reviews into the separate `reviews` dataset. Requires `maxReviewsPerProduct` to be greater than 0. |
| `maxReviewsPerProduct` | integer | No | `0` | How many reviews to scrape per product. `0` = skip reviews. |
| `proxy` | object | No | `useApifyProxy: false` | Standard Apify proxy configuration. Direct connection works by default; enable a proxy if you hit rate limits at high volume. |

Provide at least one of `searchQueries`, `categoryIds` or `startUrls`.

### Output Fields

The output schema exposes two datasets: **Products** (default dataset) and **Reviews** (named dataset `reviews`).

**Products dataset (default)** — one row per product (`type: "product"`):

| Field | Type | Description |
| --- | --- | --- |
| `type` | string | Always `"product"`. |
| `productId`, `parentId` | string, string|null | Nykaa product ID and parent product ID (shared across shades/sizes). |
| `sku`, `psku` | string|null | Product SKU and parent SKU. |
| `brand` | string|null | Brand name. |
| `title`, `name` | string|null | Full product title as displayed, and the shortened product name. |
| `url`, `slug` | string, string|null | Canonical product page URL and its slug. |
| `currency` | string | Always `INR`. |
| `mrp` | number|null | Maximum retail price in INR. |
| `price` | number|null | Current selling price in INR. |
| `discountPercent` | number|null | Discount off MRP, in percent. |
| `rating` | number|null | Average customer rating (0–5). |
| `ratingCount` | number|null | Number of customer ratings. |
| `reviewCount` | number|null | Number of written reviews. |
| `qnaCount` | number|null | Number of questions & answers. |
| `ratingHistogram[]` | array | Full star distribution: `stars`, `count`, `percent`. The true rating spread — more representative than the featured reviews alone. |
| `inStock` | boolean|null | Whether the product is currently purchasable. |
| `stockQuantity` | number|null | Nykaa's reported inventory number (can be approximate). |
| `packSize` | string|null | Pack size from the listing. |
| `variantType` | string|null | Variant dimension (`shade`, `size`, …). |
| `productType` | string|null | Product type. |
| `shadeCount` | number|null | Number of shade/size variants. |
| `shades[]` | array | Every shade/size variant: `childId`, `shade`, `sku`, `packSize`, `mrp`, `price`, `discountPercent`, `inStock`, `stockQuantity`, `image`. |
| `offers[]` | array | Active offers: `title`, `description`. |
| `description` | string|null | Product description (HTML stripped). |
| `ingredients` | string|null | Ingredient list (HTML stripped). |
| `howToUse` | string|null | How-to-use text (HTML stripped). |
| `images[]` | array | Product image URLs. |
| `imageUrl` | string|null | Primary product image URL. |
| `categoryPath[]` | array|null | Category breadcrumb, e.g. `["Makeup","Lips","Liquid Lipstick"]`. |
| `categoryLevels` | array|null | Category levels as returned by Nykaa. |
| `manufacturer`, `manufacturerAddress` | string|null | Manufacturer name and address. |
| `countryOfOrigin` | string|null | Country of origin. |
| `expiry` | string|null | Expiry date of the stock on sale. |
| `seller` | string|null | Seller ("Sold by") name. |
| `source` | string | Where the item was found, e.g. `search:cerave face wash`. |
| `scrapedAt` | string | ISO 8601 timestamp of when the item was scraped. |

**Reviews dataset (`reviews`)** — one row per review (`type: "review"`), populated only when `maxReviewsPerProduct > 0`:

| Field | Type | Description |
| --- | --- | --- |
| `type` | string | Always `"review"`. |
| `productId` | string | Product the review belongs to. |
| `reviewId` | number|null | Nykaa review identifier. |
| `title` | string|null | Review headline. |
| `text` | string|null | Full review text. |
| `author` | string|null | Reviewer display name. |
| `rating` | number|null | Star rating given by the reviewer (1–5). |
| `createdOn` | string|null | Date the review was posted. |
| `likeCount` | number | Number of users who found the review helpful. |
| `isBuyer` | boolean|null | Verified-buyer flag — whether the reviewer purchased on Nykaa. |
| `images[]` | array | Image URLs attached to the review. |
| `source` | string | Where the review came from. |
| `scrapedAt` | string | ISO 8601 timestamp. |

### Example Input

```json
{
    "searchQueries": ["cerave face wash", "matte lipstick"],
    "maxItems": 100,
    "scrapeVariants": true,
    "scrapeReviews": true,
    "maxReviewsPerProduct": 20
}
```

### Example Output

One product row (default dataset):

```json
{
    "type": "product",
    "productId": "2513256",
    "parentId": "2513256",
    "brand": "CeraVe",
    "title": "CeraVe Foaming Cleanser",
    "name": "Foaming Cleanser",
    "sku": "CERAVE00001",
    "url": "https://www.nykaa.com/cerave-foaming-cleanser/p/2513256",
    "currency": "INR",
    "mrp": 599,
    "price": 479,
    "discountPercent": 20,
    "rating": 4.5,
    "ratingCount": 1234,
    "reviewCount": 321,
    "ratingHistogram": [
        { "stars": 5, "count": 900, "percent": 73 },
        { "stars": 4, "count": 240, "percent": 19 },
        { "stars": 1, "count": 40, "percent": 3 }
    ],
    "inStock": true,
    "shadeCount": 2,
    "shades": [
        {
            "childId": "2513257",
            "shade": "236ml",
            "sku": "CERAVE00002",
            "packSize": "236ml",
            "mrp": 599,
            "price": 479,
            "discountPercent": 20,
            "inStock": true,
            "stockQuantity": 42,
            "image": "https://images-static.nykaa.com/media/catalog/product/2513257.jpg"
        }
    ],
    "offers": [{ "title": "Buy 2 Get 1", "description": "On selected skincare" }],
    "ingredients": "Aqua, Glycerin, Niacinamide, Ceramide NP…",
    "images": ["https://images-static.nykaa.com/media/catalog/product/2513256-1.jpg"],
    "imageUrl": "https://images-static.nykaa.com/media/catalog/product/2513256-1.jpg",
    "categoryPath": ["Skin", "Cleansers", "Face Wash"],
    "countryOfOrigin": "India",
    "seller": "Nykaa Retail",
    "source": "search:cerave face wash",
    "scrapedAt": "2026-01-01T10:00:00.000Z"
}
```

One review row (`reviews` dataset):

```json
{
    "type": "review",
    "productId": "2513256",
    "reviewId": 987654321,
    "title": "Great for oily skin",
    "text": "Cleans well without leaving my skin dry.",
    "author": "Priya S.",
    "rating": 5,
    "createdOn": "2025-12-10 08:12:00",
    "likeCount": 12,
    "isBuyer": true,
    "images": [],
    "source": "search:cerave face wash",
    "scrapedAt": "2026-01-01T10:00:05.000Z"
}
```

### Integrations & Automation

Runs on the Apify platform, so every run gets a REST API, scheduled runs, webhooks and one-click integrations with Google Sheets, Make, Zapier, n8n and cloud warehouses (BigQuery, Snowflake, S3).

Recommended cadences:

- **Daily** — price, MRP and stock snapshot per SKU for price monitoring and MAP compliance.
- **Weekly** — category and brand sweeps for assortment, share-of-shelf and ingredient trend tracking.
- **Hourly during sale events** (Pink Friday, Hot Pink Sale, Beauty Bonanza) — beauty discounts can swing 20–50% within a single day, so tighter polling catches flash cycles.

Pair a daily run with a stored SKU key to turn each snapshot into a dated price series and alert on price drops.

### Related Actors

Beauty and e-commerce data actors that complement this one:

- [Sephora Product Scraper](https://apify.com/autofacts/sephora) — Sephora prices, stock, shades and ratings for global beauty comparison.
- [Sephora Product, Reviews & Q\&A Scraper](https://apify.com/ahmed_jasarevic/sephora-data-scraper-products-reviews-questions-answers) — Sephora products, reviews and Q\&A in one dataset.
- [Notino Scraper](https://apify.com/ahmed_jasarevic/notino-scraper) — Notino beauty catalogue and reviews across 27 countries.
- [Flipkart Scraper](https://apify.com/ahmed_jasarevic/flipkart-scraper) — Flipkart products, prices and reviews for India e-commerce comparison.
- [Amazon Bestsellers Scraper](https://apify.com/ahmed_jasarevic/amazon-bestsellers-scraper) — Amazon bestseller rankings and prices for market research.

### Frequently Asked Questions

#### Why use this Actor instead of the official Nykaa API?

Nykaa does not publish a public, documented developer API. Its product, listing and review data is served through internal endpoints used by its own website and apps. This Actor reads those same public endpoints and returns them as clean, structured JSON — without you maintaining a scraper, rotating proxies or handling Akamai bot protection.

#### Does Nykaa have a public API?

No. There is no official public Nykaa API for products, prices or reviews. Businesses that need Nykaa data either scrape it (this Actor) or use a third-party wrapper service that does the same thing behind a paid endpoint.

#### What are alternatives to this Actor for Nykaa data?

Third-party paid APIs resell Nykaa access — for example ReefAPI, Anysite, Anakin.io, Real Data API, ScrapeIt, Parse.bot and BeautyFeeds — and pre-built datasets exist on marketplaces like Crawl Feeds and Actowiz. On Apify, alternatives include `thirdwatch/nykaa-scraper`, `stealth_mode/nykaa-reviews-scraper` and `piotrv1001/nykaa-listings-scraper`. This Actor gives you product detail **and** reviews in one run with a single, transparent per-result price.

#### How can I get Nykaa product prices and details?

Give the Actor one or more search queries, category IDs or product URLs. It returns each product's MRP, selling price, discount, rating, rating histogram, every shade/size variant with its own price and stock, plus ingredients and manufacturer data.

#### How do I scrape Nykaa reviews for sentiment analysis?

Set `scrapeReviews` to `true` and `maxReviewsPerProduct` above 0, and reviews are written to a separate `reviews` dataset with rating, title, text, author, date, helpful votes and a verified-buyer flag. Note that Nykaa publishes a limited, curated set of reviews per product (its "most useful", mostly verified-buyer selection) — for the true rating spread use the `ratingHistogram` field on the product.

#### How do I track Nykaa prices over time?

Run the Actor on a daily schedule and store each row keyed by `sku` or `productId`. Comparing snapshots by date turns MRP, selling price and discount into a price series, so a price drop or a sale window shows up as a dated event. Increase the cadence to hourly during named sale events.

#### What is the best way to build an India beauty product dataset?

Combine search queries and category sweeps, capture `brand`, `categoryPath`, `ingredients` and per-shade prices, and refresh weekly. The ingredient and `ratingCount` fields let you track trending actives (niacinamide, retinol, vitamin C, peptides) and rising SKUs across brands.

#### Can I get stock and price per shade, not just the parent product?

Yes. With `scrapeVariants` enabled (the default), every shade/size variant is returned with its own `childId`, price, discount, stock flag and stock quantity.

### For AI Agents & LLM Apps

- **Purpose:** returns Nykaa (India beauty marketplace) product rows — price, MRP, discount, rating histogram, shade/size variants, stock, ingredients and metadata — to the default dataset, and optional customer reviews to a `reviews` dataset.
- **Minimal input:** `{ "searchQueries": ["cerave face wash"] }`
- **Variant inputs:**
  - Search mode: `{ "searchQueries": ["matte lipstick"], "maxItems": 100 }`
  - Category mode: `{ "categoryIds": ["15"], "maxItems": 100 }`
  - Direct URLs: `{ "startUrls": [{ "url": "https://www.nykaa.com/cerave-foaming-cleanser/p/2513256" }] }`
  - With reviews: add `{ "scrapeReviews": true, "maxReviewsPerProduct": 20 }`
- **Output fields (products):** `type, productId, parentId, brand, title, name, sku, psku, url, slug, currency, mrp, price, discountPercent, rating, ratingCount, reviewCount, qnaCount, ratingHistogram, inStock, stockQuantity, packSize, variantType, productType, shadeCount, shades, offers, description, ingredients, howToUse, images, imageUrl, categoryPath, categoryLevels, manufacturer, manufacturerAddress, countryOfOrigin, expiry, seller, source, scrapedAt`
- **Output fields (reviews):** `type, productId, reviewId, title, text, author, rating, createdOn, likeCount, isBuyer, images, source, scrapedAt`
- **Behaviors an agent should know:**
  - At least one of `searchQueries`, `categoryIds` or `startUrls` is required; otherwise the run fails with an error.
  - `maxItems` defaults to 50 and bounds the number of products. Free accounts are additionally capped at 10 products regardless of `maxItems`.
  - `scrapeVariants` defaults to `true` — shade/size variants are included unless explicitly disabled.
  - `scrapeReviews` defaults to `true` **but** `maxReviewsPerProduct` defaults to `0`, so no reviews are collected by default. Reviews start only when `maxReviewsPerProduct > 0`.
  - Reviews are stored in a separate dataset named `reviews`, not the default dataset.
  - Proxy is off by default (`useApifyProxy: false`); a direct connection works.
  - A product page request returns the whole product including all variants in one call.
- **Billing:** pay-per-event — ~$2.50 per 1,000 products (charged via the default-dataset synthetic event) and ~$2.50 per 1,000 reviews (the `review-scraped` event).

### Legal & Compliance Disclaimer

This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Nykaa or FSN E-Commerce Ventures Limited**. It accesses only publicly available Nykaa pages and the JSON data those pages serve; it does not log in, bypass authentication, or solve CAPTCHAs. Users are responsible for complying with Nykaa's Terms of Service and with applicable data-protection law, including India's Digital Personal Data Protection Act (and GDPR/CCPA where relevant). Review records include the reviewer's public display name and should not be used for unsolicited commercial outreach in violation of applicable law.

### SEO Keywords

nykaa scraper, nykaa api, nykaa api alternative, nykaa product data, nykaa product scraper, nykaa price tracker, nykaa reviews scraper, nykaa review data, nykaa dataset, scrape nykaa, beauty product data india, india beauty market research, cosmetics market research india, nykaa price monitoring, nykaa competitor analysis, beauty price tracking india, d2c beauty pricing intelligence, nykaa ingredients data, nykaa shade variants, nykaa product listings, indian beauty ecommerce data, mrp discount tracking nykaa, nykaa sentiment analysis, share of shelf nykaa, skincare product data api

# Actor input Schema

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

Search terms to look up on Nykaa (e.g. "lipstick", "cerave face wash"). Each query returns matching products.

## `categoryIds` (type: `array`):

Nykaa category IDs to scrape (the number in a category URL such as https://www.nykaa.com/makeup/lips/c/15).

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

Direct Nykaa URLs: product pages (…/p/<id>), category pages (…/c/<id>) or search result pages.

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

Maximum number of products to scrape. Free users are capped at 10 products.

## `scrapeVariants` (type: `boolean`):

Include every shade/size variant with its own price, discount and stock level.

## `scrapeReviews` (type: `boolean`):

Additionally scrape customer reviews into a separate "reviews" dataset. Requires "Max reviews per product" to be greater than 0.

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

How many customer reviews to scrape per product (0 = skip reviews). Used when "Scrape reviews" is enabled.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchQueries": [
    "cerave face wash"
  ],
  "maxItems": 50,
  "scrapeVariants": true,
  "scrapeReviews": true,
  "maxReviewsPerProduct": 0,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per product with pricing, stock, shades/sizes, rating histogram, offers and metadata.

## `reviews` (type: `string`):

Customer reviews, one item per review (only populated when maxReviewsPerProduct > 0).

# 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 = {
    "searchQueries": [
        "cerave face wash"
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/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 = {
    "searchQueries": ["cerave face wash"],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/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 '{
  "searchQueries": [
    "cerave face wash"
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/nykaa-scraper --silent --output-dataset

```

## MCP server setup

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