# Nextdoor Neighborhood Scraper: City Demographics & Directory (`memo23/nextdoor-neighborhood-scraper`) Actor

Nextdoor city data with no login: residents, average age and income, homeowner share, affordability and friendliness scores, neighbor interests and FAQs for any US city, plus its directory of neighborhoods, local businesses and groups. $7.50 per 1,000 area profiles, $1 per 1,000 entries.

- **URL**: https://apify.com/memo23/nextdoor-neighborhood-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 area profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Nextdoor Neighborhood Scraper: City Demographics & Directory

Get the **Nextdoor area profile of any US city** for **$7.50 per 1,000 cities**: residents, average age, average income, homeowner share, Nextdoor's affordability and friendliness scores, how many neighborhoods and local groups the city has, what neighbors like doing there and why they love it, plus Nextdoor's FAQ answers and coordinates. Each city also comes with its **directory of neighborhoods, local businesses and groups** at $1 per 1,000 entries. No login, no cookies, no Nextdoor account.

![How the Nextdoor Neighborhood Scraper works](https://api.apify.com/v2/key-value-stores/3PHygRnzzTLG6r6PA/records/how-it-works-nextdoor.png)

```json
{
  "cities": ["San Francisco, CA", "Austin, TX"]
}
```

| Input | Rows |
|---|---|
| City link or "City, ST" | One area profile: residents, age, income, homeowners, scores, counts, interests, FAQ |
| Same city, with the directory on (default) | Up to 50 directory entries: neighborhoods, then businesses, then local groups with member counts |
| Neighborhood link | One area profile with the neighborhood's name, short description and picture |
| `followNeighborhoods` | A neighborhood profile for each neighborhood in the city's directory (capped per city) |

### Why Use This Scraper?

- **Local demographics in one row.** Residents, average age and income, homeowner share and two Nextdoor scores, as numbers ready for a spreadsheet.
- **What neighbors care about.** The top interests (walking, dogs, home improvement...) and the reasons neighbors give for loving the place, split into lists.
- **Type a city, not a URL.** "Austin, TX" or "Saint Louis, Missouri" works; a city Nextdoor does not have is reported and not charged.
- **Priced per city, not per run.** $0.0075 per area profile; other Nextdoor city actors charge $0.008 to $0.09 per row.

### Use Cases

- **Real estate:** compare income, homeowner share and affordability across the cities you invest or sell in.
- **Local marketing:** pick cities by age, income and interests before a campaign; find the local groups with the most members.
- **Market research:** build a table of US cities with Nextdoor's resident counts and neighborhood counts.
- **Franchise and site selection:** shortlist towns by income, affordability and how friendly neighbors rate them.
- **Neighborhood lists:** get the neighborhood names Nextdoor uses in a city, with their links.

### How It Works

1. Cities written as "City, ST" are turned into their Nextdoor city links; links are read as given.
2. Every city and neighborhood page is profiled first, four at a time (about 40 seconds each), so a small budget always gets the main rows.
3. Then each city's directory is read: up to 50 entries.
4. With `followNeighborhoods` on, the neighborhoods from those directories are profiled last.
5. Every row is charged as it is delivered, and the run stops cleanly at your spending limit.

### Input Configuration

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Nextdoor city links (`https://nextdoor.com/city/<city>--<st>/`) or neighborhood links (`https://nextdoor.com/neighborhood/...`). |
| `cities` | array | US cities as "City, ST" or "City, State". |
| `includeDirectory` | boolean | Also return each city's directory entries. Default on. |
| `maxDirectoryEntries` | integer | 10 to 50 entries per city. Default 50. |
| `followNeighborhoods` | boolean | Profile the neighborhoods listed in each directory. Default off. |
| `maxNeighborhoodsPerCity` | integer | Cap on neighborhood profiles per city. Default 10. |
| `maxItems` | integer | Cap on all rows. Default 1,000; free-plan runs return up to 100. |

#### Example input

Profiles only, for a list of cities:

```json
{
  "cities": ["Boise, ID", "Raleigh, NC", "Tampa, FL", "Sausalito, CA"],
  "includeDirectory": false
}
```

A city with its directory and its first ten neighborhoods profiled:

```json
{
  "startUrls": ["https://nextdoor.com/city/sausalito--ca/"],
  "followNeighborhoods": true,
  "maxNeighborhoodsPerCity": 10
}
```

### Output Samples

A city (from a run on 2026-10-26; `faqs` shortened):

```json
{
  "type": "area-profile",
  "areaType": "city",
  "name": "Austin",
  "city": "Austin",
  "state": "Texas",
  "stateCode": "TX",
  "countryCode": "US",
  "latitude": 30.306861051474662,
  "longitude": -97.75547714199763,
  "residents": 958202,
  "averageAge": 34,
  "averageIncomeUsd": 87000,
  "homeownerPct": 44,
  "affordabilityScore": 60,
  "lessAffordableThanPctOfStatePlaces": 61,
  "friendlinessScore": 86,
  "neighborhoodCount": 858,
  "localGroupCount": 1919,
  "businessDirectoryCount": 54,
  "classifiedsCount": 432460,
  "photoVideoPostCount": 7358,
  "topInterests": ["dogs", "home improvement & diy", "walking", "gardening & landscape", "hiking & trails", "cooking", "books", "seeing live music", "travel", "volunteering"],
  "lovedFor": ["community", "dog friendly", "family friendly", "friendly", "neighbors", "peaceful", "quiet", "trees", "walkability", "walking"],
  "description": "Austin, Texas is a vibrant city known for its live music scene and tech industry. Nextdoor Neighbors appreciate its walkability and family-friendly atmosphere. It's a dog-friendly city with plenty of trees and peaceful neighborhoods.",
  "faqs": [{ "question": "Is Austin expensive?", "answer": "Austin is less affordable than 61% of cities and towns in TX." }],
  "url": "https://nextdoor.com/city/austin--tx/"
}
```

A directory entry:

```json
{
  "type": "directory-entry",
  "kind": "local_group",
  "name": "Stop Crime SF",
  "area": "Sausalito",
  "memberCount": 3034,
  "description": "San Franciscans working to create a safe and sound city for all...",
  "url": "https://nextdoor.com/g/djja5u4dh/",
  "position": 49,
  "sourceUrl": "https://nextdoor.com/city/sausalito--ca/"
}
```

A neighborhood:

```json
{
  "type": "area-profile",
  "areaType": "neighborhood",
  "name": "Hurricane Gulch",
  "city": "Sausalito",
  "stateCode": "CA",
  "description": "Hurricane Gulch is a quaint neighborhood in Sausalito, CA, known for its steep hills and stunning bay views.",
  "url": "https://nextdoor.com/neighborhood/hurricanegulch--sausalito--ca/",
  "foundOn": "https://nextdoor.com/city/sausalito--ca/"
}
```

### Key Output Fields

| Field | Meaning |
|---|---|
| `type` | `area-profile` or `directory-entry` |
| `areaType` | `city` or `neighborhood` |
| `residents`, `averageAge`, `averageIncomeUsd`, `homeownerPct` | Demographics as Nextdoor shows them (income in dollars, homeowners in percent) |
| `affordabilityScore`, `friendlinessScore` | Nextdoor's own 0-100 scores |
| `lessAffordableThanPctOfStatePlaces` | "Less affordable than N% of cities and towns" in the same state |
| `topInterests`, `lovedFor` | What neighbors rate as their interests and why they love the place |
| `kind` | Directory entry kind: `neighborhood`, `business` or `local_group` |
| `memberCount` | Members of a local group |

### FAQ

**Do neighborhoods get demographics too?**
No. Nextdoor shows residents, income and scores on city pages only. A neighborhood page gives its name, a short description and a picture, which is why `followNeighborhoods` is off by default.

**How many directory entries does a city have?**
Up to 50, in the order Nextdoor lists them: neighborhoods first (alphabetical), then businesses, then local groups. A big city such as San Francisco (192 neighborhoods) returns its first 50 neighborhoods only; there is no second page. A small town like Sausalito returns all 16 neighborhoods plus 30 businesses and 3 groups.

**Can I scrape business pages, posts or reviews?**
No. Business pages, groups, category directories and posts are not supported: the data source answers them with wrong or empty data. Only city and neighborhood pages on nextdoor.com are read. Nextdoor UK, Canada and other countries are not supported.

**What if a city does not exist on Nextdoor?**
Nextdoor sends the link to its "Join your neighborhood" page. The actor spots this, logs it and does not charge. A neighborhood that does not exist redirects to its city and is handled the same way.

**Are the numbers exact?**
They are what Nextdoor shows on the page. Most match census figures; a few pages carry odd values (New York's city page shows 862 residents), so check outliers.

**Do I need a Nextdoor account?**
No.

### Pricing

| Event | When | Price |
|---|---|---|
| Actor start | Once per run (per GB of memory, 256 MB default) | $0.005 |
| Area profile | Each city or neighborhood profile | $0.0075 |
| Directory entry | Each neighborhood, business or group listed on a city page | $0.001 |

Example: 100 cities with their full directories cost 100 × $0.0075 + 5,000 × $0.001 + $0.005 = $5.755. Profiles alone for the same 100 cities cost $0.755.

### Support

Found a bug or need a field? Open an issue on the actor's Issues tab and include the run link.

### ⚠️ Disclaimer

This actor reads public Nextdoor city and neighborhood pages. It is not affiliated with or endorsed by Nextdoor. It collects no personal profiles and no posts. You are responsible for using the data in line with Nextdoor's terms and the laws that apply to you.

### SEO Keywords

Nextdoor scraper, Nextdoor city data, Nextdoor neighborhood scraper, Nextdoor demographics, neighborhood demographics API, city demographics data, average income by city, homeowner percentage by city, Nextdoor local groups, Nextdoor neighborhoods list, real estate market research, local marketing data

# Actor input Schema

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

City pages (https://nextdoor.com/city/<city>--<st>/) return the full area profile: residents, average age and income, homeowner share, affordability and friendliness scores, neighborhood and group counts, what neighbors like and Nextdoor's FAQ. Neighborhood pages (https://nextdoor.com/neighborhood/...) return only a name, a short description and a picture. Business, group and category pages are not supported.

## `cities` (type: `array`):

US cities written as "City, ST" or "City, State", for example "Austin, TX" or "Saint Louis, Missouri". Each becomes its Nextdoor city link. A city Nextdoor does not have is reported in the log and not charged.

## `includeDirectory` (type: `boolean`):

For each city, also return the entries Nextdoor lists on its city page: neighborhoods first, then local businesses, then local groups (with member counts). Up to 50 per city, alphabetical; a big city's 50 are all neighborhoods.

## `maxDirectoryEntries` (type: `integer`):

10 to 50. Nextdoor's city page lists no more than 50.

## `followNeighborhoods` (type: `boolean`):

Also profile the neighborhoods listed in each city's directory, billed as area profiles. Nextdoor shows only a name, a short description and a picture for a neighborhood (no demographics), so this is off by default. Turning it on also returns the directory rows.

## `maxNeighborhoodsPerCity` (type: `integer`):

Cap on neighborhood profiles taken from one city's directory.

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

Cap on all rows together. Free-plan runs return up to 100.

## Actor input object example

```json
{
  "startUrls": [
    "https://nextdoor.com/city/san-francisco--ca/"
  ],
  "includeDirectory": true,
  "maxDirectoryEntries": 50,
  "followNeighborhoods": false,
  "maxNeighborhoodsPerCity": 10,
  "maxItems": 1000
}
```

# Actor output Schema

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

Rows told apart by `type`: `area-profile` and `directory-entry`.

# 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": [
        "https://nextdoor.com/city/san-francisco--ca/"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/nextdoor-neighborhood-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": ["https://nextdoor.com/city/san-francisco--ca/"] }

# Run the Actor and wait for it to finish
run = client.actor("memo23/nextdoor-neighborhood-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": [
    "https://nextdoor.com/city/san-francisco--ca/"
  ]
}' |
apify call memo23/nextdoor-neighborhood-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/nextdoor-neighborhood-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/qCAb0fONDD7ou3SZM/builds/jIiiTUzkjmXft6cXK/openapi.json