# Rover Scraper \[$2💰] | Pet Sitters | Walkers | Reviews (`ahmed_jasarevic/rover-scraper`) Actor

Extract Rover.com pet sitter and dog walker profiles for pet care market research, lead generation and price comparison. Get names, prices, ratings, reviews, repeat clients, background-check status and full profiles by city or ZIP — $0.002 per sitter, $0.0035 per review.

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

## Pricing

from $1.85 / 1,000 sitters

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

Scrape **pet sitters, dog walkers, and pet-care providers** from [Rover.com](https://www.rover.com) — the world's largest pet-sitting marketplace. This Actor is a **Rover.com API alternative**: point it at any city, state, or ZIP code and it returns structured JSON with sitter names, prices, ratings, reviews, repeat clients, neighborhood/city/state, distance, **background-check status**, Star Sitter badges, bios, service rates, response rates, and full profiles. Pay **$0.002 per sitter** and **$0.0035 per review** — no subscription, no official API required.

### Main Use Cases

- **Pet sitter lead generation** — build targeted lists of local pet-care providers (name, profile URL, city, state, rating) for outreach and local directories
- **Pet care market research** — analyze Rover's marketplace at metro scale to size supply, spot price bands, and track how sitter density changes over time
- **Dog boarding & sitting price comparison** — compare per-night boarding, dog-walking, drop-in, and day-care rates across cities to benchmark pricing
- **Pet services competition analysis** — map who the top-rated, most-reviewed, and background-checked providers are in any neighborhood
- **Rover review analysis** — collect individual review text, ratings, reviewer names, and dates for sentiment and reputation research
- **Franchise & site selection research** — evaluate local pet-care supply when choosing where to open a facility, groomer, or day care

### How It Works

Rover.com is a Next.js application that embeds all sitter and review data in a `#__NEXT_DATA__` JSON blob inside the page HTML. This Actor uses **CheerioCrawler** (fast plain-HTTP requests + HTML parsing — **no browser needed**) and works in up to three passes:

1. **Search pass** — loads the Rover search page for your `serviceType` + `location` (or a pasted `searchUrls` link) and extracts sitter cards from the embedded JSON, with CSS-selector fallbacks.
2. **Profile pass (optional)** — visits each sitter's profile page to enrich records with bio, all service rates, response rate/time, badges, photos, and years of experience.
3. **Reviews pass (optional)** — scrapes individual reviews (rating, text, reviewer name, date) from each profile and stores them in a **dedicated `reviews` dataset**.

Results land in an Apify Dataset you can download as **JSON, HTML, CSV, or Excel**, or consume over the REST API / MCP. Because there's no browser rendering, runs are fast and cheap; a residential proxy can be enabled if Rover blocks your datacenter IP.

### Build Pet Care Market Research Databases

Every sitter is returned as one structured record — the same fields that power Rover's own search and profile UI. Because we parse the embedded `__NEXT_DATA__` payload (not plain HTML), you get **numeric prices per night/visit**, **star ratings**, **review counts**, **repeat-client counts**, **exact distance in miles**, **background-check status**, and **Star Sitter badges** — data that is hard to get reliably from shallow HTML scraping.

Run the same cities **monthly** to build a time-series pet-care supply database: watch price-per-night drift, top-rated-sitter churn, and which neighborhoods gain or lose vetted providers. The output plugs directly into spreadsheets, BI dashboards, and research reports.

### Compare Dog Walking & Sitting Prices by City

Dog walking and pet-sitting rates vary dramatically by market — typical 30-minute walks run roughly **$15–$30** in the US (higher in NYC, LA, and SF), boarding **$35–$75 per night**, and drop-in visits **$20–$30**. Scrape `serviceType` `dog-walking`, `overnight-boarding`, `drop-in`, or `doggy-day-care` across multiple cities and compare actual listed provider rates field-by-field: `pricePerNight`, `services[].price`, `distanceMiles`, `rating`, and `reviewCount` give you a real, current rate card per city without guesswork or third-party estimates.

### Input

| Field                | Type    | Required | Description                                                                  |
| -------------------- | ------- | -------- | ---------------------------------------------------------------------------- |
| `searchUrls`         | array   | optional | Rover.com search-result URLs (leave empty to use `serviceType` + `location`) |
| `serviceType`        | string  | optional | One of `overnight-boarding`, `overnight-traveling`, `dog-walking`, `drop-in`, `doggy-day-care`, `dog-training` (default `overnight-boarding`) |
| `location`           | string  | optional | City, State or ZIP code to search near, e.g. `New York, NY` or `10001`        |
| `maxItems`           | integer | optional | Max sitter profiles to scrape (1–500, default 20)                             |
| `fetchProfiles`      | boolean | optional | Visit each sitter's profile for bio, rates, response rate (default `true`)    |
| `fetchReviews`       | boolean | optional | Collect individual reviews into the `reviews` dataset (default `false` — billed separately) |
| `maxReviewsPerSitter`| integer | optional | Max reviews per sitter when `fetchReviews` is on (default 5)                  |
| `proxy`              | object  | optional | Apify proxy configuration; enable residential if access is blocked            |

### Output

**Sitter records** (default dataset, `overview` view):

| Field              | Type             | Description                                      |
| ------------------ | ---------------- | ------------------------------------------------ |
| `name`             | string           | Sitter's display name                            |
| `profileUrl`       | string           | Full URL to the sitter's profile                 |
| `profileId`        | string           | Sitter's profile slug/ID                         |
| `serviceType`      | string           | Service code (e.g. `overnight-boarding`)         |
| `serviceTypeLabel` | string           | Human-readable service (e.g. "Dog Boarding")     |
| `pricePerNight`    | number           | Base price in USD per night/visit                |
| `rating`           | number           | Average star rating (0–5)                        |
| `reviewCount`      | number           | Number of reviews                                |
| `repeatClients`    | number           | Repeat-client count                              |
| `neighborhood`     | string           | Neighborhood name                                |
| `city` / `state`   | string           | City and state code                              |
| `distanceMiles`    | number           | Distance from search location                    |
| `profilePhoto`     | string           | Profile photo URL                                |
| `backgroundChecked`| boolean          | Passed a background check?                       |
| `starSitter`       | boolean          | Has the Star Sitter badge?                       |
| `bio`              | string           | Sitter bio (profile pass)                        |
| `responseRate`     | number           | Response rate % (profile pass)                   |
| `services`         | array            | Per-service rates, e.g. `[{ name, price, unit }]`|
| `scrapedAt`        | string           | ISO timestamp of extraction                      |

**Review records** (separate `reviews` dataset): `sitterName`, `sitterProfileId`, `sitterProfileUrl`, `rating`, `text`, `reviewerName`, `date`, `scrapedAt`.

### Example Input JSON

```json
{
  "serviceType": "overnight-boarding",
  "location": "New York, NY",
  "maxItems": 100,
  "fetchProfiles": true,
  "fetchReviews": true,
  "maxReviewsPerSitter": 5,
  "proxy": { "useApifyProxy": false }
}
```

### Example Output JSON

```json
{
  "name": "John C.",
  "profileUrl": "https://www.rover.com/members/john-c-wfh-dad/",
  "profileId": "john-c-wfh-dad",
  "serviceType": "overnight-boarding",
  "serviceTypeLabel": "Dog Boarding",
  "pricePerNight": 50,
  "rating": 5.0,
  "reviewCount": 43,
  "repeatClients": 15,
  "neighborhood": "Upper East Side",
  "city": "New York",
  "state": "NY",
  "distanceMiles": 2.4,
  "profilePhoto": "https://www.rover.com/cf-image-cdn/remote/images/people/APa6vVYN/sgziwdqwpq/original.jpeg",
  "backgroundChecked": true,
  "starSitter": true,
  "bio": "Dog lover with 5 years of experience...",
  "responseRate": 95,
  "services": [{ "name": "Dog Boarding", "price": 50, "unit": "night" }],
  "scrapedAt": "2026-01-15T10:30:00+00:00"
}
```

```json
{
  "sitterName": "John C.",
  "sitterProfileId": "john-c-wfh-dad",
  "sitterProfileUrl": "https://www.rover.com/members/john-c-wfh-dad/",
  "rating": 5,
  "text": "John took wonderful care of our pup and sent updates daily.",
  "reviewerName": "Sarah M.",
  "date": "2025-11-02",
  "scrapedAt": "2026-01-15T10:31:00+00:00"
}
```

### Integrations & Scheduling

This Actor runs on the Apify platform, so you get **scheduling**, a **REST API**, an **MCP server**, and native integrations with **Zapier, Make (Integromat), n8n, LangChain**, and custom webhooks out of the box. Feed the dataset directly into Google Sheets, Airtable, a CRM, or a BI tool.

**Recommended: monthly pet market snapshot.** Schedule a monthly run per target city/service type to build a longitudinal dataset of sitter supply, price-per-night trends, and top-rated providers. Because sitter availability and rates change constantly, a consistent monthly cadence gives you clean, comparable slices over time.

### Related Actors

- [Yelp Reviews Scraper](https://apify.com/web_wanderer/yelp-reviews-scraper) — extract reviews, ratings, and business info from Yelp for local-services reputation research
- [Yelp Ultimate Scraper](https://apify.com/api-ninja/yelp-ultimate-scraper) — Yelp business listings, details, menus, and reviews for market research
- [Rover Pet Sitter Search Scraper](https://apify.com/easyapi/rover-pet-sitter-search-scraper) — search Rover.com for pet sitter listings (alternative Rover data source)
- [Thumbtack Pro Listing Scraper](https://apify.com/easyapi/thumbtack-pro-listing-scraper) — local professional service providers, reviews, and pricing for lead generation
- [Pet Services Lead Finder](https://apify.com/seibs.co/pet-services-lead-finder) — US independent pet services businesses from Google Maps with enriched contact data

### FAQ

**Does Rover have an official API?**
Rover.com does not publish a public developer API for sitter search, profiles, or reviews. This Actor is a reliable, current alternative — it reads the same embedded data Rover's own pages use and exposes it as structured JSON via the Apify REST API.

**What does it cost to scrape Rover.com?**
This Actor is **pay-per-event**: **$0.002 per sitter**, **$0.0035 per review**, plus a small per-run start fee (one event per GB of memory). Enable `fetchReviews` only when you actually need review text — reviews are billed separately from sitter records. Keep `maxItems` small for quick tests.

**How fast is it?**
CheerioCrawler uses plain HTTP + HTML parsing (no browser), so it is fast and cheap. Rover is Cloudflare-protected: if you hit blocks or 403s, enable Apify's residential proxy.

**Can I scrape multiple cities in one run?**
Yes — paste multiple Rover search URLs into `searchUrls`, or run the same input per city. Each sitter is stored as one dataset row so you can dedupe and aggregate by city.

**Do I get reviews too?**
Review counts come on every sitter record. To get individual review text, enable `fetchReviews` (billed at $0.0035 per review, capped by `maxReviewsPerSitter`).

**Is this legal?**
The Actor extracts publicly visible data from Rover.com. You are responsible for complying with Rover's Terms of Service and applicable laws, and for how you use the data you collect.

### SEO Keywords

rover scraper, scrape rover.com, pet sitter data, pet sitter database, dog walker directory, pet care business leads, pet sitter leads, pet sitting market size, dog boarding market research, pet sitter pricing data, dog walker pricing, dog walking prices, dog boarding prices, pet services marketplace, pet care market research, local pet business research, background checked pet sitters, top rated pet sitters, rover sitter profiles, rover reviews, pet boarding providers, puppy care providers, pet services competition analysis, rover api alternative, pet services data

### For AI Agents & LLM Apps

**Purpose.** Give an agent or RAG pipeline structured, current pet-care marketplace data from Rover.com — sitter supply, pricing, ratings, and reviews — without a browser or an official API.

**Minimal input.** Agents only need a `location` (plus optionally `maxItems`):

```json
{ "location": "Denver, CO", "maxItems": 50 }
```

**Output fields.** Agent-relevant sitter fields: `name`, `profileUrl`, `profileId`, `serviceTypeLabel`, `pricePerNight`, `rating`, `reviewCount`, `repeatClients`, `city`, `state`, `neighborhood`, `distanceMiles`, `backgroundChecked`, `starSitter`, `bio`, `responseRate`, `services[]`. When `fetchReviews` is enabled, review items land in a second dataset with `sitterName`, `rating`, `text`, `reviewerName`, `date`.

**Behaviors.** `fetchReviews` adds $0.0035 per review — enable it only when review text is actually required. Set `fetchProfiles: false` for fast, cheap search-card-only data. Consume results via `{{storages.datasets.default.apiUrl}}/items` and `{{storages.datasets.reviews.apiUrl}}/items`.

**Billing model (for cost-aware agents).** $0.002 per sitter record, $0.0035 per review record, plus a tiny per-run start fee scaled to memory. A 100-sitter run without reviews costs about $0.20.

### Legal & Compliance Disclaimer

This Actor is **not affiliated with, endorsed by, or connected to Rover / Rover.com** in any way. It extracts **publicly visible information** from Rover.com's public pages. Sitter profiles returned by this Actor include publicly displayed information such as **provider names, bios, ratings, and locations** — whatever sitters themselves choose to show publicly. You may be handling personal data, which is protected by GDPR in the EU and by other regulations worldwide. Only collect and use this data where you have a legitimate purpose, keep it secure, and do not use it for spam, harassment, discrimination, or any unlawful activity. You are solely responsible for complying with Rover's Terms of Service and all applicable laws in your jurisdiction.

# Actor input Schema

## `searchUrls` (type: `array`):

Rover.com search result URLs to scrape. Leave empty to use the search parameters below.

## `serviceType` (type: `string`):

Type of pet care service to search for.

## `location` (type: `string`):

City, State or ZIP code to search near (e.g. 'New York, NY', '10001').

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

Maximum number of sitter profiles to scrape.

## `fetchProfiles` (type: `boolean`):

Visit each sitter's profile page to get bio, all services, response rate, and detailed info. Slower but richer data.

## `fetchReviews` (type: `boolean`):

Collect individual reviews for each sitter. Off by default because popular sitters can have hundreds of reviews.

## `maxReviewsPerSitter` (type: `integer`):

Maximum reviews to collect per sitter when Fetch Reviews is on.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchUrls": [
    {
      "url": "https://www.rover.com/search/?service_type=overnight-boarding&location=New+York%2C+NY"
    }
  ],
  "serviceType": "overnight-boarding",
  "location": "New York, NY",
  "maxItems": 20,
  "fetchProfiles": true,
  "fetchReviews": false,
  "maxReviewsPerSitter": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `profiles` (type: `string`):

One item per sitter profile, auto-charged as a default dataset item.

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

Individual review items, billed via the 'rover-review-item' pay-per-event signal.

# 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 = {
    "searchUrls": [
        {
            "url": "https://www.rover.com/search/?service_type=overnight-boarding&location=New+York%2C+NY"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/rover-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 = {
    "searchUrls": [{ "url": "https://www.rover.com/search/?service_type=overnight-boarding&location=New+York%2C+NY" }],
    "proxy": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchUrls": [
    {
      "url": "https://www.rover.com/search/?service_type=overnight-boarding&location=New+York%2C+NY"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/rover-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/SleYuReieLQ5DYwbk/builds/uPlgzLEVXiRJcUD6M/openapi.json