# Petco Product Scraper (`parseforge/petco-scraper`) Actor

Collect pet supply product data from Petco including regular prices, sale deals, repeat delivery discounts, brand info, availability flags, and product images. Filter by category, brand name, or search keyword. Tracks same day delivery, in-store pickup, Rx food, review counts, and ratings.

- **URL**: https://apify.com/parseforge/petco-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Marketing, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$15.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🐾 Petco Scraper

Collect product listings, pricing, ratings, and availability data from Petco's online store. Search by keyword or browse any category page and get structured results you can use right away.

Whether you are a pet industry analyst tracking competitor prices, a retail team building a product catalog, or a researcher monitoring stock availability across categories, this tool delivers clean, consistent data without any manual browsing.

> **The Petco Scraper collects complete product records from Petco, with up to 18 data fields per listing, including list price, sale price, Repeat Delivery discounts, and availability flags for same-day delivery, in-store pickup, and prescription items.**

### ✨ What Does It Do

- 🖼️ **Product Image** - capture product photo URLs to build visual catalogs and quickly identify listings at scale
- 📄 **Title and Brand** - collect full product names and manufacturer brands for catalog building and brand analysis
- 💰 **Pricing** - retrieve list price, sale price, and Repeat Delivery discount to track promotions and compare competitor pricing
- ⭐ **Ratings and Reviews** - capture average star ratings and total review counts to measure product popularity and buyer trust
- 📦 **Availability Flags** - identify which products qualify for same-day delivery, in-store pickup, in-store only, or require a prescription
- 📂 **Category** - extract the product category from Petco's taxonomy for structured filtering and analysis
- 🔢 **Variation Count** - report how many size or flavor variants each product has listed

### 🔧 Input

- **Start URL** - Paste a Petco category or search results page URL to collect all products from that page. Overrides the Search Query if both are provided
- **Max Items** - Set how many products to collect. Free users: up to 100. Paid users: up to 1,000,000
- **Search Query** - Enter a keyword to search Petco directly, e.g. `purina pro plan adult dog food` or `tidy cats clumping litter`. Used when no Start URL is provided

Example input:
```json
{
  "searchQuery": "purina pro plan adult dog food",
  "maxItems": 10
}
````

### 📊 Output

Each product record includes up to 18 data fields. Download as JSON, CSV, or Excel.

| 🖼️ Product image | 📄 Product title | 🏷️ Brand |
|---|---|---|
| 💰 List price | 💸 Sale price | 🔄 Repeat Delivery price |
| ⭐ Rating | 💬 Review count | 📂 Category |
| 📦 Availability | 🚚 Same day delivery | 🏪 In store only |
| 🛒 Buy online pick up in store | 💊 Prescription food | 🔢 Variation count |
| 🔖 SKU ID | 🔗 Product URL | 🕒 Scraped at |

### 💎 Why Choose the Petco Scraper?

| Feature | Our Actor |
|---|---|
| Search by keyword or category URL | ✔️ |
| List price, sale price, and Repeat Delivery price | ✔️ |
| Star rating and review count per product | ✔️ |
| Same-day delivery and BOPUS availability flags | ✔️ |
| In-store only and prescription food detection | ✔️ |
| Variation count per listing | ✔️ |
| Paginates through all result pages automatically | ✔️ |
| Free tier: up to 100 products per run | ✔️ |
| Paid tier: up to 1,000,000 products per run | ✔️ |
| Export to JSON, CSV, or Excel format | ✔️ |

### 📋 How to Use

No technical skills required. Follow these simple steps:

1. **Sign Up**: [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Find the Tool**: Search for "Petco Scraper" in the Apify Store and configure your input
3. **Run It**: Click "Start" and watch your results appear

That's it. No coding, no setup, no complicated configuration. Now you can export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 🏪 **Retail Analyst** - track list and sale prices across pet food brands over time to identify promotion patterns and benchmark your pricing strategy against a major competitor
- 📊 **Market Researcher** - collect product availability and category data across Petco's full catalog to measure brand distribution and identify gaps in the pet supply market
- 🔍 **E-Commerce Team** - build a structured product database from Petco listings to power comparison tools, price alerts, or content marketing for the pet industry

### ❓ FAQ

**🔍 How does it work?**
The scraper connects to Petco's product catalog and extracts listing data page by page until it reaches your target item count. No account or login is required.

**💰 What is the Repeat Delivery price?**
Petco's Repeat Delivery program lets customers subscribe to automatic orders at a discounted rate. The `rdPrice` field captures this discounted price when the product offers it.

**📦 Can I collect an entire category?**
Yes. Navigate to any category on the Petco website, copy the URL from your browser, and paste it into the Start URL field. The tool paginates through all results automatically.

**📅 Can I schedule it to run automatically?**
Yes. Use integrations like Make or Zapier to run the scraper on a schedule and send results to your database or spreadsheet.

**⚠️ Are there any limits?**
Free users can collect up to 100 products per run. Paid users can collect up to 1,000,000 products per run.

### 🔗 Integrate Petco Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Connect 5000+ apps
- [GitHub](https://docs.apify.com/platform/integrations/github) - Version control integration
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notifications
- [Airbyte](https://docs.apify.com/platform/integrations/airbyte) - Data pipelines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export to spreadsheets

### 💡 More ParseForge Actors

- [Mercari Scraper](https://apify.com/parseforge/mercari-scraper) - Collect product listings, prices, and seller info from Mercari marketplace
- [Etsy Scraper](https://apify.com/parseforge/etsy-scraper) - Extract product data, reviews, and shop information from Etsy
- [Poshmark Scraper](https://apify.com/parseforge/poshmark-scraper) - Gather secondhand listings, seller profiles, and pricing from Poshmark

Browse our complete collection of [data extraction tools](https://apify.com/parseforge) for more.

### 🚀 Ready to Start?

[Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and collect your first 100 results for free. No coding, no setup.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify support page](https://docs.apify.com) for documentation and tutorials
- Contact us to request a new scraper, propose a custom project, or report an issue at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Petco or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

## `startUrl` (type: `string`):

URL of a Petco category or search results page to scrape, e.g. https://www.petco.com/shop/en/petcostore/category/dog/dog-food. Overrides the Search Query if both are provided.

## `maxItems` (type: `integer`):

Free users: Limited to 100. Paid users: Optional, max 1,000,000.

## `searchQuery` (type: `string`):

Keyword to search on Petco, e.g. "blue buffalo life protection" or "tidy cats clumping litter".

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "purina pro plan adult dog food"
}
```

# Actor output Schema

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

Dataset with all scraped items

# 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 = {
    "maxItems": 10,
    "searchQuery": "purina pro plan adult dog food"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/petco-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 = {
    "maxItems": 10,
    "searchQuery": "purina pro plan adult dog food",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/petco-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 '{
  "maxItems": 10,
  "searchQuery": "purina pro plan adult dog food"
}' |
apify call parseforge/petco-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Petco Product Scraper",
        "description": "Collect pet supply product data from Petco including regular prices, sale deals, repeat delivery discounts, brand info, availability flags, and product images. Filter by category, brand name, or search keyword. Tracks same day delivery, in-store pickup, Rx food, review counts, and ratings.",
        "version": "1.0",
        "x-build-id": "TKQaWcXe67nvZZj9f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~petco-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-petco-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/parseforge~petco-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-petco-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/parseforge~petco-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-petco-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": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "URL of a Petco category or search results page to scrape, e.g. https://www.petco.com/shop/en/petcostore/category/dog/dog-food. Overrides the Search Query if both are provided."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 100. Paid users: Optional, max 1,000,000."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword to search on Petco, e.g. \"blue buffalo life protection\" or \"tidy cats clumping litter\"."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
