# Staples Product Ratings & Review Summary Scraper (`automation-lab/staples-product-ratings-review-summary-scraper`) Actor

Track Staples product ratings, review counts, star distributions, Q\&A totals, and review-derived AI summaries by URL or item number.

- **URL**: https://apify.com/automation-lab/staples-product-ratings-review-summary-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Product Ratings & Review Summary Scraper

Monitor Staples product reputation without manually opening every product page.

This Apify Actor turns Staples product URLs or item numbers into structured rating snapshots: aggregate rating, total reviews, Q&A count, every 1–5-star bucket, and Staples' review-derived AI summary when one is available.

Use the dataset in spreadsheets, dashboards, alerts, catalog systems, or scheduled brand-monitoring workflows.

> V1 extracts review intelligence and aggregate metrics. It does not extract individual customer review text.

### What does Staples Product Ratings & Review Summary Scraper do?

The Actor accepts one or many Staples products and returns one current snapshot per product.

It extracts:

- 🆔 Staples item and part numbers
- 🏷️ Product name and brand
- ⭐ Aggregate rating
- 💬 Total review count
- ❓ Product Q&A count
- 📊 Review counts and percentages for ratings 1 through 5
- 🧠 Staples' review-derived AI summary, when present
- 🔗 Canonical Staples product URL
- 🕒 Exact extraction timestamp

The Actor uses a first-party Staples JSON surface rather than rendering a browser page, making normal runs fast and lightweight.

### Who is it for?

#### Ecommerce brands

Track whether product sentiment is improving or deteriorating across the Staples catalog.

#### Office-supply vendors

Monitor rating distributions for your products and competing SKUs on a schedule.

#### Product and reputation analysts

Collect consistent KPI snapshots for dashboards, weekly reports, and anomaly alerts.

#### Catalog teams

Enrich internal item records with public rating totals, Q&A activity, and canonical URLs.

#### Researchers

Compare review concentration across stars without manually transcribing product-page widgets.

### Why use this Staples reviews scraper?

Manual review monitoring is repetitive and difficult to compare over time.

The Actor provides:

- **Structured data** instead of copied page text
- **Batch processing** for up to 1,000 products per run
- **SKU resolution** from bare Staples item numbers
- **Scheduling** through standard Apify tasks
- **Per-product resilience** so one unavailable item does not stop a valid batch
- **Timestamped snapshots** suitable for trend monitoring
- **Exports** to JSON, CSV, Excel, XML, and other Apify dataset formats

### What data can I extract from Staples products?

| Field | Type | Description |
|---|---|---|
| `status` | string | `ok` for a product record or `error` for an optional failure record |
| `itemNumber` | string | Staples item identifier |
| `staplesPartNumber` | string or null | Staples part number returned by the product API |
| `manufacturerPartNumber` | string or null | Manufacturer part number when available |
| `name` | string | Product name |
| `brand` | string or null | Product brand |
| `canonicalUrl` | string | Canonical Staples product URL |
| `sourceUrl` | string | URL or item number supplied in input |
| `rating` | number or null | Current aggregate rating |
| `reviewCount` | integer | Current total number of reviews |
| `questionAnswerCount` | integer | Current product Q&A count |
| `ratingDistribution` | array | 1–5-star buckets with count and percentage |
| `aiReviewSummary` | string or null | Staples-provided review-derived summary; never synthesized |
| `scrapedAt` | string | UTC ISO 8601 extraction time |
| `error` | string | Failure explanation on optional error rows |

Nullable fields stay nullable when Staples does not provide them.

### How do I scrape Staples product ratings?

1. Open the Actor input page.
2. Paste one or more full Staples product URLs.
3. Optionally add bare numeric Staples item numbers.
4. Keep the default concurrency for a normal batch.
5. Click **Start**.
6. Open the default dataset when the run finishes.
7. Export the results or connect an integration.

The prefilled example uses one product and normally completes well under two minutes.

### Input

A simple URL run:

```json
{
  "productUrls": [
    "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
  ]
}
````

A bare item-number run:

```json
{
  "productUrls": [],
  "skus": ["24503591"]
}
```

A mixed monitoring batch:

```json
{
  "productUrls": [
    "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
  ],
  "skus": ["24488589"],
  "maxConcurrency": 2,
  "maxRetries": 2,
  "includeErrorRecords": true
}
```

### Input options

#### `productUrls`

Full `staples.com` product URLs.

Other domains and non-product Staples pages are rejected rather than guessed.

#### `skus`

Numeric Staples item numbers between 5 and 12 digits.

The Actor resolves each item number to its canonical product path before extraction.

#### `maxConcurrency`

Number of products fetched at once.

Default: `5`.

Allowed range: `1` to `20`.

Use a lower value if a very large scheduled batch encounters rate limiting.

#### `maxRetries`

Number of retries for transient network, rate-limit, or server failures.

Default: `2`.

Allowed range: `0` to `5`.

#### `includeErrorRecords`

When enabled, failed products produce a free diagnostic row while valid products continue.

Error rows are not charged as successful product results.

#### `proxyConfiguration`

Local runs try direct HTTP first and use the configured proxy on retries. Cloud runs use the configured proxy immediately because Staples drops requests from cloud datacenter egress.

The default US residential Apify Proxy setting is recommended. Proxy rotation remains bounded by the retry limit.

### Output example

```json
{
  "status": "ok",
  "itemNumber": "24503591",
  "staplesPartNumber": "24503591",
  "manufacturerPartNumber": "9472524",
  "name": "Epson EcoTank Photo ET-8550 Wireless Color Inkjet Printer, All-In-One Supertank, Print, Scan, Copy (9472524)",
  "brand": "Epson",
  "canonicalUrl": "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591",
  "sourceUrl": "24503591",
  "rating": 4.39,
  "reviewCount": 512,
  "questionAnswerCount": 41,
  "ratingDistribution": [
    { "rating": 1, "reviewCount": 42, "reviewPercent": 8 },
    { "rating": 2, "reviewCount": 15, "reviewPercent": 3 },
    { "rating": 3, "reviewCount": 20, "reviewPercent": 4 },
    { "rating": 4, "reviewCount": 57, "reviewPercent": 11 },
    { "rating": 5, "reviewCount": 378, "reviewPercent": 74 }
  ],
  "aiReviewSummary": "The Epson ET-8550 printer is praised for its excellent photo print quality...",
  "scrapedAt": "2026-07-18T00:00:00.000Z"
}
```

Values change as Staples receives new ratings, questions, or product updates.

### Understanding the rating distribution

Each entry in `ratingDistribution` contains:

- `rating`: star value from 1 to 5
- `reviewCount`: reviews in that bucket
- `reviewPercent`: Staples' displayed percentage for that bucket

The array is sorted from 1 star to 5 stars.

Do not assume rounded percentages always total exactly 100.

### About the AI review summary

`aiReviewSummary` is review-derived prose supplied by Staples.

The Actor does not generate, rewrite, or infer this text.

Products with too few reviews may not have a summary; those records return `null`.

Treat the summary as a quick signal and use the distribution and count fields for quantitative analysis.

### How much does it cost to scrape Staples product ratings?

This Actor uses pay-per-event pricing:

- A **$0.005** one-time fee starts each run.
- One product-result event is charged per successfully extracted product.
- Error rows are free.
- Subscription tiers receive decreasing per-product prices.

| Apify tier | Price per successful product |
|---|---:|
| FREE | $0.0028688 |
| BRONZE | $0.0024946 |
| SILVER | $0.0019458 |
| GOLD | $0.0014968 |
| PLATINUM | $0.00099786 |
| DIAMOND | $0.0006985 |

The Apify Console shows the active tier and estimated maximum charge before you start a run.

Keep related products in one batch to avoid paying the start fee repeatedly.

### Monitoring Staples ratings over time

Create an Apify task with a stable list of URLs or item numbers.

Schedule it daily, weekly, or monthly.

Send each resulting dataset to:

- Google Sheets for a lightweight tracker
- a webhook for alert processing
- cloud storage for historical snapshots
- a database or BI tool for trends

Compare `rating`, `reviewCount`, and each star bucket between timestamps.

### Tips for reliable runs

- Prefer full product URLs when they are already available in your catalog.
- Use item numbers when your source system stores Staples IDs only.
- Deduplicate inputs; the Actor also deduplicates the same item within one run.
- Keep the default concurrency for small and medium batches.
- Schedule batches instead of manually repeating runs.
- Keep error rows enabled while validating a new catalog list.
- Retry unavailable items later rather than interpreting a network error as zero reviews.

### Error handling

Invalid domains and malformed product URLs fail closed.

A mixed batch continues after individual failures.

If every requested product fails, the run exits with a non-zero status so automations can detect the failure.

Common error rows include the original input, parsed item number when known, timestamp, and a concise message.

### Integrations

#### Google Sheets

Append scheduled snapshots and chart review-count or rating changes by item number.

#### Webhooks

Trigger an alert when downstream logic detects a rating drop or a surge in low-star review counts.

#### Make and Zapier

Start the Actor from an automation, wait for completion, and route dataset records into catalog or reporting tools.

#### Cloud storage

Export dated JSON or CSV files to preserve historical product reputation snapshots.

#### Apify API

Start runs and retrieve datasets from your own application or data pipeline.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/staples-product-ratings-review-summary-scraper').call({
  skus: ['24503591'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/staples-product-ratings-review-summary-scraper').call(
    run_input={'skus': ['24503591']}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~staples-product-ratings-review-summary-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"skus":["24503591"]}'
```

Retrieve dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"
```

### Use with Apify MCP

Connect the Actor to AI assistants through Apify MCP at:

```text
https://mcp.apify.com?tools=automation-lab/staples-product-ratings-review-summary-scraper
```

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/staples-product-ratings-review-summary-scraper"
```

#### Claude Desktop setup

Add this to the `mcpServers` object in the Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify-staples-ratings": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/staples-product-ratings-review-summary-scraper"
    }
  }
}
```

#### Cursor setup

Add the same `mcpServers` JSON to Cursor's MCP settings and enable `apify-staples-ratings`.

#### VS Code setup

Open the MCP configuration in VS Code, add the HTTP server URL above, and start the server from the MCP servers view.

#### Example prompts

Claude Code:

> Run the Staples product ratings scraper for item 24503591 and summarize the 1–5-star distribution.

Example Claude Desktop prompt:

> Monitor these Staples product URLs and compare their rating, review count, and Q\&A count in a table.

Example Cursor or VS Code prompt:

> Extract Staples item 24503591 and flag any star bucket that represents more than 20 percent of reviews.

The AI assistant can start a run and inspect the resulting dataset through the configured Actor tool.

### Scheduling and notifications

Save your input as an Apify task.

Choose a schedule appropriate for how quickly the product category changes.

Use a webhook on run success to process new snapshots.

Use a webhook on run failure to notify an operator when all products fail.

Avoid treating missing summaries as failures; they are legitimately absent on some products.

### Limitations

- Only public `staples.com` product records are supported.
- The source endpoint is undocumented and may change.
- Individual review text, reviewer profiles, and review dates are not included in v1.
- The AI review summary can be absent.
- Deleted, redirected, restricted, or unavailable products may return error rows.
- Ratings and counts reflect Staples at extraction time.
- The Actor does not infer missing values.

### Is scraping Staples legal?

This Actor extracts publicly accessible product rating metadata.

Web scraping laws and contract terms vary by jurisdiction and use case.

You are responsible for ensuring that your use complies with applicable laws, Staples' terms, intellectual-property rights, and organizational policies.

Avoid collecting unnecessary personal data, do not attempt to bypass authentication, and use conservative request rates.

This documentation is not legal advice.

### Troubleshooting

#### Why did my URL return an error?

Confirm that the host is `staples.com` and the path ends in `/product_<item number>`.

Search pages, category pages, and URLs from other Staples country sites are not product inputs.

#### Why is `aiReviewSummary` null?

Staples does not provide a review-derived summary for every product, especially products with little review history.

The Actor intentionally does not synthesize one.

#### Why did the whole run fail?

The Actor fails the run when no product can be extracted.

Review logs and optional error rows for invalid inputs, unavailable item numbers, or a temporary Staples response issue.

#### Why are percentages not exactly 100?

Staples returns rounded percentages for each star bucket.

Small rounding differences are expected.

### Frequently asked questions

#### Can I submit both URLs and item numbers?

Yes. The Actor combines both lists and deduplicates repeated item numbers.

#### Does it scrape individual reviews?

No. V1 focuses on aggregate review intelligence and Staples' available summary.

#### Can I run it on a schedule?

Yes. Save the input as a task and attach an Apify schedule.

#### Are failed products charged?

No product-result event is charged for an error row.

#### How many products can one run accept?

Up to 1,000 combined URL and item-number inputs.

#### Does it require a proxy or login?

It requires no login. Local runs use anonymous first-party JSON directly; cloud runs use the default US residential Apify Proxy because Staples drops datacenter egress.

### Related scrapers

Use these Automation Lab actors for review intelligence on other major retailers:

- [Amazon Reviews Scraper](https://apify.com/automation-lab/amazon-reviews-scraper)
- [Walmart Reviews Scraper](https://apify.com/automation-lab/walmart-reviews-scraper)

Choose this Actor specifically when the products and review KPIs come from Staples.

### Data quality principles

The Actor preserves source values instead of inventing missing data.

It returns numeric counts as numbers, timestamps in UTC, and canonical absolute URLs.

It charges only after a successful product record is saved.

It exposes complete extraction failure through a non-zero run status.

These properties make the dataset suitable for repeatable monitoring and automated downstream checks.

### Start monitoring Staples product reviews

Add a product URL or item number, run the prefilled example, and inspect the dataset.

Then save a task and schedule the same input to build a rating history for the products your team cares about.

# Actor input Schema

## `productUrls` (type: `array`):

Full staples.com product URLs. URLs outside Staples or non-product pages are rejected.

## `skus` (type: `array`):

Numeric Staples item numbers (for example 24503591). The Actor resolves each number to its canonical product path.

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

Number of Staples products fetched at once. Lower this if the source begins rate-limiting a large batch.

## `maxRetries` (type: `integer`):

Retries transient network, rate-limit, and server errors with exponential backoff.

## `includeErrorRecords` (type: `boolean`):

Write an uncharged error row for products that fail while allowing valid products in the batch to continue.

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

Cloud runs use a US residential proxy because Staples drops cloud datacenter requests. Local runs try direct HTTP first and use this proxy on retries.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
  ],
  "skus": [],
  "maxConcurrency": 5,
  "maxRetries": 2,
  "includeErrorRecords": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productUrls": [
        "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
    ],
    "maxConcurrency": 5,
    "maxRetries": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/staples-product-ratings-review-summary-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 = {
    "productUrls": ["https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"],
    "maxConcurrency": 5,
    "maxRetries": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/staples-product-ratings-review-summary-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 '{
  "productUrls": [
    "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
  ],
  "maxConcurrency": 5,
  "maxRetries": 2
}' |
apify call automation-lab/staples-product-ratings-review-summary-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/staples-product-ratings-review-summary-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Staples Product Ratings & Review Summary Scraper",
        "description": "Track Staples product ratings, review counts, star distributions, Q&A totals, and review-derived AI summaries by URL or item number.",
        "version": "0.1",
        "x-build-id": "Lz5HZwK91XBfvmzqa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~staples-product-ratings-review-summary-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-staples-product-ratings-review-summary-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/automation-lab~staples-product-ratings-review-summary-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-staples-product-ratings-review-summary-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/automation-lab~staples-product-ratings-review-summary-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-staples-product-ratings-review-summary-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": {
                    "productUrls": {
                        "title": "🛒 Staples product URLs",
                        "type": "array",
                        "description": "Full staples.com product URLs. URLs outside Staples or non-product pages are rejected.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "https://www.staples.com/epson-ecotank-photo-et-8550-wireless-wide-format-color-all-in-one-inkjet-printer-c11cj21201/product_24503591"
                        ]
                    },
                    "skus": {
                        "title": "🔢 Staples item numbers",
                        "type": "array",
                        "description": "Numeric Staples item numbers (for example 24503591). The Actor resolves each number to its canonical product path.",
                        "items": {
                            "type": "string",
                            "pattern": "^[0-9]{5,12}$"
                        },
                        "default": []
                    },
                    "maxConcurrency": {
                        "title": "⚡ Maximum concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of Staples products fetched at once. Lower this if the source begins rate-limiting a large batch.",
                        "default": 5
                    },
                    "maxRetries": {
                        "title": "🔁 Retries per request",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Retries transient network, rate-limit, and server errors with exponential backoff.",
                        "default": 2
                    },
                    "includeErrorRecords": {
                        "title": "⚠️ Include per-product errors",
                        "type": "boolean",
                        "description": "Write an uncharged error row for products that fail while allowing valid products in the batch to continue.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Cloud runs use a US residential proxy because Staples drops cloud datacenter requests. Local runs try direct HTTP first and use this proxy on retries.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
