# Staples Store Locator Scraper (`datacach/staples-store-locator-scraper`) Actor
Crawls the Staples.com store locator directory (states, cities, stores) to extract unique Staples store page URLs across the US. No browser or API key needed — ideal for building location datasets or feeding downstream store-detail scrapers.
- **URL**: https://apify.com/datacach/staples-store-locator-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.50 / 1,000 links
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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
## Staples Store Locator Scraper
**Collect every Staples store page URL** from the official [Staples.com store locator](https://stores.staples.com/) in one run — no browser, no API key, and no start URLs to configure. This Actor walks the public directory hierarchy (US index → states → cities → stores) with plain HTTP requests and returns a clean, **deduplicated list of store links** ready to feed a downstream store-detail scraper or a location database.
### What is Staples Store Locator Scraper?
Staples Store Locator Scraper is an Apify Actor that **extracts Staples store page URLs** by crawling `stores.staples.com` level by level: the national index page, every US state page, every city page, and finally each individual store page. Each result is a **unique store link** with a discovery label and an extraction timestamp, pushed straight to an Apify **dataset**. It's built for people who need a bulk list of Staples store URLs — for lead generation, market coverage analysis, or as the input to a Staples store-detail (address/phone/geo/hours) Actor — without writing or maintaining their own crawler.
### What can Staples Store Locator Scraper do?
- 🧭 **Zero-config crawl** — click Run; no start URLs, search terms, or coordinates required.
- 🔗 **Full US directory coverage** — walks all 50 states + DC via the store-locator index, then every city and store beneath them.
- 🧹 **Automatic deduplication** — the same store URL is never saved twice, even across cities that link to a shared page.
- ⏱️ **Extraction timestamps** — every item includes a UTC ISO-8601 timestamp and a `mm-dd-yyyy` date, so you can track when each link was collected.
- 🔁 **Resumable runs** — if the run is migrated or restarted by the platform, already-pushed links and fully-crawled states are checkpointed and never re-emitted (and never re-billed under pay-per-result).
- ⏭️ **Pay-per-result-safe pagination** — `startIndex` and `excludeUrls` let you split the directory across multiple runs and skip links you already collected, so you're only charged for new data.
- 🚫 **No browser, no API key** — pure HTTP requests against public HTML pages, which makes runs fast and lightweight.
- 📤 **Flexible export** — download results as JSON, CSV, Excel, HTML, or XML directly from the dataset.
- ☁️ **Full Apify platform integration** — trigger runs via the **API**, schedule recurring crawls, monitor runs from the Apify Console, and connect to **Zapier**, **Make**, or webhooks for downstream automation.
### What data does Staples Store Locator Scraper extract?
Each dataset item represents a single Staples store page URL discovered during the crawl:
| Field | Type | Description | Example |
|---|---|---|---|
| `url` | string | Store page URL on `stores.staples.com` | `https://stores.staples.com/al/athens/1036-highway-72-east` |
| `coordinate` | string | Label for the source the link was found under (currently `"static source"`, since the directory crawl doesn't require coordinates) | `static source` |
| `extraction_datetime` | string | UTC timestamp the link was extracted, ISO 8601 | `2026-07-21T14:30:00.123456+00:00` |
| `extraction_date` | string | Extraction date only, `mm-dd-yyyy` | `07-21-2026` |
### How do I use Staples Store Locator Scraper to get Staples store links?
1. Open the Actor and go to the **Input** tab.
2. (Optional) Set **Max store links** (`maxResults`) if you only want a limited number of links — leave it at `0` to collect every store link in the directory.
3. (Optional) If you're paginating across multiple runs or already have some links, set **Start index** (`startIndex`) and/or **Exclude URLs** (`excludeUrls`) so you don't pay for links you already have — see the **Input** section below.
4. Click **Start**.
5. When the run finishes, open the **Output** tab (or the **Dataset** tab) to preview, filter, and export the collected store links.
### Input
The Actor needs **no required input** — you can run it with the default settings and it will crawl the entire Staples store-locator directory. Three optional fields let you control how much is collected and avoid duplicate charges under pay-per-result:
- **Max store links** (`maxResults`, integer, default `0`) — the maximum number of unique store links to collect before the run stops. `0` means unlimited (collect everything found). Free-plan runs are always capped at 10 links regardless of this setting.
- **Start index** (`startIndex`, integer, default `0`) — skip this many links from the start of the directory walk (positionally) before saving any. Useful for paginating a large crawl across multiple runs — e.g. set it to `500` once you already have the first 500 links. Ignored (forced to `0`) on the free plan.
- **Exclude URLs (already collected)** (`excludeUrls`, array of strings, default `[]`) — a list of store URLs you already have; these are never saved again no matter where they fall in the crawl order. Capped to 1 URL on the free plan.
Example input:
```json
{
"maxResults": 0,
"startIndex": 0,
"excludeUrls": []
}
````
### Output example
```json
{
"url": "https://stores.staples.com/al/athens/1036-highway-72-east",
"coordinate": "static source",
"extraction_datetime": "2026-07-21T14:30:00.123456+00:00",
"extraction_date": "07-21-2026"
}
```
You can download the dataset in **JSON, CSV, Excel, HTML, or XML** format from the Apify Console, or fetch it programmatically via the [Apify API](https://docs.apify.com/api/v2) or SDK.
### Use cases
- **Feed a store-detail scraper** — pass the collected URLs into the companion [Staples Store Details Scraper](https://apify.com/datacach/staples-store-details-scraper) to enrich each link with address, phone number, geolocation, and hours.
- **Build a location coverage map** — get a full list of every physical Staples location in the US to analyze market density or plan territory coverage.
- **Lead generation for B2B outreach** — use store URLs and locations as a starting point for local-business outreach lists.
- **Monitor directory changes over time** — schedule recurring runs and diff the dataset to catch new store openings or removed locations.
- **Populate a store-locator widget or internal dataset** — keep an internal database of Staples store pages in sync without manually browsing the site.
### Staples-related Actors
| Actor | What it does |
|---|---|
| [Staples Store Details Scraper](https://apify.com/datacach/staples-store-details-scraper) | Takes store links (like the ones from this Actor) and extracts full store details — address, phone, geolocation, hours. |
### FAQ
#### Is it legal to scrape Staples store locator data?
This Actor only collects **publicly available URLs** from the same public directory pages `stores.staples.com` serves to any visitor's browser — no login, no private data, and no personal information. That said, scraping legality can depend on your jurisdiction and intended use, and you're responsible for complying with Staples' Terms of Service. Consult a legal professional if you're unsure about your specific use case.
#### Does this Actor need an API key or proxy configuration?
No. It crawls `stores.staples.com` with plain HTTP requests — no browser, no API key, and no proxy configuration required to run it.
#### Can I access the results via the Apify API?
Yes. Every dataset produced by this Actor is available through the [Apify API](https://docs.apify.com/api/v2), so you can fetch results, trigger runs, and integrate the Actor into your own pipelines, Zapier/Make scenarios, or scheduled jobs directly from the Apify Console.
#### What happens if a directory page is blocked?
If a request to a directory page (index, state, or city) is blocked by anti-bot protection, the crawl for that specific source stops and the event is logged — it does not fail the whole run, so links already collected are preserved.
#### How do I avoid getting duplicate links across multiple runs?
Use **Start index** (`startIndex`) to skip a fixed number of links positionally, and/or **Exclude URLs** (`excludeUrls`) to skip specific URLs you already have — both are pay-per-result-safe. The Actor also checkpoints its own progress internally, so a run that's migrated or resumed by the platform never re-pushes (or re-charges for) a link it already emitted.
### Support
Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab in Apify Console. For a tailored crawl (custom fields, different regions, or a fully custom scraper), reach out via the Actor's contact options for a custom solution.
# Actor input Schema
## `maxResults` (type: `integer`):
Maximum number of unique Staples store links to collect before the run stops. Set to 0 to collect every store link found in the directory (unlimited). For example, enter 50 to grab just the first 50 stores for a quick test. Note: free-plan accounts are always capped at 10 links, no matter what you set here.
## `startIndex` (type: `integer`):
Skip this many store links from the start of the directory walk before saving any. Use it to paginate across runs: if you already have the first 500 links, set 500 here to begin from link 501 and avoid paying for links you already have. Links are discovered by walking the store-locator directory (states → cities → stores) in a fixed order, so index N is reproducible between runs as long as Staples' directory doesn't change. The Actor still has to walk the directory up to that point, so a large value does not make the run faster — it only changes which links are saved (and, under pay-per-result, which ones you're charged for). Combined with Max store links, the saved range is \[startIndex, startIndex + maxResults). Ignored (forced to 0) on the free plan.
## `excludeUrls` (type: `array`):
Store link URLs you already have. Any URL listed here is never saved again, regardless of where it falls in the directory walk. Unlike Start index, this is order-independent — ideal when you keep a running list of URLs and only want the new ones. Applied after Start index. Free-plan runs may list at most 1 URL here.
## Actor input object example
```json
{
"maxResults": 0,
"startIndex": 0,
"excludeUrls": []
}
```
# Actor output Schema
## `dataset` (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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"excludeUrls": []
};
// Run the Actor and wait for it to finish
const run = await client.actor("datacach/staples-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "excludeUrls": [] }
# Run the Actor and wait for it to finish
run = client.actor("datacach/staples-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 '{
"excludeUrls": []
}' |
apify call datacach/staples-store-locator-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=datacach/staples-store-locator-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Staples Store Locator Scraper",
"description": "Crawls the Staples.com store locator directory (states, cities, stores) to extract unique Staples store page URLs across the US. No browser or API key needed — ideal for building location datasets or feeding downstream store-detail scrapers.",
"version": "0.0",
"x-build-id": "791bD6CvT0A6ImSpb"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/datacach~staples-store-locator-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-datacach-staples-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/datacach~staples-store-locator-scraper/runs": {
"post": {
"operationId": "runs-sync-datacach-staples-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/datacach~staples-store-locator-scraper/run-sync": {
"post": {
"operationId": "run-sync-datacach-staples-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",
"properties": {
"maxResults": {
"title": "Max store links",
"minimum": 0,
"type": "integer",
"description": "Maximum number of unique Staples store links to collect before the run stops. Set to 0 to collect every store link found in the directory (unlimited). For example, enter 50 to grab just the first 50 stores for a quick test. Note: free-plan accounts are always capped at 10 links, no matter what you set here.",
"default": 0
},
"startIndex": {
"title": "Start index",
"minimum": 0,
"type": "integer",
"description": "Skip this many store links from the start of the directory walk before saving any. Use it to paginate across runs: if you already have the first 500 links, set 500 here to begin from link 501 and avoid paying for links you already have. Links are discovered by walking the store-locator directory (states → cities → stores) in a fixed order, so index N is reproducible between runs as long as Staples' directory doesn't change. The Actor still has to walk the directory up to that point, so a large value does not make the run faster — it only changes which links are saved (and, under pay-per-result, which ones you're charged for). Combined with Max store links, the saved range is [startIndex, startIndex + maxResults). Ignored (forced to 0) on the free plan.",
"default": 0
},
"excludeUrls": {
"title": "Exclude URLs (already collected)",
"type": "array",
"description": "Store link URLs you already have. Any URL listed here is never saved again, regardless of where it falls in the directory walk. Unlike Start index, this is order-independent — ideal when you keep a running list of URLs and only want the new ones. Applied after Start index. Free-plan runs may list at most 1 URL here.",
"default": [],
"items": {
"type": "string"
}
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```