# 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, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$10.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)

## 🐾 PetFlow Scraper

Collect pet supply product data from PetFlow.com without coding. This scraper bypasses Cloudflare protection, extracts prices, ratings, inventory status, and product details in minutes, making it perfect for competitive analysis, price monitoring, and market research. No manual data entry, no coding required.

> **The PetFlow Scraper collects pet supplies product data with up to 14 fields per product, automatically handling Cloudflare bot protection via residential proxies.**

### ✨ What Does It Do

- 🖼️ **Product Image** - Display product photos in market research or competitor comparison dashboards
- 📝 **Product Name** - Track exact product titles for catalog management and cross-site comparison
- 👤 **Brand** - Identify suppliers and manufacturers to analyze brand distribution and positioning
- 💰 **Current Price** - Monitor real-time costs to understand market rates and stay competitive
- 💵 **Original Price** - Calculate discount percentages and identify sales trends across categories
- ⭐ **Customer Rating** - Assess product quality and customer satisfaction to inform purchasing decisions
- 📊 **Review Count** - Measure product popularity and trust signals to identify bestsellers vs niche items
- 📝 **Description** - Extract detailed specifications for marketing or product comparison pages
- ✅ **In Stock Status** - Monitor availability to identify supply chain issues and plan inventory
- 📦 **SKU** - Link scraped products to your internal systems for inventory synchronization
- 🔗 **Product URL** - Build direct links to products for affiliate marketing or databases
- 📂 **Category** - Organize products by type for targeted analysis and reporting
- 📅 **Scraped At** - Timestamp each collection for historical cost tracking and trend analysis

### 🔧 Input

- **Start URL** - Provide a PetFlow category page like https://www.petflow.com/dog/food to begin collecting
- **Max Items** - Set how many products to collect per run, from 1 to 1,000,000 for paid users
- **Proxy Configuration** - Residential proxies are required to bypass bot protection. The actor defaults to Apify's residential proxy group or you can configure your own

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

### 📊 Output

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

| 🖼️ Image URL | 📝 Product Name | 👤 Brand |
|---|---|---|
| 💰 Current Price | 💵 Original Price | ⭐ Rating |
| 📊 Review Count | ✅ Stock Status | 📦 SKU |
| 🔗 Product URL | 📂 Category | 📝 Description |
| 📅 Scraped At | 🚨 Error | |

### 💎 Why Choose the PetFlow Scraper?

| Feature | Our Actor |
|---|---|
| Cloudflare bypass via residential proxies | ✔️ |
| Up to 14 fields per product | ✔️ |
| Pagination support (multiple pages) | ✔️ |
| Stock status tracking | ✔️ |
| Historical cost monitoring with timestamps | ✔️ |
| CSV, JSON, and Excel export | ✔️ |
| Real-time customer ratings and review counts | ✔️ |
| Automatic image URL extraction | ✔️ |
| SKU and product ID capture | ✔️ |
| Free preview mode (up to 10 items) | ✔️ |
| Retry logic for failed requests | ✔️ |
| Multi-page category scraping | ✔️ |

### 📋 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 "PetFlow 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. Export your data in CSV, Excel, or JSON format.

### 🎯 Business Use Cases

- 📊 **Market Researcher** - Monitor cost changes on bestselling dog food products weekly to track inflation trends and inform analysis reports
- 💼 **E-commerce Manager** - Collect competitor product ratings and review counts monthly to identify gap opportunities in the cat supplies market before launching new SKUs
- 📣 **Content Creator** - Extract product descriptions and images to bulk-populate affiliate product comparison guides and earn commissions on referred sales

### ❓ FAQ

**🔍 How does it work?**
The scraper uses residential proxies to bypass bot protection, then parses product pages to extract prices, ratings, stock status, and other details.

**📊 Is the data accurate?**
Yes. The scraper captures live data directly from product pages in real time, showing prices, ratings, and availability exactly as displayed on PetFlow.com.

**📅 Can I schedule runs automatically?**
Yes. Use Apify's scheduling feature to run the scraper daily, weekly, or on any custom interval. Export results to your database or spreadsheet automatically.

**⚖️ Is this allowed?**
The data you collect is publicly available. You are responsible for complying with PetFlow.com's terms of service and local laws. Always check the website's terms before collecting data.

**🛡️ Will PetFlow block me?**
PetFlow uses bot protection. The scraper handles this automatically with residential proxies, which rotate addresses to appear as real users. Proxy support is built in.

**⚡ How long does a run take?**
Speed depends on page count and item count. A typical category with 50-100 products completes in 2-5 minutes. Larger collections may take longer due to proxy rotation delays.

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

### 🔗 Integrate PetFlow 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

- [Asc Global Mro Scraper](https://apify.com/parseforge/asc-global-mro-scraper) - Scrape industrial MRO parts and data
- [Revzilla Scraper](https://apify.com/parseforge/revzilla-scraper) - Collect motorcycle gear products and reviews
- [SEC Forms Scraper](https://apify.com/parseforge/sec-forms-scraper) - Extract regulatory filings and company data
- [Indexmundi Scraper](https://apify.com/parseforge/indexmundi-scraper) - Gather commodity data and market information
- [Auctiontime Scraper](https://apify.com/parseforge/auctiontime-scraper) - Collect heavy equipment auction listings

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 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": "7QrKdjqbgCYcODHMu"
    },
    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
