# Sephora Store Locator & Stock Checker — Find Nearby Stores (`sian.agency/sephora-store-locator-scraper`) Actor

Sephora store locator + in-stock checker. Find every Sephora store near any latitude/longitude in the US, or check whether a specific SKU is in stock at nearby stores. 38 fields per store — address, hours, phone, BOPIS / curbside / same-day delivery flags. JSON / CSV export. No Sephora API key.

- **URL**: https://apify.com/sian.agency/sephora-store-locator-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 store row returneds

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Sephora Store Locator & Stock Checker

[![Store](https://img.shields.io/badge/Store-Apify-blueviolet)](https://apify.com/sian.agency/sephora-store-locator-scraper?fpr=sian)
[![Store-Catalog](https://img.shields.io/badge/Store-Catalog-pink)](https://apify.com/sian.agency/best-sephora-product-catalog-extractor?fpr=sian)
[![Store-Reviews](https://img.shields.io/badge/Store-Reviews-pink)](https://apify.com/sian.agency/best-sephora-product-information-extractor?fpr=sian)
[![Store-More-by-SIÁN](https://img.shields.io/badge/Store-More%20by%20SI%C3%81N-pink)](https://apify.com/sian.agency?fpr=sian)

**Find every Sephora store near any address in the US — and check which of them have a specific product in stock.** Powered by sephora.com's own store-locator and inventory feeds.

### What it does

- **Find stores near coordinates** — pass a latitude + longitude (and an optional radius in miles) and get back every Sephora storefront in range with full address, opening hours, phone, services, and same-day-delivery flags.
- **Check SKU stock near coordinates** — pass the same coordinates plus a Sephora SKU ID and see which of those stores currently carry it.

No proxies, no setup, no Sephora API key required.

### Why use it

- **Store-finder for your customers** — build a "nearest store" widget on your own ecommerce site without scraping the Sephora UI yourself.
- **Lead routing** — match a buyer's ZIP to the closest Sephora storefront for fulfillment hand-off.
- **Local inventory monitoring** — track whether a specific SKU is stocked in your home market, weekly or daily, with scheduled Apify runs.
- **Trade-area research** — pull every Sephora store in a state to model market coverage versus competitors (Ulta, Bluemercury).
- **Beauty influencer logistics** — figure out which stores within driving distance have the new launch in stock, before it sells out.

### Quick start

1. Choose **Find stores** or **Check SKU stock**.
2. Paste a **latitude** and **longitude** (use Google Maps → right-click → "What's here?" to get them).
3. (Optional) Adjust the **radius** in miles. Default 25.
4. (Stock mode only) Paste a **SKU ID**. Find SKUs on sephora.com or via our [Sephora Catalog Scraper](https://apify.com/sian.agency/best-sephora-product-catalog-extractor?fpr=sian).
5. Hit **Save & Start**.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `action` | enum | ✅ | `storeSearch` or `productAvailability` |
| `latitude` | string | ✅ | Decimal latitude (-90 to 90), e.g. `40.7549` |
| `longitude` | string | ✅ | Decimal longitude (-180 to 180), e.g. `-73.9840` |
| `radius` | string | optional | Search radius in miles, 1–500 (default 25) |
| `skuId` | string | required for stock mode | Sephora SKU ID, e.g. `2495505` |

#### Example coordinates

| City | Latitude | Longitude |
|---|---|---|
| New York Midtown | `40.7549` | `-73.9840` |
| Beverly Hills | `34.0736` | `-118.4004` |
| Miami Beach | `25.7907` | `-80.1300` |
| Chicago Loop | `41.8781` | `-87.6298` |
| Houston Galleria | `29.7396` | `-95.4612` |
| San Francisco Union Square | `37.7879` | `-122.4075` |

### Output

Each result row contains **38 fields**:

**Identity:** `storeId`, `displayName`, `storeType`, `startDate`, `endDate`, `sourceUrl`
**Geo:** `latitude`, `longitude`, `distanceMiles`
**Address:** `address1`, `address2`, `city`, `state`, `postalCode`, `country`, `phone`, `mallName`, `timezone`, `districtName`, `regionalName`
**Hours:** `mondayHours` … `sundayHours`
**Services:** `isBopisable`, `isCurbsideEnabled`, `isOnlineReservationEnabled`, `instacartShoppingEnabled`, `samedayDeliveryEnabled`, `shipFromStoreEnabled`, `servicesOffered[]`
**Query echo:** `queryLatitude`, `queryLongitude`, `queryRadiusMiles`, `querySkuId`
**Meta:** `itemType`, `processedAt`

Plus an HTML summary report saved to the Key-Value Store (`report.html`) with a top-15 store table and a coverage breakdown by state.

### Pricing

| Plan | Stores per run | Best for |
|---|---|---|
| FREE | 5 | Testing, demos |
| PAID | Unlimited | Production, scheduling, multi-region surveys |

Event-based pricing — pay only for the rows you receive. Free runs deduct from your Apify credits.

### FAQ

**Q. Does this cover Sephora outside the US?**
Not yet. This actor currently uses the US store endpoint. Sephora EU (FR, DE, IT, ES, PL, RO, GR, CZ, PT, TR, DK, SE, CH, HR) has separate endpoints that we'll add in a follow-up.

**Q. Why latitude/longitude instead of a ZIP?**
The upstream endpoint accepts coordinates, not ZIP codes. You can convert a ZIP to coordinates for free with any geocoder (Google, OpenStreetMap, etc.). Future versions may add a ZIP shortcut.

**Q. How fresh is the stock data?**
Pulled live each run from the same feed sephora.com uses on its own product pages. Schedule a daily run if you need rolling history.

**Q. Can I check multiple SKUs in one run?**
Not currently — one SKU per run. Use multiple scheduled runs or fan out via Apify task automation. We may add bulk SKU mode based on demand.

**Q. Why does the SKU stock check sometimes return no results?**
Either no Sephora store within the radius carries that SKU, or the SKU has gone out of stock nationwide. Widen the radius first.

### Troubleshooting

- **"latitude and longitude are required"** — both fields must be filled with decimal values.
- **"action='productAvailability' requires a skuId"** — switch to **Find stores** mode if you don't have a SKU yet.
- **Empty results in a major city** — the upstream may be temporarily slow. Re-run the actor.

### Related actors by SIÁN

- [Sephora Product Catalog Scraper](https://apify.com/sian.agency/best-sephora-product-catalog-extractor?fpr=sian) — pull catalogs by brand, category, or keyword. Use this to find the SKUs you want to track.
- [Sephora Product Details & Reviews Scraper](https://apify.com/sian.agency/best-sephora-product-information-extractor?fpr=sian) — full product specs, ingredients, and reviews with demographic breakdowns.

[More actors by SIÁN →](https://apify.com/sian.agency?fpr=sian)

### Legal

This is an independent tool built by SIÁN Agency. It is not affiliated with, endorsed by, or sponsored by Sephora USA, Inc., Sephora SA, or LVMH Moët Hennessy Louis Vuitton SE. "Sephora" is a trademark of its respective owners. We use the name strictly under nominative-fair-use to describe what this tool does.

Use this actor only for purposes that comply with sephora.com's Terms of Service and applicable law.

---

<sub>Keywords: sephora store locator, sephora near me, sephora stock check, sephora inventory, sephora BOPIS, sephora curbside pickup, sephora same day delivery, sephora store hours, sephora store finder, sephora API alternative, beauty store locator, retail store finder, store availability checker, in-store stock checker, local inventory scraper</sub>

# Actor input Schema

## `action` (type: `string`):

**Find stores** lists Sephora stores near a coordinate. **Check stock** lists nearby stores that currently carry a specific SKU.
## `latitude` (type: `string`):

Latitude of the search center, e.g. New York Midtown = `40.7549`, Beverly Hills = `34.0736`, Miami Beach = `25.7907`. Use Google Maps right-click → 'What's here?' to get coordinates.
## `longitude` (type: `string`):

Longitude of the search center, e.g. New York Midtown = `-73.9840`, Beverly Hills = `-118.4004`, Miami Beach = `-80.1300`.
## `radius` (type: `string`):

Search radius in miles. Range 1–500. Default 25.
## `skuId` (type: `string`):

Sephora SKU ID to check stock for. **Required when action = 'Check SKU stock'**, ignored otherwise. Find SKU IDs from sephora.com product pages or our [Sephora Catalog Scraper](https://apify.com/sian.agency/best-sephora-product-catalog-extractor?fpr=sian). Example: `2495505` (Rare Beauty Soft Pinch Liquid Blush).

## Actor input object example

```json
{
  "action": "storeSearch",
  "latitude": "40.7549",
  "longitude": "-73.9840",
  "radius": "25"
}
````

# Actor output Schema

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

Complete store list with address, hours, phone, and per-store services.

## `htmlReport` (type: `string`):

Visual summary with closest store, services coverage, and breakdown by state.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/sephora-store-locator-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/sephora-store-locator-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call sian.agency/sephora-store-locator-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/sephora-store-locator-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Sephora Store Locator & Stock Checker — Find Nearby Stores",
        "description": "Sephora store locator + in-stock checker. Find every Sephora store near any latitude/longitude in the US, or check whether a specific SKU is in stock at nearby stores. 38 fields per store — address, hours, phone, BOPIS / curbside / same-day delivery flags. JSON / CSV export. No Sephora API key.",
        "version": "1.0",
        "x-build-id": "Dd085s2vwB9Usu4wW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~sephora-store-locator-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-sephora-store-locator-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~sephora-store-locator-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-sephora-store-locator-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~sephora-store-locator-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-sephora-store-locator-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "action",
                    "latitude",
                    "longitude"
                ],
                "properties": {
                    "action": {
                        "title": "🎯 What do you want to do?",
                        "enum": [
                            "storeSearch",
                            "productAvailability"
                        ],
                        "type": "string",
                        "description": "**Find stores** lists Sephora stores near a coordinate. **Check stock** lists nearby stores that currently carry a specific SKU.",
                        "default": "storeSearch"
                    },
                    "latitude": {
                        "title": "📍 Latitude",
                        "type": "string",
                        "description": "Latitude of the search center, e.g. New York Midtown = `40.7549`, Beverly Hills = `34.0736`, Miami Beach = `25.7907`. Use Google Maps right-click → 'What's here?' to get coordinates.",
                        "default": "40.7549"
                    },
                    "longitude": {
                        "title": "📍 Longitude",
                        "type": "string",
                        "description": "Longitude of the search center, e.g. New York Midtown = `-73.9840`, Beverly Hills = `-118.4004`, Miami Beach = `-80.1300`.",
                        "default": "-73.9840"
                    },
                    "radius": {
                        "title": "📏 Radius (miles)",
                        "type": "string",
                        "description": "Search radius in miles. Range 1–500. Default 25.",
                        "default": "25"
                    },
                    "skuId": {
                        "title": "🏷️ SKU ID (required when checking stock)",
                        "type": "string",
                        "description": "Sephora SKU ID to check stock for. **Required when action = 'Check SKU stock'**, ignored otherwise. Find SKU IDs from sephora.com product pages or our [Sephora Catalog Scraper](https://apify.com/sian.agency/best-sephora-product-catalog-extractor?fpr=sian). Example: `2495505` (Rare Beauty Soft Pinch Liquid Blush)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```