# Chewy Scraper \[$1.90/1K💰] | Pet Prices | Reviews & Q\&A (`ahmed_jasarevic/chewy-scraper`) Actor

Scrape Chewy.com pet products by URL or category and export brand, price, rating, review count, every size variant with per-variant prices, plus reviews and Q\&A as clean JSON. Uses Chewy's own JSON APIs, no browser.

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

## Pricing

from $1.70 / 1,000 products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Chewy Scraper — Pet Product Prices, Reviews & Q\&A API

Extract **product name, brand, price, rating, review count, every size variant, individual reviews and Q\&A** from Chewy.com product pages (`chewy.com/.../dp/{id}`) and category pages (`chewy.com/b/{category}/`). Built for pet brands, MAP / price-monitoring teams, e-commerce resellers and review aggregators — at **$1.90 / 1,000 products**.

### Main use cases

- **Price monitoring and MAP enforcement** — track advertised prices and every size variant to catch MAP violations.
- **Amazon and marketplace price comparison** — compare Chewy prices against Amazon, Petco and PetSmart.
- **Pet product data / catalog building** — assemble a structured catalog with brand, GTIN, variants and stock status.
- **Review and Q\&A analysis** — export customer reviews and questions for sentiment analysis and product feedback.
- **E-commerce market research** — analyse assortment, pricing and ratings across pet categories.

### How it works

Chewy's `www` HTML is guarded by **Akamai Bot Manager + Kasada**, so this actor never touches page HTML. Instead it talks directly to the two internal JSON surfaces the Chewy storefront itself uses — both answer clean JSON with **no cookies, no auth, plain HTTP**:

| # | Surface | Endpoint | Used for |
|---|---------|----------|----------|
| 1 | **PLP search proxy** (same-origin API the category pages query) | `GET https://www.chewy.com/plp/api/search?groupId={id}&from={offset}&count={n}` | Category enumeration: name, brand, price, rating, review count, `/dp/{id}` links, paged with `from`/`count` |
| 2 | **PDP GraphQL gateway** | `POST https://www.chewy.com/api/pdp-graphql/graphql` | Product detail (`item(id:)`), paginated reviews, paginated Q\&A |

`groupId` is the trailing number in a `/b/{slug}-{groupId}` category URL. The actor is a lightweight **CheerioCrawler used purely as an HTTP/JSON client** (**256 MB**) — no browser, no rendering.

Two sibling endpoints were probed and **rejected**: `https://api.chewy.com/` returns *403 Access Denied* (Akamai) without special headers, and `https://www.chewy.com/api/api-router/graphql` exposes a different GraphQL schema that does not serve PDP data.

### Extract Pet Product Prices And Variants For Price Monitoring

Every product row includes the advertised price of the scraped variant plus a `variants[]` array with **every size/pack variant, each with its own price, GTIN and stock flags** — ideal for MAP monitoring. `ratingDistribution[]` gives the per-star breakdown, and `inStock` / `availabilityStatus` / `isDiscontinued` / `isPrescription` capture availability, so you can track prices and assortment across a category over time.

### Build A Pet Product Database Without The Chewy API

Chewy has no public product API, and its HTML is bot-walled from datacenter IPs. This actor uses Chewy's own GraphQL + PLP search APIs, which return everything needed — including rating distributions, all size variants with per-variant prices, and cursor-paged reviews and Q\&A — at a fraction of the cost of rendering pages. Category pages enumerate products through the PLP proxy and auto-paginate until `maxProducts` is reached; product pages fetch detail, reviews and Q\&A from the GraphQL gateway.

Reviews and Q\&A are always stored in their own datasets — **`reviews`** (one row per review) and **`questions`** (one row per question) — each row carrying `itemId`, `url`, `partNumber`, `productName` and `brand` for joining back to the product. As a safety net, if a dataset write is ever denied, rows fall back to the default dataset with a `recordType` field (`review` / `question`), so no data is lost. The actor provides these datasets via `storages.datasets` aliases and surfaces them on the run page through the output schema (`Products`, `Reviews`, `Questions`).

### Input Parameters

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array (requestListSources) | **Yes** | product + category prefills | Product pages (`/dp/{id}`) and/or category pages (`/b/{category}/`). |
| `maxProducts` | integer | No | `50` | Max products returned; category pages page until this cap (max 5000). |
| `includeReviews` | boolean | No | `true` | Fetch individual customer reviews per product. |
| `maxReviewsPerProduct` | integer | No | `30` | Reviews per product (0 disables review fetching). |
| `reviewSort` | string (enum) | No | `MOST_RELEVANT` | `MOST_RELEVANT`, `MOST_HELPFUL`, `NEWEST`, `HIGHEST_RATED`, `LOWEST_RATED`. Falls back to `MOST_RELEVANT` if rejected. |
| `includeQuestions` | boolean | No | `true` | Fetch customer questions and answers per product. |
| `maxQuestionsPerProduct` | integer | No | `20` | Q\&A entries per product (0 disables Q\&A fetching). |
| `maxRequestsPerCrawl` | integer | No | `2000` | Safety cap; one product costs ~1 request + ~1 per 25 reviews/questions. |
| `maxConcurrency` | integer | No | `16` | Parallel HTTP requests; raise to 25–30 if your plan allows. |
| `proxy` | object (proxy) | No | `useApifyProxy: false` | Standard Apify proxy picker — enable a residential group if you ever hit rate limits. |

Free-plan users get a capped preview (**10 products** per run); paid users get the full `maxProducts` range.

### Output Fields

One dataset item per product (24 fields; the default `overview` view shows URL, Brand, Product, Price, Rating, Reviews):

| Field | Type | Description |
|---|---|---|
| `url` | string | Canonical Chewy product page URL. |
| `itemId` | string | Numeric item id from the `/dp/{id}` URL. |
| `itemName` | string | Full variant-specific product title. |
| `productName` | string | Base product name shared across variants. |
| `brand` | string / null | Manufacturer / brand name. |
| `partNumber` | string / null | Chewy product-level part number. |
| `entryId` | string / null | Chewy catalog entry id. |
| `slug` | string / null | URL slug of the product. |
| `gtin` | string / null | Global trade item number / UPC. |
| `price` | number / null | Advertised price of the scraped variant in USD. |
| `rating` | number / null | Average star rating (0–5). |
| `reviewCount` | integer / null | Total number of customer ratings. |
| `ratingDistribution` | array | Per-star breakdown: `[{ rating, count, percent }]`. |
| `inStock` | boolean / null | Whether the scraped variant is in stock. |
| `availabilityStatus` | string / null | Raw availability flag (e.g. `OUT_OF_STOCK`, `DISCONTINUED`). |
| `isDiscontinued` | boolean / null | Whether the variant is discontinued. |
| `isPrescription` | boolean / null | Whether the item requires a prescription. |
| `breadcrumbs` | array | Category path: `[{ id, name, url }]`. |
| `variants` | array | All size/pack variants with per-variant price, GTIN and stock flags. |
| `questionsTotal` | integer / null | Total number of customer questions. |
| `questions` | array | Q\&A entries — stored in the `questions` dataset. |
| `reviewsTotal` | integer / null | Total number of customer reviews. |
| `reviews` | array | Individual reviews — stored in the `reviews` dataset. |
| `productDescription` | string / null | Product marketing description. |

### Example Input And Output

**Input**

```json
{
  "startUrls": [
    { "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610" },
    { "url": "https://www.chewy.com/b/toys-315" }
  ],
  "maxProducts": 50,
  "includeReviews": true,
  "maxReviewsPerProduct": 30,
  "includeQuestions": true,
  "maxQuestionsPerProduct": 20,
  "maxConcurrency": 16
}
```

**Output (one product row)**

```json
{
  "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610",
  "itemId": "179610",
  "itemName": "Frisco Pig Corduroy Plush Squeaky Dog Toy",
  "productName": "Frisco Pig Corduroy Plush Squeaky Dog Toy",
  "brand": "Frisco",
  "partNumber": "123456",
  "entryId": "987654",
  "slug": "frisco-pig-corduroy-plush-squeaky-dog",
  "gtin": "0193800000000",
  "price": 6.99,
  "rating": 4.6,
  "reviewCount": 1842,
  "ratingDistribution": [{ "rating": 5, "count": 1200, "percent": 65 }],
  "inStock": true,
  "availabilityStatus": "IN_STOCK",
  "isDiscontinued": false,
  "isPrescription": false,
  "breadcrumbs": [{ "id": "315", "name": "Dog Toys", "url": "https://www.chewy.com/b/toys-315" }],
  "variants": [{ "name": "Small", "price": 6.99, "gtin": "0193800000000", "inStock": true }],
  "questionsTotal": 24,
  "questions": [],
  "reviewsTotal": 1842,
  "reviews": [],
  "productDescription": "A corduroy plush pig with a built-in squeaker..."
}
```

Reviews and Q\&A rows are written to the `reviews` and `questions` datasets, each carrying `itemId`, `url`, `partNumber`, `productName` and `brand`.

### Integrations & Automation

Every Apify actor is reachable through the **Apify API**, and this one plugs into **webhooks**, **Zapier** and **Make** so products, reviews and Q\&A can flow into a Google Sheet, Airtable base, price-monitoring dashboard or a Shopify/catalog pipeline. For price monitoring, run it on a **schedule** — a daily pass over your category URLs is enough to catch price and stock changes, and recurring runs also improve the actor's Store recommendation signals.

#### Monetization (pay-per-event)

Each saved review charges the `review` event and each saved question charges the `question` event, so heavy review/Q\&A runs bill proportionally to the value delivered. Products are charged per result. On flat-priced or local runs the charging calls are safe no-ops.

### Related Actors

- [Amazon-crawler](https://apify.com/junglee/Amazon-crawler) — the largest Amazon products scraper; compare pet-product prices and data across Amazon and Chewy.
- [petco-product-scraper](https://apify.com/sian.agency/petco-product-scraper) — a direct pet-retail competitor for cross-retailer assortment and price comparison.
- [abebooks-scraper](https://apify.com/ahmed_jasarevic/abebooks-scraper) — own actor, e-commerce product data.
- [newegg-scraper](https://apify.com/ahmed_jasarevic/newegg-scraper) — own actor, e-commerce product data.
- [amazon-bestsellers-scraper](https://apify.com/ahmed_jasarevic/amazon-bestsellers-scraper) — own actor, Amazon bestseller/product ranking data.

### FAQ

#### Is there a Chewy API?

Chewy does not publish a public product API, and its `www` HTML is guarded by Akamai Bot Manager + Kasada. This actor reads Chewy's own internal PLP search and PDP GraphQL endpoints, so you get structured products, variants, reviews and Q\&A without an API key or a browser.

#### What are the alternatives to this actor / this data source?

For pet-retail data you can combine this with Amazon and Petco scrapers. Chewy is the largest US online pet retailer, so it is a distinct source alongside Amazon and Petco rather than a duplicate.

#### How do I monitor pet-food prices and catch MAP violations?

Pass the category page for the products you care about and schedule the actor daily. Each run returns the advertised price plus every size variant with its own price and stock flags, so you can diff runs and flag price drops or MAP violations.

#### How do I get all size variants of a product?

Each product row includes a `variants[]` array with every size/pack variant, each with its own price, GTIN and stock flags — no extra configuration needed.

#### Do I need a proxy?

Usually not — the JSON APIs answer from datacenter IPs. Enable the Apify proxy (residential group) only if you hit rate limits on large runs.

#### Where are reviews and Q\&A stored?

In their own datasets (`reviews` and `questions`), one row per entry, each carrying `itemId`, `url`, `partNumber`, `productName` and `brand` so you can join them back to the product.

### SEO Keywords

chewy, chewy scraper, chewy products, chewy api, chewy pet supplies, pet product data, pet food price, price monitoring, map monitoring, ecommerce price scraping, amazon price monitoring, product variant price, reviews and q\&a scraping, petco data, amazon scraper, ecommerce catalog data

### For AI Agents & LLM Apps

Purpose: return one structured product row per Chewy.com product (plus separate reviews and questions rows), for given product or category URLs.

Minimal working input:

```json
{ "startUrls": [{ "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610" }], "maxProducts": 50 }
```

Variant (category enumeration, override to skip reviews/Q\&A):

```json
{ "startUrls": [{ "url": "https://www.chewy.com/b/toys-315" }], "maxProducts": 50, "includeReviews": false, "includeQuestions": false }
```

Output fields (products dataset): `url, itemId, itemName, productName, brand, partNumber, entryId, slug, gtin, price, rating, reviewCount, ratingDistribution, inStock, availabilityStatus, isDiscontinued, isPrescription, breadcrumbs, variants, questionsTotal, questions, reviewsTotal, reviews, productDescription`. Reviews and questions are stored in separate datasets (`reviews`, `questions`) with join keys `itemId`, `url`, `partNumber`, `productName`, `brand`.

Behaviors an agent should know:

- **`startUrls` is required** (no default keyword mode). Category URLs (`/b/{slug}-{groupId}`) auto-paginate until `maxProducts`.
- If `maxProducts` is left unset it defaults to **50**; free-plan runs are capped at **10 products**.
- `includeReviews` / `includeQuestions` default to **true** and add billed events: `maxReviewsPerProduct` defaults to 30, `maxQuestionsPerProduct` to 20. Setting either to `0` disables it.
- `reviewSort` falls back to `MOST_RELEVANT` automatically if Chewy rejects the requested value.
- `reviews[]` / `questions[]` arrays in the product row are left empty — the entries live in the separate `reviews` / `questions` datasets (or, as a fallback, in the default dataset tagged with `recordType`).
- Prices reflect the default US storefront; discontinued/suppressed variants still return metadata but may lack a price.

Billing: pay-per-event — **$0.0019 per product** ($1.90 / 1,000), **$0.0004 per review** ($0.40 / 1,000) and **$0.0003 per question** ($0.30 / 1,000), plus a $0.00005 actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Chewy**. It accesses only publicly available JSON endpoints that Chewy.com's own storefront uses; it does not log in, bypass authentication, or solve CAPTCHAs on anyone's behalf. Users are responsible for ensuring their use complies with Chewy's Terms of Service and with applicable data-protection law. Output may include reviewer names and review text; where personal data is present it must not be used for unsolicited commercial outreach or in violation of applicable law (e.g. CAN-SPAM, CCPA, GDPR).

# Actor input Schema

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

Chewy product pages (chewy.com/.../dp/{id}) and/or category pages (chewy.com/b/{category}/) to scrape.

## `maxProducts` (type: `integer`):

Maximum number of products to return per run. Category pages are paged until this cap is reached.

## `includeReviews` (type: `boolean`):

Fetch individual customer reviews for each product.

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

How many individual reviews to fetch per product (0 disables review fetching).

## `reviewSort` (type: `string`):

Order in which reviews are returned. If the site rejects a value, the actor retries with MOST_RELEVANT.

## `includeQuestions` (type: `boolean`):

Fetch customer questions and answers for each product.

## `maxQuestionsPerProduct` (type: `integer`):

How many Q\&A entries to fetch per product (0 disables Q\&A fetching).

## `maxRequestsPerCrawl` (type: `integer`):

Safety cap on total HTTP requests per run. Each product costs ~1 request plus ~1 per 25 reviews/questions.

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

How many HTTP requests to run in parallel. Higher is faster; 16 suits Chewy's JSON APIs, raise to 25-30 if your plan allows.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610"
    },
    {
      "url": "https://www.chewy.com/b/toys-315"
    }
  ],
  "maxProducts": 50,
  "includeReviews": true,
  "maxReviewsPerProduct": 30,
  "reviewSort": "MOST_RELEVANT",
  "includeQuestions": true,
  "maxQuestionsPerProduct": 20,
  "maxRequestsPerCrawl": 2000,
  "maxConcurrency": 16,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

No description

## `questions` (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 = {
    "startUrls": [
        {
            "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610"
        },
        {
            "url": "https://www.chewy.com/b/toys-315"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/chewy-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 = {
    "startUrls": [
        { "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610" },
        { "url": "https://www.chewy.com/b/toys-315" },
    ],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/chewy-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.chewy.com/frisco-pig-corduroy-plush-squeaky-dog/dp/179610"
    },
    {
      "url": "https://www.chewy.com/b/toys-315"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/chewy-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/chewy-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/183MBeH4f3zALCBVG/builds/MqFSLATHl4cUHGmNj/openapi.json