# Petco Product Scraper — Prices, Autoship & Ratings (`muhammadafzal/petco-product-scraper`) Actor

Track Petco prices with this Petco product scraper: list, sale and autoship prices, ratings, review counts and SKUs for pet brands, sellers and analysts.

- **URL**: https://apify.com/muhammadafzal/petco-product-scraper.md
- **Developed by:** [Muhammad Afzal](https://apify.com/muhammadafzal) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 product extracteds

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

## Petco Product Scraper — Prices, Autoship & Ratings

Petco Product Scraper collects Petco prices, sale prices, autoship prices, star ratings, review counts, SKUs and delivery options from Petco search terms, category pages or product URLs, and returns one clean record per product. It is built for pet brands, online sellers and price analysts who need Petco product data in a spreadsheet, database or AI workflow.

The Actor reads the same public product-search data that powers Petco's own search and category pages, over plain HTTP. It needs no browser, no login and no cookies, so a small run finishes in a few seconds of compute.

**Price:** $5.00 per 1,000 products on the FREE tier ($4.00 on GOLD and above), plus a $0.00649 start fee per run. Up to 500 products per run on every Apify plan.

### What Petco product data do you get?

One dataset record per unique Petco product:

| Field | What it means |
|---|---|
| `title` | Product name including size or variant, as shown on Petco |
| `brand` | Brand name |
| `price` | Regular (list) price in USD |
| `salePrice` | Current online price when it is below the list price, otherwise `null` |
| `autoshipPrice` | Petco Autoship (repeat delivery) price in USD |
| `currency` | Always `USD` |
| `rating` | Average star rating (0–5) |
| `reviewCount` | Number of customer reviews |
| `sku` | Petco item number (the number at the end of the product URL) |
| `productId` | Petco catalog ID of the returned variant |
| `variantCount` | Number of sizes or variants listed for the product |
| `availability` | `InStoreOnly` for in-store-only items, otherwise `null` (stock levels are not published) |
| `inStoreOnly` | Sold in stores only |
| `autoshipEligible` | Can be ordered with Autoship |
| `sameDayDeliveryEligible` | Eligible for same-day delivery |
| `pickupInStoreEligible` | Eligible for buy online, pick up in store |
| `category` | Petco's internal category path, for example `Consumables|Food|Household Pet` |
| `description` | Product description from Petco's search data |
| `productUrl` | Link to the Petco product page |
| `imageUrl`, `imageUrls` | Main product image URL |
| `inputType`, `input` | Which search term or URL produced the record (`search`, `category` or `product`) |
| `scrapedAt` | When the record was collected (ISO timestamp) |
| `source` | Always `petco.com` |

### When to use this Petco scraper

- **Track Petco prices** for chosen products or a whole category, including sale prices and the Autoship price.
- **Pet food price comparison:** collect Petco dog food prices and cat food prices on a schedule and compare them with your own catalog or other retailers.
- **Brand and review monitoring:** follow ratings and review counts for your brand and competing brands.
- **Petco catalog snapshot:** export a category's assortment, brands, SKUs and fulfilment options for assortment research.
- **Feed tools and agents:** send structured records to a database, BI tool, spreadsheet or AI agent, with the product URL kept for verification.

It is a focused ecommerce scraper for one retailer. Do not use it for:

- Customer review text (only the average rating and review count are returned).
- Stock counts or prices for a specific store or ZIP code (it returns Petco's US online catalog prices).
- Petco services such as grooming, vet care or pet insurance.
- Retailers other than petco.com.

### Input

Use any mix of search terms, category URLs and product URLs.

| Field | Default | What it does |
|---|---|---|
| `searchTerms` | prefilled `dog food` | Petco searches such as `dog food` or `cat litter`. A term with no keyword match returns no products instead of loosely related suggestions. |
| `categoryUrls` | `[]` | Petco category URLs (`https://www.petco.com/category/dry-dog-food`, legacy `/shop/en/petcostore/category/...` links) or search URLs (`https://www.petco.com/search?query=cat%20litter`). Filters in the URL query are ignored. |
| `productUrls` | `[]` | Petco product URLs such as `https://www.petco.com/product/<product-slug>-3748364`. The size or variant in the URL is returned. |
| `maxProducts` | 20 (prefill 3) | Run-wide maximum number of unique products returned and charged, 1–500. |
| `maxPagesPerSearch` | 3 | Result pages per search term or category, 1–20. One page holds up to 100 products. |
| `requestTimeoutSecs` | 30 | Timeout for each product-search request, 10–180 seconds. |

Inputs are processed a few at a time (product URLs first, then categories, then searches) until `maxProducts` is reached, so with several inputs and a small cap the first inputs can use the whole allowance. If you add URLs and leave the prefilled `dog food` search unchanged, that search is skipped and a warning is added to `OUTPUT`.

Petco dog food and cat food prices:

```json
{
  "searchTerms": ["dog food", "cat food"],
  "maxProducts": 100,
  "maxPagesPerSearch": 1
}
```

A category plus specific products:

```json
{
  "categoryUrls": ["https://www.petco.com/category/dry-dog-food"],
  "productUrls": ["https://www.petco.com/product/purina-pro-plan-sensitive-skin-and-stomach-salmon-and-rice-formula-dry-dog-food-40-lbs-3748364"],
  "maxProducts": 25
}
```

### Petco API: run it from your code

The Actor works as a Petco product data API through the Apify API. JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('muhammadafzal/petco-product-scraper').call({
  searchTerms: ['dog food'],
  maxProducts: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

cURL, returning the products in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/muhammadafzal~petco-product-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["cat litter"], "maxProducts": 10}'
```

You can also run it from Apify Console, schedules, webhooks, Make, Zapier, n8n, or the hosted Apify MCP server for AI agents.

### Output example

A real record from a `dog food` search (description shortened):

```json
{
  "productId": "2503505",
  "title": "Taste of the Wild Pacific Stream Grain-Free with Smoke-Flavored Salmon Dry Dog Food, 28 lbs.",
  "brand": "Taste of the Wild",
  "productUrl": "https://www.petco.com/product/taste-of-the-wild-pacific-stream-grain-free-dry-dog-food-with-smoked-salmon-28-lbs-2998871",
  "imageUrl": "https://assets.petco.com/petco/image/upload/f_auto,q_auto,w_190/dpr_auto/2998871-center-1",
  "imageUrls": ["https://assets.petco.com/petco/image/upload/f_auto,q_auto,w_190/dpr_auto/2998871-center-1"],
  "price": 59.99,
  "salePrice": 58.99,
  "autoshipPrice": 56.04,
  "currency": "USD",
  "availability": null,
  "inStoreOnly": false,
  "autoshipEligible": true,
  "sameDayDeliveryEligible": true,
  "pickupInStoreEligible": true,
  "rating": 4.71,
  "reviewCount": 1951,
  "category": "Consumables|Food|Household Pet",
  "description": "Taste of the Wild Pacific Stream with SMOKE-FLAVORED SALMON dry dog food; REAL FISH is the #1 ingredient; ...",
  "sku": "2998871",
  "variantCount": 3,
  "inputType": "search",
  "input": "dog food",
  "scrapedAt": "2026-10-25T13:56:21.861Z",
  "source": "petco.com"
}
```

Each run also writes one `OUTPUT` record with the outcome (`DATA`, `EMPTY`, `BLOCKED`, `REJECTED` or `FAILED`), products delivered and charged, the status of every input (data, empty, not-found, skipped, blocked or failed), the stop reason, request counts and warnings:

```json
{
  "outcome": "DATA",
  "productsReturned": 3,
  "chargedProducts": 3,
  "stopReason": "the product limit of 3 was reached",
  "inputs": [{ "inputType": "search", "input": "dog food", "status": "data", "products": 3, "pages": 1, "totalAvailable": 2492 }],
  "warnings": []
}
```

### Pricing

Pay per event, with Apify platform usage included in the prices (no separate usage fee is passed to you). Your tier follows your Apify subscription plan.

| Event | FREE | BRONZE (2.5% off) | SILVER (5% off) | GOLD, PLATINUM, DIAMOND (20% off) | Charged when |
|---|---:|---:|---:|---:|---|
| Product extracted (`product-extracted`, primary) | $0.005001 | $0.004875 | $0.00475 | $0.004 | Once per unique product written to the dataset |
| Actor start (`apify-actor-start`) | $0.00649 | $0.006327 | $0.006165 | $0.005192 | Once per run per started GB of allocated memory; the default 256 MB run (512 MB maximum) is one start event |

Every Apify plan, the free plan included, can request up to 500 products per run with `maxProducts`.

Worked examples:

- FREE tier, prefilled input (3 products): $0.00649 + 3 × $0.005001 = **$0.021493**.
- FREE tier, 500 products: $0.00649 + 500 × $0.005001 = **$2.50699**.
- SILVER, default 20 products: $0.006165 + 20 × $0.00475 = **$0.101165**.
- BRONZE, 100 products: $0.006327 + 100 × $0.004875 = **$0.493827**.
- GOLD, 500 products: $0.005192 + 500 × $0.004 = **$2.005192**.

Duplicate, unmatched and failed items are never charged. Empty, rejected and blocked runs pay only the start fee. The lowest maximum total charge you can set is $0.011491 (one start event plus one product), and the run stops cleanly when your maximum total charge is reached.

### Reliability, limits and failure modes

- **Access:** direct HTTP requests to Petco's public product search. If Petco repeatedly refuses requests, the Actor retries them automatically through a residential network route. Rate limits (HTTP 429) are retried with backoff.
- **Blocked or failed runs** end with a clear status message, an `OUTPUT` outcome of `BLOCKED` or `FAILED`, and no product charges. After three inputs in a row fail, the run stops instead of spending more time.
- **Empty results are truthful:** unmatched searches, empty categories and unknown product URLs are reported in `OUTPUT` as `empty` or `not-found`; no placeholder records are created.
- **Stock:** Petco search data does not include stock levels. `availability` is `InStoreOnly` for in-store-only items and otherwise `null`; use the delivery and pickup flags for fulfilment options.
- **Images:** `imageUrls` holds the main product image only.
- **Category filters** (brand, price, facets in the URL query) are not applied; the whole category is paginated in Petco's relevance order.
- **Market:** the US Petco store, prices in USD.
- **Time limits:** the default run timeout is 300 seconds. When the timeout is near, the Actor stops early, keeps every product already delivered and says so in the status message.

### Legal and data-protection note

The Actor collects public product information only: names, prices, ratings, review counts and product details. It does not access accounts, carts or checkout, and it does not collect customer names, review text or other personal data. Use the data in line with Petco's terms and the laws that apply to you, and verify prices on Petco before making high-impact decisions.

### FAQ

#### Is there a Petco API for product data?

This Actor gives you programmatic access to Petco product data: call it through the Apify API, a client library or the Apify MCP server, and receive JSON records with prices, ratings, SKUs and product URLs.

#### Can I export Petco prices to CSV or Excel?

Yes. Open the run's dataset in Apify Console and export CSV, Excel, JSON, XML or RSS, or download the same records through the dataset API.

#### How do I monitor Petco price and rating changes over time?

Save your input as a Task, add an Apify schedule (for example daily or weekly), and compare `price`, `salePrice`, `autoshipPrice`, `rating` and `reviewCount` by `sku` between runs. A webhook or integration can process each new dataset automatically.

#### Does it collect Petco customer reviews?

No. Each product includes the average `rating` and the `reviewCount`, but not the text of individual reviews.

#### Does it show Petco prices near me or for a specific store?

No. It returns the prices that Petco's US online catalog shows. It does not look up prices for a specific store or ZIP code; the `inStoreOnly` and `pickupInStoreEligible` flags show how an item can be bought.

#### Does it show the Petco Autoship price?

Yes. `autoshipPrice` is the repeat-delivery price from Petco's search data, and `autoshipEligible` shows whether Autoship is available. In our October 2026 sample run, Autoship prices were 5% below the current list or sale price. First-order Autoship promotions are not returned as a separate field.

### Support

When reporting a problem, include the Actor run ID, a redacted input, the expected result and a public example URL when applicable. Never post API tokens, cookies or personal data in an issue.

Last verified: 2026-11-04

# Actor input Schema

## `searchTerms` (type: `array`):

Petco searches to run, such as "dog food" or "cat litter". Terms with no keyword match return no products (loosely related suggestions are not returned). The prefilled "dog food" is skipped when you also supply URLs.

## `categoryUrls` (type: `array`):

Petco category URLs (https://www.petco.com/category/dry-dog-food or legacy /shop/en/petcostore/category/... links) or Petco search-result URLs (https://www.petco.com/search?query=...). Category filters in the URL query are ignored.

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

Direct Petco product URLs such as https://www.petco.com/product/<product-slug>-3748364. The size or variant in the URL is returned.

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

Run-wide maximum number of unique products returned (and charged). Inputs are processed a few at a time until this cap is reached.

## `maxPagesPerSearch` (type: `integer`):

Pagination depth for each search term and category. A result page holds up to 100 products (or maxProducts when smaller).

## `requestTimeoutSecs` (type: `integer`):

Timeout for each product-search request. Large categories can take up to about 20 seconds on a cold request.

## Actor input object example

```json
{
  "searchTerms": [
    "dog food"
  ],
  "categoryUrls": [],
  "productUrls": [],
  "maxProducts": 3,
  "maxPagesPerSearch": 3,
  "requestTimeoutSecs": 30
}
```

# Actor output Schema

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

URL of the default dataset containing normalized Petco product records.

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

URL of the OUTPUT key-value record with counts, warnings, and billing totals.

# 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 = {
    "searchTerms": [
        "dog food"
    ],
    "maxProducts": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammadafzal/petco-product-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 = {
    "searchTerms": ["dog food"],
    "maxProducts": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("muhammadafzal/petco-product-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 '{
  "searchTerms": [
    "dog food"
  ],
  "maxProducts": 3
}' |
apify call muhammadafzal/petco-product-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammadafzal/petco-product-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/kfGM3EmbvFHIFM6O0/builds/cQ0SdbZmdFtMCG02K/openapi.json