# Sephora Scraper & API - Products, Prices, Shades & Stock (`rel8ble/sephora-products-scraper`) Actor

Sephora scraper and API: Sephora US and Canada beauty products by keyword, category, brand or URL. One result = one product: brand, name, price, sale price, rating, reviews, badges, shades / sizes with stock, ingredients, images, URL. $0.85 per 1,000, no start fee.

- **URL**: https://apify.com/rel8ble/sephora-products-scraper.md
- **Developed by:** [Giovanni Rich](https://apify.com/rel8ble) (community)
- **Categories:** E-commerce
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.85 / 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.

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

## Sephora Scraper & API - Products, Prices, Shades & Stock

**Sephora Products Scraper** is an unofficial Sephora API and product data scraper for **sephora.com (US) and Sephora Canada**: search by keyword, list a whole category or brand, or paste product URLs, and get one clean JSON row per product with brand, name, price, sale price, currency, star rating, review count, number of shades / sizes, badges (new, bestseller, Sephora exclusive, limited edition, online only), image and URL. Turn on product details to add the full description, ingredient list, suggested usage, loves count, highlight tags (Vegan, Clean at Sephora...), category path, all images and **every variant (shade / size) with its own price, size and stock flags**.

It reads the same JSON catalog endpoint and server-rendered product pages the Sephora website uses, over plain HTTP: no browser, no login, no API key. About 100 products per request on listings, one request per product for details.

Use it for **price and promotion monitoring** (sale prices, price ranges, new arrivals), **competitor and assortment research** (what a brand sells at Sephora, at what prices, with what ratings), **product catalog building** (names, images, descriptions, ingredients, sizes and shades for marketplaces or comparison sites), **review and rating tracking** (rating, review count, loves, Sephora's review sentiment tags) and **feeding AI agents** with structured beauty-product data.

### Sample output

Five rows from a real run (`searchQueries: ["mascara"]`, details off, 22 Oct 2026), taken from `sample-output.json`:

| Brand | Product | Price (USD) | Rating | Reviews | Shades / sizes |
|---|---|---|---|---|---|
| Lancôme | Lash Idôle Lengthening & Volumizing Mascara | 16 | 4.5 | 10785 | 2 |
| ILIA | Limitless Lash Mascara - Clean Lengthening Mascara | 17 | 4.13 | 7817 | 2 |
| Too Faced | Better Than Sex Volumizing & Lengthening Mascara | 16 | 3.72 | 19692 | 3 |
| Yves Saint Laurent | Lash Clash Extreme Volume Mascara | 18 | 4.12 | 3600 | 4 |
| Tower 28 Beauty | MakeWaves® Lengthening + Volumizing Mascara | 12 | 3.81 | 2989 | 2 |

The full row has 36 fields; one is shown in JSON under Output example below.

### How to use

1. Type one or more **Search keywords** (`vitamin c serum`, `tubing mascara`, `sunscreen spf 50`), and / or **Categories** (`mascara`, `face-serum`, `foundation-makeup`, or any `sephora.com/shop/<slug>` URL), and / or **Brands** (`fenty-beauty-rihanna`, `the-ordinary`, or any `sephora.com/brand/<slug>` URL). Each line is one listing; results are merged.
2. Pick the **Store**: `us` (sephora.com, USD) or `ca` (Sephora Canada, CAD and the Canadian assortment).
3. Leave **Include product details** off for a fast, cheap listing (about 100 products per request), or turn it on for the full product page: description, ingredients, loves count, category path, images and every shade / size with price and stock.
4. Optionally sort (best selling, top rated, new, price) and filter before anything is charged: price range, minimum rating, only these brands, on sale only, new only.
5. Set **Max results per query** and **Max results in total**, click **Start**, and download JSON, CSV or Excel from the **Output** tab, or pull the rows through the API, Make, Zapier, n8n or an MCP client.

Already have links? Paste product pages (`https://www.sephora.com/product/...-P515709`) into **Sephora URLs**: each gives one full row with details, no search needed. Category, brand and `/search?keyword=` URLs work there too.

### What you get

One dataset item per product:

- **Identity**: `productId`, `name`, `brand`, `brandUrl` (details), `url`, `skuId` (the shown variant), `image`, `imageAlt`, `images` (details), `videos` (details).
- **Price**: `listPrice` as Sephora prints it (`"$26.00"` or a range `"$9.90 - $17.50"` across variants), `price` / `priceMax` (what you pay now, sale price when on sale), `regularPrice` / `regularPriceMax`, `salePrice`, `valuePrice` (sets), `currency` (`USD` or `CAD`), `isOnSale`.
- **Social proof**: `rating` (0-5), `reviews`, `lovesCount` (details), `reviewSummary` and `sentiments` (Sephora's pros / cons tags with counts, details).
- **Flags**: `isNew`, `isBestseller`, `isLimitedEdition`, `isSephoraExclusive`, `isOnlineOnly`, `isAppExclusive`, `sponsored`, `pickupEligible`, `sameDayDeliveryEligible`, `shipToHomeEligible`, `isOutOfStock` and `isOnlyFewLeft` (details), `maxPurchaseQuantity` (details), `badge` (awards), `highlights` (`Vegan`, `Clean at Sephora`, `Fragrance Free`...).
- **Content** (details): `shortDescription`, `description`, `suggestedUsage`, `ingredients` (plain text), `size`, `category` (path from the top with ids and URLs), `categoryName`.
- **Variants** (details): `variantsCount`, `variationType` (`Color`, `Size`, `Scent`...), `variants[]` with `skuId`, `name` (the shade or size), `size`, `listPrice`, `price`, `regularPrice`, `salePrice`, `isOutOfStock`, `isOnlyFewLeft`, `isNew`, `isLimitedEdition`, `ingredients`, `image`, `url`.
- **Meta**: `detailsIncluded`, `detailsError` (the listing row is kept when a product page fails), `position` in the listing, `sourceType` (`search`, `category`, `brand`, `url`), `sourceQuery`, `scrapedAt`.

With **Include product details** off, rows carry the identity, price, rating / reviews, flags, `variantsCount`, `variationType` and `image` fields from the listing and `detailsIncluded: false`.

### Use cases

- **Price monitoring**: run `onSaleOnly: true` on a category every morning and diff `salePrice` against yesterday; `regularPrice` and `salePrice` are separate numbers.
- **Brand assortment**: `brands: ["rare-beauty-by-selena-gomez"]` with details lists every product, shade and size the brand sells at Sephora with stock flags.
- **Catalog building**: names, descriptions, ingredient lists, sizes, images and category paths for a marketplace, comparison site or ingredient-analysis app.
- **Launch tracking**: `newOnly: true` + `sortBy: newest` on `skincare` categories shows what launched this week.
- **Market research**: `sortBy: bestSelling` + `maxItemsPerQuery: 100` per category gives the top sellers with ratings and review counts; `minRating: 4` keeps the well-reviewed ones.
- **AI agents**: "find vegan mascaras under $25 rated 4+ at Sephora" maps straight onto the input fields (`searchQueries`, `maxPrice`, `minRating`; `highlights` carries `Vegan`).

### Pricing

Pay per result: **$0.85 per 1,000 products** (one result = one product row saved to the dataset, with or without details). No start fee and no charge per search.

- The prefilled form (`mascara`, up to 100 products, listing only) = $0.085
- A category of 200 products, listing only = $0.17
- A brand's 130 products with every shade and ingredient list = $0.11
- Daily sale check on 10 categories x 100 products = $0.85 per day

Failed requests and duplicates are never charged. If you set a maximum cost per run, the scraper stops cleanly when it reaches it. Apify's free plan includes $5 of monthly platform credit, enough for about 5,800 products, with or without details.

### FAQ

**Does it need a browser, a Sephora account or an API key?**
No. It reads Sephora's catalog JSON and product pages over HTTP.

**Can I get shades and stock?**
Yes, turn on `includeDetails`: every variant comes with its own price, size and out-of-stock / only-few-left flags.

**Does it scrape reviews?**
No, only rating, review count, loves count and Sephora's sentiment tags.

**US and Canada?**
Both: `country: "us"` (USD) or `"ca"` (CAD).

**How fast is it?**
Listings come about 100 products per request: 451 products took 86 seconds in a cloud test (22 Oct 2026). Details add one product page per row; 18 detailed products took 32 seconds in the cloud.

**How much does a typical job cost?**
$0.85 per 1,000 products, with or without details: 100 products is $0.085, a 1,000-product category with every shade is $0.85.

### Input example

| Field | Default | Description |
|---|---|---|
| `searchQueries` | - | Keywords, one search each |
| `categories` | - | Category slugs / ids / `/shop/` URLs |
| `brands` | - | Brand slugs / `/brand/` URLs |
| `startUrls` | - | Product, category, brand or search URLs |
| `country` | `us` | `us` (USD) or `ca` (CAD) |
| `includeDetails` | `false` | Read every product page (variants, ingredients, description...) |
| `sortBy` | `relevance` | `bestSelling`, `topRated`, `newest`, `priceLowToHigh`, `priceHighToLow` |
| `minPrice` / `maxPrice` | - | Price range in the store currency |
| `minRating` | - | `4` = 4 stars and up |
| `brandFilter` | - | Keep only these brand names (as Sephora spells them) |
| `onSaleOnly` / `newOnly` | `false` | Sale / new-arrival filters |
| `maxItemsPerQuery` | 100 | Products per search / category / brand; 0 = all |
| `maxItems` | 1000 | Products per run; 0 = all |
| `proxyConfiguration` | Apify datacenter | Sephora serves datacenter IPs; the proxy spreads requests |

Top 50 best-selling face serums rated 4+ with full details:

```json
{
    "categories": ["face-serum"],
    "sortBy": "bestSelling",
    "minRating": "4",
    "includeDetails": true,
    "maxItemsPerQuery": 50
}
```

Everything a brand sells in Canada, listing only:

```json
{
    "brands": ["the-ordinary"],
    "country": "ca",
    "maxItemsPerQuery": 0
}
```

Lipsticks on sale, cheapest first:

```json
{
    "searchQueries": ["lipstick"],
    "onSaleOnly": true,
    "sortBy": "priceLowToHigh",
    "maxItemsPerQuery": 50
}
```

Two specific products with details:

```json
{
    "startUrls": [
        "https://www.sephora.com/product/badi-lash-smudge-proof-volumizing-tubing-mascara-P515709",
        "https://www.sephora.com/product/P502185"
    ]
}
```

### Output example

A listing row (details off), from `searchQueries: ["mascara"]` on 22 Oct 2026:

```json
{
    "productId": "P467208",
    "name": "Lash Idôle Lengthening & Volumizing Mascara",
    "brand": "Lancôme",
    "url": "https://www.sephora.com/product/lancome-lash-idole-lash-lifting-volumizing-mascara-P467208?skuId=2417145",
    "skuId": "2417145",
    "listPrice": "$16.00 - $30.00",
    "price": 16,
    "priceMax": 30,
    "regularPrice": 16,
    "regularPriceMax": 30,
    "salePrice": null,
    "valuePrice": null,
    "isOnSale": false,
    "rating": 4.4998,
    "reviews": 10785,
    "variantsCount": 2,
    "variationType": null,
    "isNew": false,
    "isBestseller": true,
    "isLimitedEdition": false,
    "isSephoraExclusive": false,
    "isOnlineOnly": false,
    "isAppExclusive": false,
    "skuType": null,
    "pickupEligible": false,
    "sameDayDeliveryEligible": false,
    "shipToHomeEligible": false,
    "sponsored": false,
    "image": "https://www.sephora.com/productimages/sku/s2417145-main-zoom.jpg",
    "imageAlt": "Lancôme - Lash Idôle Lengthening & Volumizing Mascara",
    "detailsIncluded": false,
    "currency": "USD",
    "position": 1,
    "sourceType": "search",
    "sourceQuery": "mascara",
    "scrapedAt": "2026-10-22T17:50:47.790Z"
}
```

A product row with details (trimmed), from a pasted product URL:

```json
{
    "productId": "P515709",
    "name": "Badi Lash Smudge Proof Volumizing Tubing Mascara",
    "brand": "Kulfi",
    "brandUrl": "https://www.sephora.com/brand/kulfi",
    "url": "https://www.sephora.com/product/badi-lash-smudge-proof-volumizing-tubing-mascara-P515709",
    "skuId": "2867117",
    "listPrice": "$26.00",
    "price": 26,
    "regularPrice": 26,
    "salePrice": null,
    "currency": "USD",
    "isOnSale": false,
    "rating": 4.1737,
    "reviews": 426,
    "lovesCount": 28308,
    "size": "0.34 oz / 10 mL",
    "variationType": "Color",
    "variantsCount": 1,
    "isSephoraExclusive": true,
    "isOutOfStock": false,
    "isOnlyFewLeft": false,
    "maxPurchaseQuantity": 10,
    "description": "What it is: A good-for-your-lashes tubing mascara that volumizes from root to tip without smudging or running and is easily removed with warm water.\n\nFormulation Type: Volumizing, Lengthening\n\nHighlighted Ingredients:\n- Castor Seed Oil: Moisturizes. ...",
    "suggestedUsage": "Suggested Usage:\n-Beginning at the base of your lashes, gently guide the wand from root to tip ...",
    "ingredients": "-Castor Seed Oil: Moisturizes. ... Water (Aqua) (Eau), Acrylates Copolymer, ...",
    "highlights": ["Vegan", "Clean at Sephora", "Volumizing", "allure 2025 Best of Beauty Award Winner", "Lengthening"],
    "badge": "allure 2025 Best of Beauty Award Winner",
    "category": [
        { "id": "cat140006", "name": "Makeup", "url": "https://www.sephora.com/shop/makeup-cosmetics" },
        { "id": "cat130054", "name": "Eye", "url": "https://www.sephora.com/shop/eye-makeup" },
        { "id": "cat60026", "name": "Mascara", "url": "https://www.sephora.com/shop/mascara" }
    ],
    "categoryName": "Mascara",
    "images": ["https://www.sephora.com/productimages/sku/s2867117-main-zoom.jpg", "https://www.sephora.com/productimages/sku/s2867117-av-011-zoom.jpg", "..."],
    "videos": [{ "title": "P515709av01.mp4", "url": "https://www.sephora.com/6369693433112", "thumbnail": "https://www.sephora.com/contentimages/VideoImagePXM/P515709av01-thumbnail.png" }],
    "variants": [
        {
            "skuId": "2867117",
            "name": "Black",
            "variationType": "Color",
            "size": "0.34 oz / 10 mL",
            "listPrice": "$26.00",
            "price": 26,
            "regularPrice": 26,
            "salePrice": null,
            "isOutOfStock": false,
            "isOnlyFewLeft": false,
            "isNew": false,
            "isLimitedEdition": false,
            "image": "https://www.sephora.com/productimages/sku/s2867117-main-zoom.jpg",
            "url": "https://www.sephora.com/product/badi-lash-smudge-proof-volumizing-tubing-mascara-P515709?skuId=2867117"
        }
    ],
    "reviewSummary": "Customers often find the applicator easy to use and mention positive experiences with no smudge and no clumping performance. Some reviews note occasional flaking, minor clumping, and a bit of dryness.",
    "sentiments": [{ "name": "Applicator", "type": "pros", "count": 76 }, { "name": "No Clumping", "type": "pros", "count": 41 }, { "name": "Flaking", "type": "cons", "count": 43 }],
    "detailsIncluded": true,
    "sourceType": "url",
    "scrapedAt": "2026-10-22T17:54:12.001Z"
}
```

Fill rates on the test runs (details on; 19 products locally across a search, a category, a brand and a URL, 18 products from Apify's cloud on Sephora Canada): name, brand, price, rating, reviews 100%; description, loves count, variants and category path 100% of the products whose page carries product data (2 of 18 gift sets in the cloud run had none and kept their listing row with `detailsError`); ingredients 72-95% (sets and some tools list none); size 50% (shown only for sized SKUs). A field Sephora does not have is `null`, never guessed.

### Why this one

Prices below are the Store's FREE-tier prices per 1,000 results, read in a live Apify Store search on 17 Nov 2026. Ours is $0.85 with no start fee, details included. The most-used Sephora product scrapers: autofacts/sephora (41 users in 30 days) $6.00 + $0.00005 per run; happyendpoint (9) $2.00 + $0.002 per run; sian.agency's catalog extractor (9) $29.00 + $0.005 per run; igview-owner (7) $20.00 + $0.02 per run; datasaurus (6) $2.00 per 1,000 listing rows, $5.00 per 1,000 product pages + $0.02 per run; abotapi (4) $1.80 + $0.50 per 1,000 detail rows + $0.06 per run. Closer on price: nice_dev (3) $0.89 + $0.01 per run, plus $0.45 per 1,000 for product details; dataspryva $0.99 + $0.10 per run; shahidirfan $1.00 + $0.0005 per run. Two free actors exist: buseta's collects reviews and Q\&A, and tufantoksoz's covers sephora.de only. Among the paid scrapers of sephora.com products we found, $0.85 is the lowest price per product row; actors that sell reviews only are priced per review and not compared here. Rivals' prices can change; check the Store page before you rely on this.

It also returns what a price monitor needs in one row: list price, regular price, sale price and `isOnSale` as separate fields, and with details on every shade or size with its own price and stock flag.

### Integrations

- **Make, Zapier and n8n**: run on a schedule and push price changes to Google Sheets, Slack, Airtable or your own database.
- **Google Sheets**: export the dataset straight into a spreadsheet.
- **Apify API**: run the actor and fetch results over REST, or with the official JavaScript and Python clients.
- **Webhooks**: get notified when a run finishes.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can call this Sephora API directly and read the results.

### Limits (read before large runs)

- **Search is Sephora's own**: a keyword search returns what the site's search returns, including loosely related products; a nonsense keyword returns Sephora's fallback picks (about 100 products) rather than an empty answer. Use a category or brand for a complete, exact set.
- **Listing prices can be ranges** (`"$9.90 - $17.50"`) when variants differ in price; `price` is the low end and `priceMax` the high end. Turn details on for the exact price of every variant.
- **Details cost one request per product** (about 1 MB each); a run of 1,000 detailed products takes roughly 15 minutes at the default 2 parallel requests. Listing-only runs do about 100 products per request.
- **Sephora (Akamai) blocks IPs that send bursts.** The actor paces requests, keeps each proxy session to a few dozen requests and rotates on a block; keep `proxyConfiguration` on Apify Proxy. Raising `maxConcurrency` above 3 mostly produces retries.
- **Product pages are not served to most datacenter proxy IPs** (HTTP 403), while the catalog API is. Listings therefore go through `proxyConfiguration` and product pages are fetched without a proxy by default; set `detailsUseProxy: true` only together with a RESIDENTIAL proxy.
- **Stock flags** (`isOutOfStock`, `isOnlyFewLeft`) are per variant and only in detailed rows; listings do not expose them.
- **Canada** uses the Canadian assortment and CAD prices (`country: "ca"`); there is no other country on sephora.com. Sephora's other sites (sephora.fr, .co.uk, .com.au...) are separate platforms and not covered.
- **Reviews themselves are not collected**, only the rating, the review count, the loves count and Sephora's sentiment tags.
- Only the catalog API and product pages are read; Sephora's HTML search and browse pages (disallowed in its robots.txt) are never requested.

Need a custom scraper or a ready dataset? Hire me on Fiverr: https://www.fiverr.com/rel8ble

# Actor input Schema

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

What to search for on Sephora, one search per line: "vitamin c serum", "tubing mascara", "sunscreen spf 50", a brand name or a product name. Each line is one search; results are merged. Typical: 1-50 lines.

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

Optional. Sephora category slugs or ids, one per line: "mascara", "foundation-makeup", "face-serum", "cat60026", or a sephora.com/shop/<slug> URL. The whole category is listed (paged), filters and sort apply.

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

Optional. Brand slugs as in sephora.com/brand/<slug>, one per line: "fenty-beauty-rihanna", "rare-beauty-selena-gomez", "the-ordinary", or the brand page URL. Every product of the brand is listed.

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

Optional. Any sephora.com link, one per line: a product page ("https://www.sephora.com/product/...-P515709", one full row each), a /shop/<category> page, a /brand/<slug> page or a /search?keyword=... page.

## `country` (type: `string`):

"us" (default) = sephora.com, prices in USD. "ca" = Sephora Canada, prices in CAD and the Canadian assortment.

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

Default false: one row per product from the listing (brand, name, price, sale price, rating, reviews, badges, variant count, image, URL) - about 100 products per request. True: also open every product page (one request each, about 1 MB) and add the description, ingredients, suggested usage, loves count, highlights, category path, all images and every variant (shade / size) with its own price, size and stock flags.

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

Order of the results, same options as the site: relevance (default), best selling, top rated, new, price low to high, price high to low. Useful with "Max results per query" (e.g. top 50 best sellers in a category).

## `minPrice` (type: `string`):

Optional. Keep only products priced at or above this (in the store currency), e.g. "25".

## `maxPrice` (type: `string`):

Optional. Keep only products priced at or below this, e.g. "50".

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

Optional. "4" = 4 stars and up, "3" = 3 stars and up (whole numbers 1-5).

## `brandFilter` (type: `array`):

Optional. Restrict a search or category to these brand names exactly as Sephora spells them, one per line: "Lancôme", "Benefit Cosmetics", "SEPHORA COLLECTION".

## `onSaleOnly` (type: `boolean`):

Keep only products with a sale price.

## `newOnly` (type: `boolean`):

Keep only products Sephora flags as new.

## `maxItemsPerQuery` (type: `integer`):

Stop each search / category / brand after this many products. 0 = everything Sephora lists. Default 100.

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

Stop the whole run after this many products. 0 = no limit. Default 1000 (= $0.85). The run also stops cleanly at the "Maximum cost per run" you set.

## `maxConcurrency` (type: `integer`):

How many requests to run at once. Default 2. Sephora (Akamai) blocks IPs that send bursts, so higher values mostly mean more retries.

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

How often a failed request is retried on a new session / IP before it is given up. Default 5.

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

Used for the listing requests (search, category, brand). Default: Apify Proxy (datacenter), which Sephora's catalog API serves. Each session makes a limited number of requests on one IP.

## `detailsUseProxy` (type: `boolean`):

Default false: product pages (details) are fetched without a proxy, because Sephora answers most datacenter proxy IPs with 403 on those pages while serving them to Apify's own IPs. Set true only together with a RESIDENTIAL proxy in "Proxy".

## Actor input object example

```json
{
  "searchQueries": [
    "mascara"
  ],
  "country": "us",
  "includeDetails": false,
  "sortBy": "relevance",
  "onSaleOnly": false,
  "newOnly": false,
  "maxItemsPerQuery": 100,
  "maxItems": 1000,
  "maxConcurrency": 2,
  "maxRequestRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "detailsUseProxy": false
}
```

# Actor output Schema

## `results` (type: `string`):

One row per product: brand, name, price, sale price, currency, rating, reviews, badges, variant count, image, URL; with details also description, ingredients, loves count, category path, images and every variant with price and stock flags.

## `summary` (type: `string`):

Per-search counts (Sephora total, pages read, results saved, stop reason), product pages fetched or failed, blocked answers and anything that failed with a hint.

# 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": [
        "mascara"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rel8ble/sephora-products-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": ["mascara"],
    "proxyConfiguration": { "useApifyProxy": True },
}

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

```

## MCP server setup

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