# Sittercity Caregiver Listings Scraper (`crawlerbros/sittercity-scraper`) Actor

Scrape Sittercity city/state caregiver listings - babysitters, nannies, child care, companion/senior care, pet care, and special needs caregivers. Get names, rates, experience, ratings, reviews, and trust & safety badges. No auth, no proxy needed.

- **URL**: https://apify.com/crawlerbros/sittercity-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Sittercity Caregiver Listings Scraper

Scrape **Sittercity** city/state caregiver listing pages — babysitters, nannies, child care, companion/senior care, pet sitting, and special needs caregivers. Get names, hourly rates, years of experience, ratings, review snippets, trust & safety badges, and area-level aggregate stats (active caregiver counts, average rates) for any US city. Also scrapes Sittercity's **family-posted job listings** (real jobs families are hiring for, across 6 categories including housekeeping). Includes a **Discover Cities** mode that enumerates every valid city/state combination straight from Sittercity's own public sitemap, so you never have to guess a city slug. HTTP-only, no login, no cookies, no proxy required.

### What this actor does

- **6 caregiver categories:** `babysitters`, `nannies`, `childCare`, `companionCare` (senior/elder care), `petSitting`, `specialNeeds`
- **6 job-postings categories:** real family-posted job listings for `babysittingJobs`, `nannyJobs`, `petSittingJobs`, `companionCareJobs`, `specialNeedsJobs`, and `housekeepingJobs` — pay rate, schedule, children/pets count, and job description for each open job
- **Any US city/state:** covers Sittercity's full nationwide coverage — pick any of the 50 states + DC and any city Sittercity lists
- **Rich per-caregiver data:** name, photo, years of paid experience, distance, hourly rate range (where shown), star rating, review count, bio, trust & safety badges, and a recent review snippet (where available)
- **Area aggregate stats:** a bonus record per run with area-level numbers Sittercity publishes (active caregiver count, average hourly rate, total 5-star reviews, or total providers in the area)
- **Advanced Search mode:** hits Sittercity's real full-database, ZIP+radius search endpoint — the true full caregiver count with real pagination (thousands of results in most metro areas), not the curated top-10 the Babysitters/Nannies/Child Care city landing pages cap at — plus real server-side filters: hourly rate, background-check level, years of experience, language spoken, "must have a car", recently-active window, and free-text keyword
- **Discover Cities mode:** enumerate every city/state Sittercity has a live listing page for, per category, straight from Sittercity's public sitemap — optionally filtered to one state
- **Child-care specialty niches:** optionally filter `childCare` (9 niches) or `nannies` (6 niches) to a specific need — before-school, after-school, tutoring, homeschool, hybrid-learning, eLearning, bilingual, ASL-speaking, or overnight — via the `careNiche` input, returning a genuinely different set of caregivers than the unfiltered category page
- **Empty fields are omitted** — a record only contains the fields that were actually present on the page, never `null` or placeholder values

### Output per caregiver

- `name` — caregiver's display name (e.g. `"Anna C."`)
- `providerId` — Sittercity's internal caregiver UUID
- `providerNumericId` — Sittercity's internal numeric caregiver ID (companion care / pet sitting / special needs only)
- `careCategory` — friendly category label (e.g. `"Babysitter"`, `"Pet Care Provider"`)
- `careType` — Sittercity's internal care-type code (e.g. `babysitter`, `nanny`, `companion_care`, `pet_care`)
- `photoUrl` — caregiver's profile photo
- `yearsExperience` — years of paid caregiving experience
- `distanceMiles` — distance from the searched city center
- `city`, `state`, `zipCode` — caregiver's location (zip code only on babysitters/nannies/childCare)
- `bio` — caregiver's self-written profile snippet
- `badges[]` — self-reported trust & safety badges (e.g. `"First Aid Training"`, `"CPR Certification"`, `"Basic Background Check"`, `"Enhanced Background Check"`)
- `hourlyRateMin`, `hourlyRateMax` — hourly rate range in USD (babysitters/nannies/childCare only — see Limitations)
- `rating` — average star rating (0–5)
- `reviewCount` — number of reviews behind the rating
- `recentReviewRating`, `recentReviewerName`, `recentReviewText` — most recent review snippet (babysitters/nannies/childCare only)
- `careNiche` — the child-care specialty filter applied, if any (e.g. `"Tutoring / Homework Help"`) — only present when `careNiche` input was set and valid for the chosen `mode`
- `profileUrl` — link to the caregiver's full profile page, **as seen on the listing page only — this URL is never itself scraped** (see Limitations)
- `sourceUrl` — the listing page this record was scraped from
- `recordType` — always `"caregiver"`
- `scrapedAt` — UTC ISO timestamp

### Output: area summary (one bonus record per run)

- `activeCaregiverCount` — number of active caregivers in the area (babysitters/nannies/childCare)
- `averageHourlyRate` — average hourly rate for the area (babysitters/nannies/childCare)
- `platformFiveStarReviewCount` — total 5-star reviews shown on the page (babysitters/nannies/childCare)
- `totalProvidersInArea` — total caregivers matching the search (companionCare/petSitting/specialNeeds)
- `careCategory`, `state`, `city`, `sourceUrl`
- `recordType` — always `"areaSummary"`
- `scrapedAt`

### Output per job posting (Job Postings modes only)

- `jobTitle` — the family's job title/headline for the posting
- `jobId` — Sittercity's internal numeric job ID
- `jobUrl` — direct link to the job posting
- `payRate` — single hourly/nightly rate, when the posting shows one flat rate
- `payRateMin`, `payRateMax` — pay range, when the posting shows a range (e.g. `$10-23/hr`)
- `payUnit` — pay unit, e.g. `hr`, `night`, `day` (omitted when the family didn't list a rate)
- `childrenCount` — number of children the job involves (babysitting/nanny/child-care/special-needs jobs)
- `petsCount` — number of pets the job involves (pet-sitting jobs)
- `serviceType` — the specific service requested (e.g. `"Babysitting"`, `"Nanny"`, `"Overnight Pet Care"`, `"Home Care"`)
- `city`, `state` — job location
- `distanceMiles` — distance from the searched city center
- `scheduleType` — schedule category (e.g. `"Occasional"`, `"One-time"`, `"Weekly"`)
- `scheduleDays` — active weekdays for recurring ("Weekly"/"One-time") schedules, e.g. `["Mon", "Tue", "Wed", "Thu", "Fri"]` (omitted for "Occasional"/as-needed jobs, which have no fixed weekday pattern)
- `scheduleDetail` — schedule specifics (times/dates/flexibility notes)
- `description` — the family's job description (as shown on the listing card, may be truncated with `...` — see Limitations)
- `postedByName` — first name + last initial of the family who posted the job
- `postedDate` — date posted, as shown (`M/D/YYYY`)
- `postedDateIso` — the same date, normalized to `YYYY-MM-DD`
- `jobCategory` — friendly category label (e.g. `"Babysitting Job"`, `"Housekeeping Job"`)
- `sourceUrl` — the job-listing page this record was scraped from
- `recordType` — always `"jobPosting"`
- `scrapedAt` — UTC ISO timestamp

### Advanced Search mode (`mode: "advancedSearch"`)

Sittercity's city/state landing pages you get from the normal caregiver-category modes are two different templates:

- Babysitters / Nannies / Child Care: a curated top-10 "SEO landing page", capped hard at ~10 caregivers per city.
- Companion Care / Pet Sitting / Special Needs: real pagination, but no rate/keyword/background-check filtering.

`mode: "advancedSearch"` instead hits Sittercity's own ZIP+radius **search** endpoint (the same one behind the "Refine Results" sidebar on their own site) — it returns the true full result count (often thousands per metro area) with real pagination for **all 6 caregiver categories**, plus real server-side filters. Uses `searchCategory` (not `mode`'s caregiver values) + `zipCode` (required) instead of `state`/`city`.

Records use the same caregiver-record shape as every other mode, plus extra fields:

- `searchZipCode` — the ZIP code searched
- `searchDistanceMiles` — the search radius used
- `sortBy` — only present when a non-default sort was requested

#### Filters

| Field | Options |
|---|---|
| `searchDistance` | `1`, `2`, `5`, `10`, `15`, `25` (default), `40`, `50` miles |
| `sortBy` | `relevance` (default), `distance` (closest first), `rate`, `experience` (most years first) — result ordering, verified live across every `searchCategory` |
| `rateFacet` | `11-15`, `16-20`, `21-30`, `31-40`, `40+` ($/hr) |
| `backgroundCheckFacet` | `any`, `basic_criminal`, `enhanced_criminal`, `motor_vehicle` |
| `yearsExperienceFacet` | `1-2`, `3-5`, `6-10`, `11+` |
| `lastLoginFacet` | `one_week`, `two_weeks`, `one_month`, `three_months` |
| `languageFacet` | 50 languages (Spanish, Mandarin, ASL, French, etc.) |
| `requiresTransportation` | boolean — only caregivers who indicated they have a car |
| `searchKeyword` | free-text search of caregiver bios |
| `petTypeFacet` | Pet Sitting only — 9 pet types (dogs, cats, birds, horses, farm animals, reptiles/amphibians, exotic pets, small mammals, other) |
| `seniorAgeFacet` | Companion Care only — 5 senior age ranges (under 55 through over 85) |
| `specialNeedsAgeFacet` | Special Needs only — 5 age groups (infant, toddler, youth, adult, senior) |

The last 3 filters are category-specific "Refine Results" facets that only exist upstream for one `searchCategory` each (verified live 2026-07-26) — sending one for any other category is silently ignored with a status-message note rather than erroring.

**A handful of (filter, category) combinations are not reliably supported upstream** — verified live: `rateFacet` + Babysitters, `languageFacet` + Pet Sitting, and `requiresTransportation` + Companion Care or Pet Sitting each consistently return an unrendered 0-result page from Sittercity itself, even though the same filter works fine for every other category and the unfiltered category has thousands of real matches. Rather than silently shipping that broken 0-result page as if it were a genuine "no matches" answer, this actor detects those 4 specific combinations, **drops just that filter**, still returns real results for every other filter/category you asked for, and logs + notes it in the run's status message. All other filter/category combinations (26 of 30 tested) work correctly.

### Output: city discovery (Discover Cities mode only)

- `careCategory` — friendly category label the discovered city applies to (caregiver-listing categories only)
- `careType` — Sittercity's internal care-type code (caregiver-listing categories only)
- `jobCategory` — friendly job-category label (job-listing categories only — see below)
- `state` — 2-letter state code (uppercase)
- `city` — city slug, ready to paste into the `city` input field
- `cityDisplay` — human-readable city name
- `listingUrl` — the exact listing page this actor would scrape for that city/state/category
- `sourceSitemapUrl` — which sitemap fragment this city/state pair came from
- `recordType` — always `"cityListing"`
- `scrapedAt`

`discoverCategory` also accepts 5 job-posting categories (`babysittingJobs`, `nannyJobs`, `petSittingJobs`, `companionCareJobs`, `specialNeedsJobs`) — Sittercity's own sitemap separately enumerates real city-listing pages for job postings, distinct from the caregiver-listing pages (verified live: 11,000+ city entries per category). `housekeepingJobs` isn't included here — its sitemap entries are individual job-posting URLs, not a discoverable city list — but its city/state listing page still works fine if you already know the city slug (use `childCare`/`babysitters`' discovered slugs, which cover the same US cities).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `babysitters` | Category to scrape: `babysitters` / `nannies` / `childCare` / `companionCare` / `petSitting` / `specialNeeds` (caregiver listings), `babysittingJobs` / `nannyJobs` / `petSittingJobs` / `companionCareJobs` / `specialNeedsJobs` / `housekeepingJobs` (family job postings), `advancedSearch` (real full-database ZIP+radius search with filters), or `discoverCities` (discover valid cities instead of scraping) |
| `discoverCategory` | string | `babysitters` | Only used when `mode` is `discoverCities`. Which category's valid city/state pages to enumerate — a caregiver-listing category (`babysitters`/`nannies`/`childCare`/`companionCare`/`petSitting`/`specialNeeds`) or a job-postings category (`babysittingJobs`/`nannyJobs`/`petSittingJobs`/`companionCareJobs`/`specialNeedsJobs`) |
| `searchCategory` | string | `babysitters` | Only used when `mode` is `advancedSearch`. Which caregiver category to search |
| `zipCode` | string | *(none)* | Required when `mode` is `advancedSearch`. 5-digit US ZIP code to search near |
| `searchDistance` | string | `25` | Only used when `mode` is `advancedSearch`. Search radius in miles: `1`/`2`/`5`/`10`/`15`/`25`/`40`/`50` |
| `sortBy` | string | `relevance` | Only used when `mode` is `advancedSearch`. Result order: `relevance`/`distance`/`rate`/`experience` |
| `rateFacet` | string | *(none)* | Only used when `mode` is `advancedSearch`. Hourly-rate filter — see Advanced Search section for options and a known limitation |
| `backgroundCheckFacet` | string | *(none)* | Only used when `mode` is `advancedSearch`. Background-check level filter |
| `yearsExperienceFacet` | string | *(none)* | Only used when `mode` is `advancedSearch`. Years-of-experience filter |
| `lastLoginFacet` | string | *(none)* | Only used when `mode` is `advancedSearch`. Recently-active window filter |
| `languageFacet` | string | *(none)* | Only used when `mode` is `advancedSearch`. Language-spoken filter — see Advanced Search section for a known limitation |
| `requiresTransportation` | boolean | `false` | Only used when `mode` is `advancedSearch`. Only return caregivers who indicated they have a car — see Advanced Search section for a known limitation |
| `searchKeyword` | string | *(none)* | Only used when `mode` is `advancedSearch`. Free-text keyword search of caregiver bios |
| `petTypeFacet` | string | *(none)* | Only used when `mode` is `advancedSearch` and `searchCategory` is `petSitting`. Type-of-pet filter |
| `seniorAgeFacet` | string | *(none)* | Only used when `mode` is `advancedSearch` and `searchCategory` is `companionCare`. Senior age-range filter |
| `specialNeedsAgeFacet` | string | *(none)* | Only used when `mode` is `advancedSearch` and `searchCategory` is `specialNeeds`. Age-group filter |
| `careNiche` | string | *(none)* | Optional specialty filter. Only real for `mode: "childCare"` (all 9: `beforeSchool` / `afterSchool` / `tutoring` / `homeschool` / `hybridLearning` / `elearning` / `bilingual` / `aslSpeaking` / `overnight`) and `mode: "nannies"` (6: `beforeSchool` / `afterSchool` / `tutoring` / `homeschool` / `hybridLearning` / `elearning`). Any other mode, or a niche not offered for the chosen mode, is silently ignored and the normal unfiltered listing is scraped instead |
| `state` | string | `mi` | US state, 2-letter code (dropdown of all 50 states + DC). In `discoverCities` mode this is an optional filter — leave it out to discover cities nationwide |
| `city` | string | `detroit` | City name — lowercase with hyphens instead of spaces (e.g. `detroit`, `new-york`, `los-angeles`). Not used in `discoverCities` or `advancedSearch` mode |
| `maxItems` | integer | `20` | Max records to return (1–500). Babysitters / Nannies / Child Care cap at ~10 per city with their normal `mode` (the curated landing-page template has no further pagination — use `advancedSearch` for full pagination on these categories); Companion Care / Pet Sitting / Special Needs support full pagination up to this limit; `advancedSearch` supports full pagination up to this limit for all 6 categories; Job Postings modes cap at whatever is actually posted for that city (typically 1–15 — the source's own listing page shows only one page, and `robots.txt` disallows further job-listing pagination); in `discoverCities` mode this caps the number of city/state pairs returned |

### Examples

#### Example: babysitters in Detroit, MI

```json
{
  "mode": "babysitters",
  "state": "mi",
  "city": "detroit",
  "maxItems": 20
}
```

#### Example: nannies in Los Angeles, CA

```json
{
  "mode": "nannies",
  "state": "ca",
  "city": "los-angeles",
  "maxItems": 10
}
```

#### Example: bilingual before-school child-care providers in Detroit, MI

```json
{
  "mode": "childCare",
  "careNiche": "bilingual",
  "state": "mi",
  "city": "detroit",
  "maxItems": 10
}
```

#### Example: senior/companion caregivers in Austin, TX (up to 100)

```json
{
  "mode": "companionCare",
  "state": "tx",
  "city": "austin",
  "maxItems": 100
}
```

#### Example: pet sitters in Miami, FL

```json
{
  "mode": "petSitting",
  "state": "fl",
  "city": "miami",
  "maxItems": 50
}
```

#### Example: babysitting job postings in Detroit, MI

```json
{
  "mode": "babysittingJobs",
  "state": "mi",
  "city": "detroit",
  "maxItems": 20
}
```

#### Example: housekeeping job postings in Chicago, IL

```json
{
  "mode": "housekeepingJobs",
  "state": "il",
  "city": "chicago",
  "maxItems": 20
}
```

#### Example: Advanced Search — Spanish-speaking, 6-10 years experience nannies near ZIP 48228

```json
{
  "mode": "advancedSearch",
  "searchCategory": "nannies",
  "zipCode": "48228",
  "searchDistance": "25",
  "languageFacet": "spanish",
  "yearsExperienceFacet": "6-10",
  "maxItems": 50
}
```

#### Example: discover every companion-care city in Texas

```json
{
  "mode": "discoverCities",
  "discoverCategory": "companionCare",
  "state": "tx",
  "maxItems": 200
}
```

### Use cases

- **Local market research** — compare babysitting/nanny rates across cities and states
- **Childcare marketplaces & directories** — enrich local listings with real caregiver counts and average rates
- **Competitive intelligence** — track caregiver supply and pricing trends for a childcare or senior-care business
- **Parenting content & local guides** — source real caregiver availability data for city-specific articles
- **Senior care & pet care planning services** — pull companion care and pet sitting availability by area

### Limitations

#### Individual profile pages are intentionally not scraped

Sittercity's `robots.txt` disallows crawling `/babysitter/{id}` individual profile pages:

```
Disallow: /babysitter/
```

This actor honors that as a hard policy boundary and only scrapes **listing-level** pages (city/state search results), which `robots.txt` does not restrict. The `profileUrl` field on each caregiver record is copied verbatim from the link shown on the listing page for reference only — it is **never fetched** by this actor, regardless of whether the specific URL path it points to (`/providers/{uuid}` or `/provider/profile/{type}/{uuid}`) is technically reachable. If you need full profile detail pages, you must visit them yourself, in your browser, respecting Sittercity's terms of service.

#### Hourly rate and recent-review fields only appear on 3 of the 6 categories

Sittercity serves caregiver listings via two different page layouts:

- **Babysitters, Nannies, Child Care** — a "top result" landing page that shows hourly rate, star rating, review count, and a recent review snippet, but is capped at roughly the top 10 caregivers per city with no further pagination.
- **Companion Care, Pet Sitting, Special Needs** — a paginated search-results page that supports fetching the full caregiver count for the area, but does not display hourly rate or a recent-review snippet on the listing page (Pet Sitting does show a star rating).

This is a genuine difference in what Sittercity's own pages expose, not a scraping limitation — fields that aren't shown on a given category's listing page are simply omitted from the output rather than being filled with placeholder values.

#### City must match Sittercity's own listing pages

`city` must be a slug Sittercity has an actual listing page for (lowercase, hyphenated, e.g. `new-york`, `los-angeles`). An unrecognized city/state combination returns 0 records with a clear status message rather than an error. Use `mode: "discoverCities"` to get a list of valid city slugs straight from Sittercity's own sitemap instead of guessing.

#### Search-facet filters are now exposed via `mode: "advancedSearch"` — with 4 known incompatible combos

An earlier version of this actor investigated Sittercity's filter form (distance radius, hourly-rate band, background-check type, years of experience, language spoken, "must have a car") and initially left it out after finding some facet/category combinations returned an unrendered 0-card page. A later pass (2026-07-26) mapped this precisely: of 30 (facet × category) combinations tested live, 26 work correctly and only 4 are genuinely broken upstream — `rateFacet` + Babysitters, `languageFacet` + Pet Sitting, and `requiresTransportation` + Companion Care or Pet Sitting. These 4 consistently 200 OK with 0 cards even though the same filter works for every other category and the unfiltered category has thousands of real matches, confirmed non-transient across 2 different ZIP codes.

Rather than leaving out the whole feature (as the earlier version did) or silently shipping those 4 combos as a false "0 results", this actor now exposes the full filter set via `mode: "advancedSearch"` and automatically drops just the incompatible filter for its known-broken category — you still get real, correctly-filtered results for every filter you asked for that IS supported, and a note in the run's status message + logs when one was dropped. See the Advanced Search section above.

**Stacking 3+ filters at once can occasionally hit the same unrendered-shell response**, separately from the 4 known-broken combos above. Verified live (round-8 QA, 2026-07-26): `backgroundCheckFacet` + `yearsExperienceFacet` + `languageFacet` combined all three at once for Babysitters returns the same unrendered 0-card page Sittercity serves for a genuinely broken combo — even though every pair of those three filters works correctly on its own, and swapping in different filter values reproduces the same failure. This is a narrow upstream filter-combination limit, not scrapeable-page-count or account-side, and it isn't practical to enumerate every broken 3-or-more-way combination the way the 4 known 2-way combos are. If a request with 3+ filters returns 0 results, the actor's status message already suggests the correct fix — try removing one filter (start with `languageFacet`, the common factor in the one confirmed-broken 3-way combo) or widening `searchDistance`.

#### Babysitters / Nannies / Child Care top-10 lists can vary between runs

The "top result" landing pages (Babysitters, Nannies, Child Care, and the `careNiche` specialty variants) are Sittercity's own SEO/marketing pages, not a stable paginated feed — the specific caregivers shown in the top-10 can rotate between separate runs for the same category/state/city (verified 2026-07-25: two consecutive runs of the same input returned different, overlapping-but-not-identical caregiver sets). This reflects Sittercity's own listing logic and is not a scraping defect. Companion Care / Pet Sitting / Special Needs (the paginated search-results pages) do not exhibit this — the same input reliably returns the same caregivers.

The same rotation applies to `mode: "advancedSearch"` when `sortBy` is left at its default `relevance` — verified live 2026-07-26 (two consecutive identical-input runs against the same ZIP returned only 5/20 identical providers). This is Sittercity's own "relevance" ranking rotating/promoting listings, not a scraping defect. Set `sortBy` to `distance`, `rate`, or `experience` for fully deterministic, repeatable ordering — verified live to return byte-identical provider order across repeated runs.

#### Duration/age-specific sub-category pages (weekend, hourly, overnight, toddler, etc.) are not exposed — but the real child-care specialty niches ARE

Sittercity also publishes URLs like `/child-care/weekend-babysitters/{state}/{city}` and 27 similar duration/age-specific variants. These were investigated and found to be marketing landing pages, not real caregiver listings — live testing across 9 sample slugs/cities found 0 caregiver cards on 7 of them and only 1–2 on the other 2, versus 10–15+ on the corresponding base category page. They were left out to avoid shipping a mode that would return empty or near-empty results most of the time.

Separately, a genuinely different family of 9 (`childCare`) + 6 (`nannies`) specialty-niche pages — the ones actually cross-linked from Sittercity's own babysitters/nannies landing pages ("School help" section) — were verified to return real, distinct top-N caregiver sets (not a duplicate of the base page, not empty) and are exposed via the `careNiche` input. See "Output per caregiver" above for the field and the Input table for the full option list.

#### Job postings: single page only, and `childCare` jobs are the same as `babysitting` jobs

Sittercity's `robots.txt` disallows crawling `?page=`-style query-string variants of job-listing paths (e.g. `Disallow: /babysitting-jobs/*?*`), so this actor only ever fetches the first page of a job-listing category (typically 1–15 real postings, varying by city and category — this is the actual number of open jobs, not a truncation). Separately, `/child-care-jobs/{state}/{city}` was verified to return byte-identical postings to `/babysitting-jobs/{state}/{city}` (Sittercity files both under the same underlying job type), so `childCareJobs` is intentionally not offered as a separate mode — use `babysittingJobs` for that content. `housekeepingJobs` is included even though there's no matching `housekeeping` caregiver-listing category, because Sittercity does publish a distinct, real housekeeping job-postings page.

The `description` field is the job card's own preview text and may end with `...` if Sittercity itself truncates it on the listing page — this actor does not fetch a separate job-detail page to get the full text.

### FAQ

**Is this affiliated with Sittercity?**
No. This is an independent, third-party actor that scrapes Sittercity's own publicly accessible listing pages. It is not affiliated with, endorsed by, or sponsored by Sittercity Incorporated.

**Do I need a Sittercity account, cookies, or a proxy?**
No. All listing pages scraped by this actor are publicly accessible without logging in, and no proxy is required.

**Why is `hourlyRateMin`/`hourlyRateMax` missing for Companion Care / Pet Sitting / Special Needs records?**
Sittercity's own listing pages for those 3 categories don't display an hourly rate on the search-results card — only on Babysitters / Nannies / Child Care. See Limitations above.

**Why do some caregivers have no `badges`, `rating`, or `bio`?**
Not every caregiver has completed every optional profile section (background check, first aid/CPR certification, or received reviews yet). Fields that Sittercity itself doesn't show for a given caregiver are omitted rather than filled with a placeholder.

**How fresh is the data?**
Every run scrapes Sittercity's live listing pages at request time — there is no caching layer in this actor.

**Can I get every caregiver in a city, not just the first page?**
For Companion Care, Pet Sitting, and Special Needs, the normal `mode` paginates through the source's own city listing results pages up to `maxItems`. Babysitters, Nannies, and Child Care are capped at Sittercity's own fixed ~10-result landing page for that category when using their normal `mode` (no additional pages exist on that curated landing-page template). For a much larger, truly paginated result set across **all 6 categories** (typically thousands of caregivers per metro area), use `mode: "advancedSearch"` with a `zipCode` instead — it hits Sittercity's real full-database search endpoint. Note that Sittercity's own advertised total counts (`totalProvidersInArea` in the bonus `areaSummary` record, or the "Showing N" count behind `advancedSearch`) are frequently larger than the number of genuinely distinct caregivers actually reachable through pagination — past a certain page, the source starts repeating already-seen caregivers rather than surfacing new ones. This actor de-duplicates caregivers within a run (by provider ID) and stops early once it detects the real unique pool is exhausted, so you'll never receive duplicate records, but you may receive fewer unique records than the advertised total or `maxItems` suggests for smaller/less-dense areas.

**How do I find valid city slugs without guessing?**
Run the actor with `mode: "discoverCities"`. It reads Sittercity's own public sitemap (declared in their `robots.txt` via a `Sitemap:` directive — the standard, crawler-permitted way to advertise a site's URL list) and returns every city/state combination that has a live listing page for the category you pick, including a ready-to-use `listingUrl` for each.

**What does the `careType` field mean?**
It's Sittercity's own internal classification for the caregiver, as encoded in the profile link on the listing page (e.g. `babysitter`, `nanny`, `companion_care`, `pet_care`). Note that Child Care and Special Needs categories are internally filed under Sittercity's `babysitter` careType — this is how Sittercity itself organizes the data, not an artifact of this actor.

# Actor input Schema

## `mode` (type: `string`):

Which Sittercity caregiver listing category to scrape. Pick "Discover Cities" to enumerate valid city/state combinations from Sittercity's public sitemap instead of scraping caregivers.

## `discoverCategory` (type: `string`):

Only used when `mode` is "Discover Cities". Which category's valid city/state listing pages to enumerate from Sittercity's sitemap — either a caregiver-listing category or a job-postings category (both have real, distinct sitemap-listed city pages).

## `searchCategory` (type: `string`):

Only used when `mode` is "Advanced Search". Which caregiver category to search for. Advanced Search hits Sittercity's real full-database search endpoint (ZIP + radius based) rather than a curated top-N city landing page, so it returns the true full result count with real pagination and real server-side filters.

## `zipCode` (type: `string`):

5-digit US ZIP code to search near. Only used (and required) when `mode` is "Advanced Search", e.g. "48228".

## `searchDistance` (type: `string`):

Only used when `mode` is "Advanced Search". Maximum distance from `zipCode` to search.

## `rateFacet` (type: `string`):

Only used when `mode` is "Advanced Search". Filter caregivers by their listed hourly rate range. Not reliably supported upstream for the Babysitters category — silently ignored (with a status-message note) if combined with `searchCategory: "babysitters"`.

## `backgroundCheckFacet` (type: `string`):

Only used when `mode` is "Advanced Search". Filter to caregivers with a completed background check of this level.

## `yearsExperienceFacet` (type: `string`):

Only used when `mode` is "Advanced Search". Filter caregivers by years of paid experience.

## `lastLoginFacet` (type: `string`):

Only used when `mode` is "Advanced Search". Filter to caregivers who last logged in within this window.

## `languageFacet` (type: `string`):

Only used when `mode` is "Advanced Search". Filter to caregivers who speak this language. Not reliably supported upstream for the Pet Care category — silently ignored (with a status-message note) if combined with `searchCategory: "petSitting"`.

## `petTypeFacet` (type: `string`):

Only used when `mode` is "Advanced Search" and `searchCategory` is "Pet Care Providers". Filter to caregivers experienced with this type of pet. Ignored (with a status-message note) for any other `searchCategory`.

## `seniorAgeFacet` (type: `string`):

Only used when `mode` is "Advanced Search" and `searchCategory` is "Companion Care / Senior Care". Filter to caregivers experienced with seniors in this age range. Ignored (with a status-message note) for any other `searchCategory`.

## `specialNeedsAgeFacet` (type: `string`):

Only used when `mode` is "Advanced Search" and `searchCategory` is "Special Needs Caregivers". Filter to caregivers experienced with this age group. Ignored (with a status-message note) for any other `searchCategory`.

## `requiresTransportation` (type: `boolean`):

Only used when `mode` is "Advanced Search". If true, only returns caregivers who indicated they have access to transportation. Not reliably supported upstream for the Companion Care / Senior Care and Pet Care categories — silently ignored (with a status-message note) if combined with those `searchCategory` values.

## `sortBy` (type: `string`):

Only used when `mode` is "Advanced Search". Result ordering for the real search-database results. All 4 options verified live across every `searchCategory`.

## `searchKeyword` (type: `string`):

Only used when `mode` is "Advanced Search". Free-text keyword to search caregiver bios for, e.g. "CPR" or "newborn".

## `state` (type: `string`):

US state to search in. When `mode` is "Discover Cities", this optionally filters the discovered cities to one state — leave blank to discover cities nationwide.

## `careNiche` (type: `string`):

Optional specialty filter for a real, distinct set of caregivers. Only applies when `mode` is "Child Care Providers" (all 9 options) or "Nannies" (Before-School through eLearning only) — every other mode, or a specialty not offered for the chosen mode, is ignored and the normal unfiltered listing is scraped instead.

## `city` (type: `string`):

City name, lowercase with hyphens instead of spaces (e.g. "detroit", "new-york", "los-angeles"). Must be a city Sittercity has a listing page for (Job Postings modes use the same city/state as the matching caregiver category). Not used when `mode` is "Discover Cities" — use that mode to find valid city slugs instead of guessing.

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

Maximum number of records to return. Babysitters / Nannies / Child Care pages show a fixed top-10 list per city (no further pagination exists on that curated landing-page template), so those 3 categories cap at 10 regardless of this value when using their normal `mode`. Companion Care / Pet Sitting / Special Needs support full pagination up to this limit. Job Postings modes show a single page of real postings per city (typically 1-15, varies by city and category — robots.txt disallows further job-listing pagination) so those 6 categories cap at whatever is actually posted. "Advanced Search" mode searches the real full database (ZIP + radius) with real pagination for all 6 caregiver categories, up to this limit. In "Discover Cities" mode this caps the number of city/state combinations returned.

## Actor input object example

```json
{
  "mode": "babysitters",
  "discoverCategory": "babysitters",
  "searchCategory": "babysitters",
  "zipCode": "48228",
  "searchDistance": "25",
  "rateFacet": "",
  "backgroundCheckFacet": "",
  "yearsExperienceFacet": "",
  "lastLoginFacet": "",
  "languageFacet": "",
  "petTypeFacet": "",
  "seniorAgeFacet": "",
  "specialNeedsAgeFacet": "",
  "requiresTransportation": false,
  "sortBy": "relevance",
  "searchKeyword": "",
  "state": "mi",
  "careNiche": "",
  "city": "detroit",
  "maxItems": 20
}
```

# Actor output Schema

## `caregivers` (type: `string`):

Dataset containing all scraped Sittercity caregiver listing records.

# 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 = {
    "mode": "babysitters",
    "discoverCategory": "babysitters",
    "searchCategory": "babysitters",
    "zipCode": "48228",
    "searchDistance": "25",
    "rateFacet": "",
    "backgroundCheckFacet": "",
    "yearsExperienceFacet": "",
    "lastLoginFacet": "",
    "languageFacet": "",
    "petTypeFacet": "",
    "seniorAgeFacet": "",
    "specialNeedsAgeFacet": "",
    "requiresTransportation": false,
    "sortBy": "relevance",
    "searchKeyword": "",
    "state": "mi",
    "careNiche": "",
    "city": "detroit",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/sittercity-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 = {
    "mode": "babysitters",
    "discoverCategory": "babysitters",
    "searchCategory": "babysitters",
    "zipCode": "48228",
    "searchDistance": "25",
    "rateFacet": "",
    "backgroundCheckFacet": "",
    "yearsExperienceFacet": "",
    "lastLoginFacet": "",
    "languageFacet": "",
    "petTypeFacet": "",
    "seniorAgeFacet": "",
    "specialNeedsAgeFacet": "",
    "requiresTransportation": False,
    "sortBy": "relevance",
    "searchKeyword": "",
    "state": "mi",
    "careNiche": "",
    "city": "detroit",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/sittercity-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 '{
  "mode": "babysitters",
  "discoverCategory": "babysitters",
  "searchCategory": "babysitters",
  "zipCode": "48228",
  "searchDistance": "25",
  "rateFacet": "",
  "backgroundCheckFacet": "",
  "yearsExperienceFacet": "",
  "lastLoginFacet": "",
  "languageFacet": "",
  "petTypeFacet": "",
  "seniorAgeFacet": "",
  "specialNeedsAgeFacet": "",
  "requiresTransportation": false,
  "sortBy": "relevance",
  "searchKeyword": "",
  "state": "mi",
  "careNiche": "",
  "city": "detroit",
  "maxItems": 20
}' |
apify call crawlerbros/sittercity-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/0ZlrmpTMLZJnPuUK9/builds/e05GaalFjXi66EVnu/openapi.json