# Caring.com Scraper \[$5/1K💰] | Senior Living | Pricing (`ahmed_jasarevic/caring-scraper`) Actor

Extract senior living facilities from Caring.com: assisted living, memory care and independent living with address, care types, rating, starting price, phone and optional reviews and amenities.

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

## Pricing

from $1.90 / 1,000 facility listings

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

## Caring.com Scraper – Senior Living Facilities, Pricing & Reviews

Extract **senior living and senior care facilities from Caring.com**: facility name, operator, address, care types (assisted living, memory care, independent living), overall rating, review count, starting monthly price and phone — plus optional reviews, amenities, per-room pricing, capacity and licence data. **$5 per 1,000 facilities, no browser rendering.**

### What Can You Do With Caring.com Data?

- **Senior living market research** – count and compare assisted living, memory care and independent living facilities by city
- **Pricing benchmarks** – collect starting monthly prices and per-room pricing for a metro or a state
- **Senior housing investment and site selection** – map supply, operators and capacity in a target market
- **Care referral and placement lead lists** – one row per facility with address, phone and care types
- **Review and quality analysis** – pull ratings and review text for a sentiment or quality study
- **Family comparison tools** – build a shortlist dataset of facilities with prices, care types and amenities

### How It Works

![How the Caring.com Scraper works: from a city listing URL to structured senior care facility records.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-caring-scraper.webp)

Caring.com's listing pages are rendered from an internal JSON search API. The actor calls that API directly for each city listing URL, so a page of results arrives as JSON rather than HTML — no browser, no rendering, no DOM parsing. By default it requests 50 facilities per listing page and stops at `maxItems`.

With `includeDetails` on, each facility's own page is fetched for reviews, amenities, per-room pricing, capacity, licence and website. That is one extra request and one extra billed event per facility, so it is off by default: listing data alone gives you name, address, care types, rating, price and phone.

### Extract Senior Living Data Without A Senior Care Data API

There is no free, self-serve API for US senior living facilities. Caring.com aggregates the supply — facility profiles, care types, prices and reviews — but only for humans browsing the site. Commercial senior-housing databases are sold as market reports or enterprise licences.

This actor turns the listing surface into rows you can filter, join and schedule, at a per-facility price instead of an enterprise contract.

### Assisted Living, Memory Care And Independent Living In One Dataset

`startUrls` accepts city listing pages such as `https://www.caring.com/senior-living/assisted-living/new-york/new-york`, and individual facility pages. The care type is encoded in the listing URL path, so running the same city for `assisted-living`, `memory-care` and `independent-living` gives you three comparable slices with the same schema.

If you pass facility pages directly, the actor scrapes just those facilities — useful for refreshing a known shortlist rather than re-crawling a city.

### Senior Living Pricing, Ratings And Review Counts

`startingPrice` is the facility's advertised starting monthly price in USD, taken from the listing. It is a starting figure, not a quote: room type, care level and add-ons change the final number, which is why `includeDetails` adds per-room pricing where the source publishes it.

`overallRating` is Caring.com's aggregate rating and `numReviews` the number of reviews behind it. Both are the source's editorial signals, not a government inspection score.

### Input – Configure A Facility Extract

| Field | Type | Required | Default | Notes |
|---|---|---|---|---|
| `startUrls` | array | No | New York assisted living city page | Caring.com city listing pages or individual facility pages |
| `maxItems` | integer | No | `100` | Max facilities saved; `0` = unlimited |
| `includeDetails` | boolean | No | `false` | Fetch each facility page for reviews, amenities, per-room pricing, capacity, licence, website |
| `maxRequestsPerCrawl` | integer | No | `500` | HTTP request cap (about one listing request per 50 facilities plus one detail request each) |
| `maxConcurrency` | integer | No | `20` | Parallel API requests; lower it if you get rate-limited |
| `hitsPerPage` | integer | No | `50` | Facilities requested per listing page |
| `proxy` | object | No | — | Optional; the internal API usually works from datacenter IPs |

### Output – Senior Living Facility Fields

Overview (always present):

| Field | Type | Description |
|---|---|---|
| `facilityName` | string | Facility name |
| `address` | string | Street address, city, state and ZIP as published |
| `careTypes` | array | Care types offered (Assisted Living, Memory Care, Independent Living, …) |
| `overallRating` | number | Caring.com aggregate rating |
| `startingPrice` | number | Advertised starting monthly price (USD) |
| `phone` | string | Facility phone number |
| `sourceUrl` | string | Canonical Caring.com profile URL |

Added by `includeDetails`: `numReviews` and review rows, amenities, per-room pricing, capacity, licence information, website, coordinates and photo references.

### Example Input – Memory Care In Two Cities

```json
{
  "startUrls": [
    { "url": "https://www.caring.com/senior-living/memory-care/new-york/new-york" },
    { "url": "https://www.caring.com/senior-living/memory-care/new-jersey/jersey-city" }
  ],
  "maxItems": 200,
  "includeDetails": true,
  "hitsPerPage": 50
}
```

### Example Output – One Facility Record

```json
{
  "facilityName": "Sunrise of Manhattan",
  "address": "150 Amsterdam Ave, New York, NY 10023",
  "careTypes": ["Assisted Living", "Memory Care"],
  "overallRating": 4.8,
  "numReviews": 86,
  "startingPrice": 8500,
  "phone": "(212) 555-0192",
  "sourceUrl": "https://www.caring.com/senior-living/new-york/new-york/sunrise-of-manhattan"
}
```

### Export Senior Care Data To JSON, CSV Or Excel And Schedule Runs

Results land in the default dataset and can be downloaded as JSON, CSV, Excel or XML, or read through the Apify API. A city with 200 facilities completes in well under a minute at the default concurrency.

Prices and reviews drift, so a **monthly schedule** is a good cadence for pricing intelligence; a **quarterly run** is enough for supply mapping. At $0.005 per facility, 1,000 facilities cost $5; details add a separate charge per facility.

### Related Actors

- [Docplanner Scraper](https://apify.com/ahmed_jasarevic/docplanner-scraper) – healthcare provider and clinic directory data with the same facility-per-row shape
- [Google Maps Scraper](https://apify.com/apify/google-maps-scraper) – enrich facilities with geocoded coordinates, nearby amenities and additional reviews
- [Website Content Crawler](https://apify.com/apify/website-content-crawler) – pull facility websites, inspection reports and licensing pages into clean text
- [Google Search Scraper](https://apify.com/apify/google-search-scraper) – find senior living market reports, openings and licensing news per metro

### FAQ

#### Why use this actor instead of the Caring.com website?

Because there is no export and no API. Comparing 200 facilities by hand means opening 200 pages. This actor returns them as a sortable table with price, rating, care types and contact details in one run.

#### Is there a Caring.com API?

Not a public one. The site's own frontend calls an internal JSON search API; this actor uses that same endpoint, which is why it does not need a browser and why datacenter IPs usually work.

#### How current are the prices?

`startingPrice` is read live at run time from the listing. Caring.com prices are advertised starting rates, so they move with promotions and room availability — treat them as a market band, not a quote.

#### What is the difference between listing data and details?

Listing data is what a city results page carries: name, address, care types, rating, starting price, phone. Details add a request per facility for reviews, amenities, per-room pricing, capacity and licence. Details are off by default because they roughly double both runtime and cost.

#### What are alternatives for senior living data?

The CMS **Provider Data Catalog** and state licensing databases are free and authoritative for licensed facilities and inspection results, but they carry no reviews and no advertised pricing. Commercial senior-housing databases sell curated supply and occupancy data. Caring.com is the consumer-facing view: prices, ratings and reviews.

#### Can I get every facility in the US in one run?

Not practically. Coverage follows the city listing URLs you supply; there is no single national listing page. Queue one URL per metro and the runs are additive.

#### Do I need a proxy?

Usually not. The internal API tolerates datacenter IPs. If your platform IP gets blocked, enable a residential proxy group and lower `maxConcurrency`.

### SEO Keywords

caring.com scraper, senior living data, assisted living database, memory care facilities list, senior care market data, assisted living pricing data, senior housing research, senior living api, caring.com alternative, senior care lead generation, elder care directory data, senior living reviews data, retirement community database, senior housing investment data, assisted living facilities by city, memory care pricing, senior living market research, skilled nursing data

### For AI Agents & LLM Apps

Returns one row per senior living facility scraped from Caring.com city listings or facility pages: name, address, care types, rating, starting monthly price and phone; `includeDetails` adds reviews, amenities, per-room pricing and licence data.

Minimal working input:

```json
{ "maxItems": 25 }
```

Variant — details on for a specific metro and care type:

```json
{ "startUrls": [{ "url": "https://www.caring.com/senior-living/assisted-living/new-york/new-york" }], "maxItems": 50, "includeDetails": true }
```

Output fields: `facilityName, address, careTypes, overallRating, startingPrice, phone, sourceUrl` — plus `numReviews`, amenities, per-room pricing, capacity, licence and website when `includeDetails` is on.

Behaviors an agent should know:

- **`startUrls` empty scrapes a default New York assisted-living city page** — never assume an empty input means "all facilities".
- `maxItems` defaults to **100**, not unlimited; `0` means no limit.
- `includeDetails` adds **one extra billed event per facility** (`facility-detail`) and roughly doubles requests.
- `hitsPerPage` (default 50) changes how many facilities one listing request returns; lowering it multiplies requests, not coverage.
- `maxRequestsPerCrawl` (default 500) is a hard stop — a details-heavy run can hit it before `maxItems`.
- `careTypes` is an array, not a string; `startingPrice` is a starting monthly rate in USD, not a quote.
- The care type comes from the listing URL path, so the same city under `assisted-living` and `memory-care` returns different sets.

Billing: **$0.005 per facility** saved, plus a small actor-start event.

### Legal & Compliance Disclaimer

This actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Caring.com or its parent company.

It accesses publicly visible senior living listing pages through the site's own internal JSON search endpoint — no login, no paywall bypass, no CAPTCHA solving. Output may include facility phone numbers and addresses; those are business contact details published for enquiries, not private individual data.

Users are responsible for complying with Caring.com's Terms of Service and with applicable law. If you use the phone numbers for outreach, note that unsolicited marketing calls and texts to businesses and individuals are regulated in the US (TCPA, CAN-SPAM) and in the EU (GDPR, ePrivacy). Advertised prices are the facility's own published starting rates and should not be presented as quotes. This section is a factual disclosure, not legal advice.

# Actor input Schema

## `startUrls` (type: `array`):

Caring.com city listing pages (for example https://www.caring.com/senior-living/assisted-living/new-york/new-york) or individual facility pages. The scraper uses Caring.com's internal JSON API for these pages, so datacenter IPs are not blocked by the HTML WAF.

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

Maximum number of facilities to scrape (0 = unlimited). Each saved facility counts toward pay-per-event charges.

## `includeDetails` (type: `boolean`):

Fetch each facility page for reviews, amenities, per-room pricing, capacity, license, and website. When off, the Actor saves listing data only and makes fewer requests. With pay-per-event pricing, details add a separate detail charge per facility.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of HTTP requests the Actor may make. Each 50 facilities needs roughly one listing request plus one details request per facility.

## `maxConcurrency` (type: `integer`):

Number of API requests to run in parallel. Lower this if Caring.com starts rate-limiting.

## `hitsPerPage` (type: `integer`):

Number of facilities requested from the internal search API per page. Larger pages need fewer listing requests.

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

Optional proxy. The internal API usually works without a proxy, but enable a residential group if your platform IP is blocked.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.caring.com/senior-living/assisted-living/new-york/new-york"
    }
  ],
  "maxItems": 100,
  "includeDetails": false,
  "maxRequestsPerCrawl": 500,
  "maxConcurrency": 20,
  "hitsPerPage": 50,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.caring.com/senior-living/assisted-living/new-york/new-york"
        }
    ],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/caring-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 = {
    "startUrls": [{ "url": "https://www.caring.com/senior-living/assisted-living/new-york/new-york" }],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/caring-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 '{
  "startUrls": [
    {
      "url": "https://www.caring.com/senior-living/assisted-living/new-york/new-york"
    }
  ],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/caring-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/caring-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/ayXVbQTyP9vmFkIic/builds/xDTXZgBjf19OdHl5j/openapi.json