# Petflow Scraper (`parseforge/petflow-scraper`) Actor

Collect pet supplies product data from PetFlow.com including prices, discounts, brand info, stock availability, ratings, and full descriptions. Browse by category like dog food, cat food, treats, and more. Handles bot protection automatically.

- **URL**: https://apify.com/parseforge/petflow-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Automation, Other
- **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.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://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🐾 PetFlow Scraper

> 🚀 **Pull every pet supply listing from petflow.com in seconds.** Filter by category, capture price changes, and ship clean rows to your downstream tools. No API key, no registration, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-08 · **📊 16 fields** per record · **24+ products per category page** · **Cloudflare bypass via residential proxies** · **Live pricing in USD**

PetFlow runs a large catalogue of dog and cat supplies behind Cloudflare's challenge layer, which means a casual `curl` returns a verification page instead of a product list. This Actor sits in front of that wall: it boots a stealth-tuned Firefox session, clears the challenge with a residential IP, and harvests the JSON the storefront streams to its own React UI. The result is a clean dataset with **brand, SKU, image URL, current price, original price, percent discount, stock status, category, rating, review count, description, and a timestamp** for every product.

You feed in a category URL like `https://www.petflow.com/dog/food` and a `maxItems` cap. The Actor scrolls through the page, captures each batch of catalog responses, deduplicates by SKU, and pushes records to your dataset. Free runs preview **10 items** so you can verify the shape; paid runs go up to **1,000,000**. Schedule it daily for price tracking, run it ad-hoc for competitive snapshots, or wire it into Make / Zapier for pet-supply price alerts. Every record is freshly scraped at the moment of execution.

| 🎯 Target audience | 💡 Primary use cases |
|---|---|
| 📊 E-commerce analysts tracking pet category prices | Build weekly price snapshots across dog and cat food brands |
| 💼 Marketplace sellers benchmarking against PetFlow | Compare your SKUs against PetFlow's prices, ratings, and stock |
| 📣 Affiliate marketers and content creators | Populate review pages with live prices, brand metadata, and images |
| 🧠 Data engineers building product data pipelines | Stream PetFlow records into BigQuery, S3, or a feature store |

---

### 📋 What the PetFlow Scraper does

- 🐕 **Category coverage.** Point the Actor at any PetFlow category URL (dog, cat, food, toys, treats, supplements) and it grabs the full listing surface, not just the top of the page.
- 💰 **Live pricing.** Capture current price, original price, percent discount, and currency on every record, so you can detect markdowns the moment they go live.
- 📦 **Stock and SKU.** Each row carries the canonical SKU plus an `inStock` flag, so you know which items are sellable right now.
- ⭐ **Ratings and reviews.** When PetFlow exposes them, customer rating and review count are pulled in alongside the product, with promotional copy when available.
- 🖼️ **Images and product URL.** A direct `imageUrl` for visual catalogues plus a clickable `url` for affiliate links or audit trails.

Each record bundles the imageUrl, name, brand, url, sku, price, originalPrice, discount, currency, rating, reviewCount, description, category, inStock, promoText, and scrapedAt timestamp. The dataset is downloadable in CSV, Excel, JSON, JSONL, RSS, HTML, and XML formats out of the box.

> 💡 **Why it matters:** retail pricing is one of the fastest moving signals in pet commerce. A dataset that you can refresh on a schedule lets you see promotions, brand shelf changes, and stock rotations within hours, not at the end of the quarter when your spreadsheet is stale.

---

### 🎬 Full Demo

🚧 Coming soon: a 3-minute walkthrough showing input setup, a live run, and how to wire the dataset into a downstream tool. The Actor is fully operational while the video is in production.

---

### ⚙️ Input

<table>
  <tr>
    <th>Field</th>
    <th>Type</th>
    <th>Required</th>
    <th>Description</th>
  </tr>
  <tr>
    <td><code>startUrl</code></td>
    <td>string</td>
    <td>yes</td>
    <td>A PetFlow category or search URL, for example <code>https://www.petflow.com/dog/food</code> or <code>https://www.petflow.com/search?q=treats</code>.</td>
  </tr>
  <tr>
    <td><code>maxItems</code></td>
    <td>integer</td>
    <td>no</td>
    <td>Cap on the number of products to push. Free plan caps at 10. Paid plans can go up to 1,000,000.</td>
  </tr>
  <tr>
    <td><code>proxyConfiguration</code></td>
    <td>object</td>
    <td>no</td>
    <td>Defaults to Apify Residential proxies in the US. You can override the group or supply your own proxy URLs.</td>
  </tr>
</table>

Example: dog food category, 100 items, default proxy.

```json
{
  "startUrl": "https://www.petflow.com/dog/food",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

Example: cat treats search, free preview run.

```json
{
  "startUrl": "https://www.petflow.com/search?q=cat+treats",
  "maxItems": 10
}
```

> ⚠️ **Good to Know:** PetFlow sits behind Cloudflare's bot challenge, so a residential proxy is required. The Actor cycles up to 15 fresh sessions per run to find one that clears the challenge cleanly. Runs that cannot clear after every retry return a single error record rather than partial data.

***

### 📊 Output

Every record is a flat JSON object with 16 fields. Download the dataset as JSON, JSONL, CSV, Excel, RSS, HTML, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | `//www.petflow.com/media/catalog/product/g/o/gold_dog_dry_adult_30lb_072705115211_0acb.jpg` |
| 📝 `name` | string | `Fromm Gold Adult Dog Food` |
| 👤 `brand` | string | `Fromm` |
| 🔗 `url` | string | `https://www.petflow.com/product/c300431` |
| 📦 `sku` | string | `C300431` |
| 💰 `price` | number | `15.5` |
| 💵 `originalPrice` | number | null | `19.99` |
| 🏷️ `discount` | number | null | `22` |
| 💱 `currency` | string | `USD` |
| ⭐ `rating` | number | null | `4.7` |
| 📊 `reviewCount` | number | null | `132` |
| 📝 `description` | string | Trimmed marketing description |
| 📂 `category` | string | `Dog > Food` |
| ✅ `inStock` | boolean | `true` |
| 🎁 `promoText` | string | null | Promotional banner text when present |
| 📅 `scrapedAt` | string (ISO 8601) | `2026-05-08T00:39:05.597Z` |
| 🚨 `error` | string | Only present on failure rows |

#### 📦 Sample records

<details>
<summary><b>Typical record (full description, in stock)</b></summary>

```json
{
  "imageUrl": "//www.petflow.com/media/catalog/product/g/o/gold_dog_dry_adult_30lb_072705115211_0acb.jpg",
  "name": "Fromm Gold Adult Dog Food",
  "brand": "Fromm",
  "url": "https://www.petflow.com/product/c300431",
  "sku": "C300431",
  "price": 15.5,
  "originalPrice": null,
  "discount": null,
  "currency": "USD",
  "rating": null,
  "reviewCount": null,
  "description": "Tastefully prepared with a balanced blend of select proteins and wholesome ingredients for adult dogs. Fromm Family Adult Gold Food for Dogs is formulated to provide your normally active adult dog with complete and balanced nutrition.",
  "category": "Dog > Food",
  "inStock": true,
  "promoText": null,
  "scrapedAt": "2026-05-08T00:39:05.597Z"
}
```

</details>

<details>
<summary><b>Different brand (NutriSource)</b></summary>

```json
{
  "imageUrl": "//www.petflow.com/media/catalog/product/X/3/X31759_1_299c.jpg",
  "name": "NutriSource Adult Chicken & Rice Dry Dog Food",
  "brand": "NutriSource",
  "url": "https://www.petflow.com/product/c300879",
  "sku": "C300879",
  "price": 17.59,
  "originalPrice": null,
  "discount": null,
  "currency": "USD",
  "rating": null,
  "reviewCount": null,
  "description": "Perfect for all breeds, NutriSource Adult Chicken and Rice Dry Dog Food utilizes a holistic, easy to digest recipe for ideal health maintenance.",
  "category": "Dog > Food",
  "inStock": true,
  "promoText": null,
  "scrapedAt": "2026-05-08T00:39:05.597Z"
}
```

</details>

<details>
<summary><b>Sparse record (nullable fields)</b></summary>

```json
{
  "imageUrl": "//www.petflow.com/media/catalog/product/t/g/tgold_product_dogdry_SmBreedAdultGold_210560_10567_2d35.jpg",
  "name": "Fromm Gold Small Breed Adult Dog Food",
  "brand": "Fromm",
  "url": "https://www.petflow.com/product/c301062",
  "sku": "C301062",
  "price": 17.02,
  "originalPrice": null,
  "discount": null,
  "currency": "USD",
  "rating": null,
  "reviewCount": null,
  "description": null,
  "category": "Dog > Food",
  "inStock": true,
  "promoText": null,
  "scrapedAt": "2026-05-08T00:39:05.597Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🛡️ | \*\*Cloudflare-aware. \*\*Stealth Firefox session with up to 15 retries to clear the challenge before any record is scraped. |
| 💸 | \*\*Pay only for results. \*\*Errored runs that produce zero items are not billed beyond the platform minimum. |
| 📊 | \*\*16 fields per row. \*\*Image, brand, SKU, price, original price, discount, rating, review count, description, category, stock, currency, URL, promo text, and timestamp. |
| 🔄 | \*\*Live data. \*\*Every run hits the catalog API at the moment of execution. No cache, no stale snapshots. |
| 📂 | \*\*Any export format. \*\*CSV, JSON, JSONL, Excel, HTML, XML, or stream via the Apify API. |
| ⏱️ | \*\*Schedule-friendly. \*\*Drop the Actor into the Apify scheduler and let it refresh nightly, hourly, or on a custom cron. |
| 🔌 | \*\*Workflow ready. \*\*Dataset webhooks, Make / Zapier templates, Google Sheets, Slack notifications, and Airbyte connectors all work out of the box. |

> 📊 A full PetFlow category page returns 24 products per scroll batch, captured in a single API response we intercept directly.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| Manual copy and paste | Free, but expensive in time | Low | Stale within hours | None | Browser plus spreadsheet |
| Generic browser automation scripts | High maintenance | Medium | Brittle | Limited | Custom code, proxy hosting, monitoring |
| Paid live retail APIs | $$$ subscription | Variable | Real-time | Vendor-defined | Account, API keys, rate-limit handling |
| **⭐ PetFlow Scraper** *(this Actor)* | **Pay-per-run on Apify** | **Full category surface** | **On every run** | **URL-based filters** | **Paste a URL, click Start** |

For analysts and small teams, the trade-off is simple: a maintained Apify Actor with built-in proxies and dataset exports beats hand-rolling a Cloudflare bypass.

***

### 🚀 How to use

1. 🔐 **Sign up.** [Create a free Apify account with $5 in monthly credit](https://console.apify.com/sign-up?fpr=vmoqkp). No credit card required at sign up.
2. 🔍 **Open the Actor.** Search for "PetFlow Scraper" in the [Apify Store](https://apify.com/parseforge/petflow-scraper) and click "Try for free".
3. ⚙️ **Configure inputs.** Paste a PetFlow category or search URL into `startUrl`, choose your `maxItems`, and confirm the residential proxy is enabled.
4. ▶️ **Start the run.** Click "Start" and watch the live log. A first batch of products appears within roughly a minute on a clean Cloudflare clearance.
5. 📥 **Export the dataset.** Download CSV, Excel, JSON, or pipe the dataset to BigQuery, Google Sheets, Slack, or your own webhook from the Storage tab.

> ⏱️ **Total time:** roughly 2 minutes from signup to first dataset on a paid run; longer if Cloudflare needs multiple session retries.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%">

#### 📊 E-commerce analyst

- Track price changes across dog and cat food brands week over week
- Detect when PetFlow runs promotions ahead of seasonal events
- Map SKUs to your internal catalog to spot pricing gaps
- Build dashboards showing brand share by stock and pricing tier

</td>
<td width="50%">

#### 💼 Marketplace seller

- Benchmark your product prices against PetFlow's listed prices
- Watch competitor stock levels to time your own restocks
- Identify category leaders by review count and rating
- Surface new product launches the moment PetFlow lists them

</td>
</tr>
<tr>
<td width="50%">

#### 📣 Affiliate or content creator

- Generate buyer guides backed by live prices and images
- Refresh comparison pages automatically on a schedule
- Mine product descriptions for keyword research
- Surface deeply discounted items for deal newsletters

</td>
<td width="50%">

#### 🧠 Data engineer

- Feed pet category data into a feature store for forecasting
- Train recommendation models with real product metadata
- Prototype price-elasticity studies on a known vertical
- Wire the dataset into a Slack alert for stock or price drops

</td>
</tr>
</table>

***

### 🌟 Beyond business use cases

Data like this powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical datasets for papers, thesis work, and coursework
- Longitudinal studies tracking changes across snapshots
- Reproducible research with cited, versioned data pulls
- Classroom exercises on data analysis and ethical scraping

</td>
<td width="50%">

#### 🎨 Personal and creative

- Side projects, portfolio demos, and indie app launches
- Data visualizations, dashboards, and infographics
- Content research for bloggers, YouTubers, and podcasters
- Hobbyist collections and personal trackers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Transparency reporting and accountability projects
- Advocacy campaigns backed by public-interest data
- Community-run databases for local issues
- Investigative journalism on public records

</td>
<td width="50%">

#### 🧪 Experimentation

- Prototype AI and machine-learning pipelines with real data
- Validate product-market hypotheses before engineering spend
- Train small domain-specific models on niche corpora
- Test dashboard concepts with live input

</td>
</tr>
</table>

***

### 🔌 Automating PetFlow Scraper

Run the Actor from your own code or workflow tooling. Every run is exposed as a REST endpoint, with first-class SDKs for Node.js and Python.

- 📦 [**Node.js SDK**](https://docs.apify.com/sdk/js) - start runs, stream the dataset, and react to webhooks.
- 🐍 [**Python SDK**](https://docs.apify.com/sdk/python) - the same primitives in idiomatic Python for analysts.
- 📚 [**Apify API reference**](https://docs.apify.com/api/v2) - call the Actor directly with HTTP, perfect for cron and serverless functions.

Schedules: open the Actor in your console and create a Schedule. Pick a cadence (hourly, daily, weekly), supply the same input you would pass manually, and Apify will run the Actor on the clock and post results to the dataset of your choice.

***

### ❓ Frequently Asked Questions

<details>
<summary><b>💳 Do I need a paid Apify plan to run this Actor?</b></summary>

No. You can start on the free plan, which includes **$5 in monthly credit**. That is enough for several preview runs (10 items each) so you can confirm the Actor fits your use case before committing. Paid plans unlock higher caps, more concurrent runs, and larger datasets. [Create a free Apify account here](https://console.apify.com/sign-up?fpr=vmoqkp).

</details>

<details>
<summary><b>🚨 What happens if my run fails or returns no results?</b></summary>

Failed runs that produce zero records are flagged in the log with a single error item rather than billed for fictional output. If PetFlow's protection blocks every retry in a window, re-run the Actor a few minutes later or [open our contact form](https://tally.so/r/BzdKgA) and we'll investigate.

</details>

<details>
<summary><b>📏 How many items can I scrape per run?</b></summary>

Free users are capped at **10 items per run** so you can preview the output. Paid users can raise `maxItems` up to **1,000,000** per run. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp) if you need full scale.

</details>

<details>
<summary><b>🕒 How fresh is the data?</b></summary>

Every run fetches live data at the moment of execution. There is no cache or delay. The records you get reflect what PetFlow returned at that moment. Schedule the Actor for a rolling snapshot.

</details>

<details>
<summary><b>🧑‍💻 Can I call this Actor from my own code?</b></summary>

Yes. Apify exposes every Actor as a REST endpoint and ships SDKs for [Node.js](https://docs.apify.com/sdk/js) and [Python](https://docs.apify.com/sdk/python). You can start a run, read the dataset, and consume webhooks in a few lines.

</details>

<details>
<summary><b>📤 How do I export the data?</b></summary>

Every Apify dataset can be downloaded from the console as CSV, JSON, JSONL, Excel, HTML, XML, or RSS. You can also pull results programmatically via the [Apify API](https://docs.apify.com/api/v2) or stream them into BigQuery, S3, and other destinations through built-in integrations.

</details>

<details>
<summary><b>📅 Can I schedule the Actor to run automatically?</b></summary>

Yes. Use the Apify scheduler to run the Actor on any cadence, from hourly to monthly. Results land in your dataset and can be delivered to webhooks, email, Slack, cloud storage, Make, or Zapier.

</details>

<details>
<summary><b>🔍 What inputs does the Actor accept?</b></summary>

A category or search URL plus an item cap. Anything you can paste into PetFlow's URL bar (category pages, search results, brand pages) is fair game.

</details>

<details>
<summary><b>🌍 Does this work for non-US shoppers?</b></summary>

Yes. The Actor uses US residential proxies by default because PetFlow ships in the United States, but the dataset itself is locale-agnostic. Prices come in USD, which is the storefront's native currency.

</details>

<details>
<summary><b>🏢 Can I use the data commercially?</b></summary>

The dataset you produce is yours to use within the bounds of [PetFlow's terms of service](https://www.petflow.com/) and applicable law. Apify is the tooling layer; the legal responsibility for downstream use rests with you. When in doubt, consult counsel.

</details>

<details>
<summary><b>⚖️ Is this legal?</b></summary>

Web scraping of publicly accessible product information is broadly permitted in many jurisdictions, but the rules vary by country, by use case, and by the source's terms of service. Use the Actor responsibly, respect rate limits and robots policy, and check legal guidance for your specific application.

</details>

<details>
<summary><b>🛠️ I need a custom version, what now?</b></summary>

[Open our contact form](https://tally.so/r/BzdKgA) with a short description. We build custom Apify Actors, extend existing ones with new fields, and deliver private deployments for teams.

</details>

***

### 🔌 Integrate with any app

- [**Make**](https://docs.apify.com/platform/integrations/make) - automate multi-step workflows on a visual canvas
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - connect to 5,000+ apps with no code
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - sync runs and datasets with version control
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - get notifications when a run finishes
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - move data into your warehouse on a schedule
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - drop CSVs directly into shared drives

***

### 🔗 Recommended Actors

- [**🛒 Shopee Scraper**](https://apify.com/parseforge/shopee-scraper) - pull e-commerce listings from Shopee with prices, ratings, and stock status
- [**🎸 Guitar Center Scraper**](https://apify.com/parseforge/guitar-center-scraper) - extract musical instrument products from a major retail catalog
- [**👜 The RealReal Scraper**](https://apify.com/parseforge/therealreal-scraper) - scrape luxury resale listings with brand, price, and condition data
- [**🚗 Cars24 Scraper**](https://apify.com/parseforge/cars24-scraper) - collect vehicle listings with specs, pricing, and inventory signals
- [**🏪 OLX Scraper**](https://apify.com/parseforge/olx-scraper) - harvest classifieds across categories with seller and pricing details

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more retail and marketplace scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) and we'll get back to you within one business day.

***

> ⚠️ **Disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by PetFlow.com or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

# Actor input Schema

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

URL of a PetFlow category or search page to scrape (e.g. https://www.petflow.com/dog/food or https://www.petflow.com/search?q=treats).

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

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

Proxy settings. Residential proxies are required to bypass bot protection.

## Actor input object example

```json
{
  "startUrl": "https://www.petflow.com/dog/food",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrl": "https://www.petflow.com/dog/food",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/petflow-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 = {
    "startUrl": "https://www.petflow.com/dog/food",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/petflow-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 '{
  "startUrl": "https://www.petflow.com/dog/food",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parseforge/petflow-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Petflow Scraper",
        "description": "Collect pet supplies product data from PetFlow.com including prices, discounts, brand info, stock availability, ratings, and full descriptions. Browse by category like dog food, cat food, treats, and more. Handles bot protection automatically.",
        "version": "1.0",
        "x-build-id": "qJ7jsmJMZedH6y8fU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~petflow-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-petflow-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~petflow-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-petflow-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~petflow-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-petflow-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",
                "required": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "Start URL",
                        "type": "string",
                        "description": "URL of a PetFlow category or search page to scrape (e.g. https://www.petflow.com/dog/food or https://www.petflow.com/search?q=treats)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are required to bypass bot protection."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
