# Nextdoor Business Scraper (`axiomworks/nextdoor-business-leads-scraper`) Actor

Scrape Nextdoor public business directories and pages to get local business leads, including names, phone numbers, emails, websites, addresses, categories, faves and opening hours. Search by category and city, or provide directory URLs, business page URLs or slugs; no Nextdoor login is required.

- **URL**: https://apify.com/axiomworks/nextdoor-business-leads-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Lead generation, Business
- **Stats:** 3 total users, 2 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.27 / 1,000 results

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

**Returns:** one row per Nextdoor business with `name`, `phone`, `email`, `website`, `fullAddress`, `primaryCategory`, `faveCount` and `pageUrl`.
**Input:** `{"category": "Handyman", "location": "San Francisco, CA", "maxItems": 50}`
**Best for:** local lead lists for agencies and home-services marketers, competitor mapping by city, enriching a CRM with Nextdoor contact details.

```json
{
    "name": "George Turner Construction",
    "phone": "+14152467309",
    "email": "george@georgeturnerconstruction.com",
    "website": "http://georgeturnerconstruction.com",
    "fullAddress": "Hawthorne Road, Bolinas, CA",
    "primaryCategory": "Carpenter",
    "searchRank": 4
}
```

### What does Nextdoor Business Scraper do?

Nextdoor Business Scraper is a Nextdoor scraper for local business leads. Give it a service category and a US city ("Plumber" in "Houston, TX"), and it reads Nextdoor's public business directory for that search, then opens every business page it finds and returns one clean record per business: name, phone number, contact email, website, address, categories, neighbor faves, followers, opening hours and, where Nextdoor has written one, its AI summary of what neighbors say. It works without a Nextdoor account and without logging in: it only reads the public directory and business pages that anyone can open in a browser.

You can also skip the search and give it Nextdoor URLs directly, either directory URLs such as `https://nextdoor.com/topics/handyman/san-francisco/ca/` or business page URLs such as `https://nextdoor.com/pages/sf-pro-handyman-san-francisco-ca/`, or simply a list of business slugs. Mixed inputs share one `maxItems` budget, so you always know the maximum number of rows a run can return.

Think of it as an unofficial Nextdoor API for business data. Typical jobs are building prospect lists of small local service businesses (handymen, plumbers, cleaners, roofers, landscapers), checking which competitors neighbors recommend in a given city, and filling in missing phone numbers and emails for businesses you already track.

### What data can you get from Nextdoor?

Every record has the same fields. A field is `null` when the business doesn't publish that detail on its public page (many sole traders list a phone but no website, for example).

| Field | Description | Example |
|---|---|---|
| `id` | Nextdoor's numeric business ID (string), unique within a run | `52876676` |
| `name` | Business name as shown on Nextdoor | `George Turner Construction` |
| `slug` | URL slug of the business page | `george-turner-construction-bolinas-ca` |
| `pageUrl` | Nextdoor's canonical page URL | `https://nextdoor.com/page/george-turner-construction-bolinas-ca` |
| `phone` | Phone number in E.164 format | `+14152467309` |
| `phoneFormatted` | Phone number as displayed | `(415) 246-7309` |
| `email` | Contact email listed on the page | `george@georgeturnerconstruction.com` |
| `website` | Business website | `http://georgeturnerconstruction.com` |
| `description` | The business's own description; about a third of businesses write one, the rest are `null` | `I'm a Bolinas resident, a carpenter by trade...` |
| `fullAddress` | Address line shown on the page (sometimes only city and state) | `Hawthorne Road, Bolinas, CA` |
| `street` | Street number and street name | `Hawthorne Road` |
| `city` | City | `Bolinas` |
| `state` | Two-letter state code | `CA` |
| `postalCode` | ZIP code | `94924` |
| `country` | Two-letter country code | `US` |
| `primaryCategory` | The category Nextdoor displays | `Carpenter` |
| `categories` | All categories the business is listed under | `["Carpenter", "Handyman", "General contractor"]` |
| `faveCount` | Neighbor "faves" (recommendations) | `0` |
| `followerCount` | Page followers | `0` |
| `openStatus` | Open or closed status at scrape time | `Closed until Tue 9:00 AM` |
| `openingHours` | One `{day, hours}` entry per day for the next week | `[{"day": "Tuesday", "hours": "9:00 AM–5:00 PM"}]` |
| `logoUrl` | Logo or profile photo URL | `https://us1-photo.nextdoor.com/business_logo/...png` |
| `aiSummary` | Nextdoor's AI summary of neighbor recommendations; only businesses with enough recommendations have one (roughly one in eight), the rest are `null` | `Local homeowners seeking a skilled carpenter...` |
| `searchCategory` | Directory category the row came from (null for business URLs) | `Handyman` |
| `searchLocation` | Directory location key (null for business URLs) | `san-francisco--ca` |
| `searchRank` | 1-based position in the directory results (null for business URLs) | `4` |
| `scrapedAt` | ISO 8601 UTC time of scraping | `2026-10-20T00:05:37.000Z` |
| `sourceUrl` | Business page the record was read from | `https://nextdoor.com/pages/george-turner-construction-bolinas-ca/` |

How often each field is filled depends on the businesses, not on the scraper. In a test run of "Plumber" in Houston, every row had a name, category, faves and follower count, about three quarters had a phone number and address, and a little over half had an email address.

### How to use Nextdoor Business Scraper

1. Open Nextdoor Business Scraper in Apify Console and go to the Input tab.
2. Type a category, for example `Handyman`, and a location in `City, ST` form, for example `San Francisco, CA`. Full state names (`Houston, Texas`) work as well.
3. Set `maxItems` to the number of businesses you want. Directory pages hold six businesses each, and the scraper keeps paging until it has enough or Nextdoor has no more.
4. Click Start. Each business page is opened at a polite pace (about one request per second), so 50 businesses take roughly a minute.
5. When the run finishes, open the Output tab and export the dataset as JSON, CSV, Excel, XML or HTML, or pull it through the API.

Nextdoor's directory widens outward from the city: a search for San Francisco also lists businesses from neighboring towns, and some results sit in nearby categories. The `searchRank` column keeps Nextdoor's order, so you can cut the list wherever relevance drops.

Categories in other languages work if Nextdoor has businesses for them: `Limpieza` in `Miami, FL` returns cleaning businesses. If you already know the businesses you need, put their URLs or slugs into `businesses`. Each one returns exactly one row.

The default proxy is Apify's datacenter proxy. Nextdoor limits how many business pages one IP address may open; when it refuses, the scraper retries on a fresh IP automatically. If a run still reports blocks, switch `proxyConfiguration` to residential proxies.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `category` | string | With `location` | Business category or service, e.g. `Handyman`, `Plumber`, `House cleaning`, `Limpieza`. |
| `location` | string | With `category` | US city and state, e.g. `San Francisco, CA`. |
| `startUrls` | array | No | Nextdoor directory URLs (`/topics/<category>/<city>/<state>/`) and/or business URLs (`/pages/<slug>/` or `/page/<slug>`). `us.nextdoor.com` URLs work too. |
| `businesses` | array of strings | No | Business page URLs or bare slugs such as `sf-pro-handyman-san-francisco-ca`. |
| `maxItems` | integer | No | Maximum number of businesses in total across all targets, 1-10000, default 50. |
| `proxyConfiguration` | object | No | Proxy settings. Default: Apify Proxy (datacenter). |

Give at least one of: `category` with `location`, `startUrls`, or `businesses`. Business pages and slugs are fetched first; directory searches then fill whatever is left of `maxItems`.

```json
{
    "category": "Plumber",
    "location": "Houston, TX",
    "startUrls": [
        { "url": "https://nextdoor.com/topics/limpieza/miami/fl/" }
    ],
    "businesses": [
        "https://nextdoor.com/pages/sf-pro-handyman-san-francisco-ca/",
        "handyman-heroes-berkeley-ca"
    ],
    "maxItems": 60,
    "proxyConfiguration": { "useApifyProxy": true }
}
```

What happens with targets that don't work: a city Nextdoor has no directory for, a business page that was removed or a category with no listings is skipped with a warning in the log, and the run carries on with the other targets. If nothing at all comes back, the run still finishes successfully with 0 results and a status message that says what to change. Only input that can never work, such as a non-Nextdoor URL or a location without a state, stops the run with an error before it starts.

### Output

Real records from a run of `{"category": "Handyman", "location": "San Francisco, CA"}`:

```json
[
    {
        "id": "52876676",
        "name": "George Turner Construction",
        "slug": "george-turner-construction-bolinas-ca",
        "pageUrl": "https://nextdoor.com/page/george-turner-construction-bolinas-ca",
        "phone": "+14152467309",
        "phoneFormatted": "(415) 246-7309",
        "email": "george@georgeturnerconstruction.com",
        "website": "http://georgeturnerconstruction.com",
        "description": "I'm a Bolinas resident, a carpenter by trade with a background in building science and a commitment to fine craftsmanship. ...",
        "fullAddress": "Hawthorne Road, Bolinas, CA",
        "street": "Hawthorne Road",
        "city": "Bolinas",
        "state": "CA",
        "postalCode": "94924",
        "country": "US",
        "primaryCategory": "Carpenter",
        "categories": ["Carpenter", "Handyman", "General contractor"],
        "faveCount": 0,
        "followerCount": 0,
        "openStatus": "Closed until Tue 9:00 AM",
        "openingHours": [
            { "day": "Tuesday", "hours": "9:00 AM–5:00 PM" },
            { "day": "Wednesday", "hours": "9:00 AM–5:00 PM" },
            { "day": "Thursday", "hours": "9:00 AM–5:00 PM" },
            { "day": "Friday", "hours": "9:00 AM–5:00 PM" },
            { "day": "Saturday", "hours": "Closed" },
            { "day": "Sunday", "hours": "Closed" },
            { "day": "Monday", "hours": "9:00 AM–5:00 PM" }
        ],
        "logoUrl": "https://us1-photo.nextdoor.com/business_logo/f6/14/f6148fb6fd1303b2a6f46a877e822968.png",
        "aiSummary": "Local homeowners seeking a skilled carpenter, handyman, or general contractor in Bolinas are encouraged to consider George Turner Construction. ...",
        "searchCategory": "Handyman",
        "searchLocation": "san-francisco--ca",
        "searchRank": 4,
        "scrapedAt": "2026-10-20T00:05:37.000Z",
        "sourceUrl": "https://nextdoor.com/pages/george-turner-construction-bolinas-ca/"
    },
    {
        "id": "33294270",
        "name": "Marin Hearthstone",
        "slug": "marin-hearthstone-muir-beach-ca",
        "pageUrl": "https://nextdoor.com/page/marin-hearthstone-muir-beach-ca",
        "phone": "+14152649615",
        "phoneFormatted": "(415) 264-9615",
        "email": "kathleen.johnston.ca@gmail.com",
        "website": "http://www.marinhearthstone.com",
        "description": "Marin Hearthstone is here to manage your home care needs, whether it be handyman projects, home repairs or small remodels, ...",
        "fullAddress": "Muir Beach, CA",
        "street": null,
        "city": null,
        "state": null,
        "postalCode": null,
        "country": null,
        "primaryCategory": "Handyman",
        "categories": ["Handyman"],
        "faveCount": 0,
        "followerCount": 0,
        "openStatus": null,
        "openingHours": [],
        "logoUrl": "https://us1-photo.nextdoor.com/business_logo/c9/75/c97506f555c73da83d7f191ea5dff1f0.jpg",
        "aiSummary": null,
        "searchCategory": "Handyman",
        "searchLocation": "san-francisco--ca",
        "searchRank": 3,
        "scrapedAt": "2026-10-20T00:05:34.000Z",
        "sourceUrl": "https://nextdoor.com/pages/marin-hearthstone-muir-beach-ca/"
    }
]
```

Long texts are shortened with "..." here for reading; the dataset holds them in full. You can download the dataset as JSON, CSV, Excel, XML, RSS or HTML from the Output tab or through the API.

### How much does it cost to scrape Nextdoor?

Nextdoor Business Scraper is charged per result. You pay only for the businesses returned, and `maxItems` caps how many that can be. Targets that fail or return nothing cost nothing. See the Pricing tab for the current price.

If you set a maximum cost per run in the run options, the scraper stops cleanly when that limit is reached and keeps everything it collected so far; the status message then tells you the limit was hit.

### Use with AI agents (MCP)

Connect Nextdoor Business Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/nextdoor-business-leads-scraper"
        }
    }
}
```

Example prompts:

1. "Find 30 handymen on Nextdoor in San Francisco, CA and give me a table with name, phone and email."
2. "Get the Nextdoor business pages for these three slugs and tell me which ones list a website."
3. "List plumbers Nextdoor shows for Houston, TX, sorted by neighbor faves, and flag the ones with no phone number."

The input schema is written for agents: the fields that need each other (`category` and `location`) say so, `maxItems` is a shared budget across all targets, and a dead or blocked target returns 0 rows with a clear status message instead of an error.

### Integrations and API

Run Nextdoor Business Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/nextdoor-business-leads-scraper").call(
    run_input={"category": "Handyman", "location": "San Francisco, CA", "maxItems": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["phone"], item["email"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/nextdoor-business-leads-scraper').call({
    category: 'Handyman',
    location: 'San Francisco, CA',
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~nextdoor-business-leads-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"category": "Handyman", "location": "San Francisco, CA", "maxItems": 50}'
```

On the Integrations tab you can send results to Make, Zapier, n8n, Google Sheets, Slack or any webhook when a run finishes, and the Schedule feature reruns a search daily or weekly so new local businesses show up in your sheet automatically.

### FAQ

**Do I need a Nextdoor account?**
No. The scraper reads only Nextdoor's public directory and business pages, which load without logging in. It never signs in and never reads neighborhood posts or member profiles.

**Why are some businesses from other towns?**
That is how Nextdoor's directory works: results widen outward from the city you search. A San Francisco search, for example, includes businesses from Muir Beach and Bolinas. Use `searchRank`, `city` or `fullAddress` to filter.

**Why is the phone, email or address empty for some rows?**
Each business chooses what to publish. Sole traders often list only a phone number, and some hide their address. The scraper outputs `null` instead of guessing.

**Why did my run return 0 results?**
The city may not have a Nextdoor directory under that spelling (the status message says so), the category may have no listings there, or Nextdoor may have blocked the requests. Check the spelling, try a nearby larger city or a broader category, or switch to residential proxies.

**How many businesses can one search return?**
As many as Nextdoor lists for that search, up to `maxItems`. The scraper pages through the directory six businesses at a time until Nextdoor reports no more pages.

**Does it work outside the United States?**
No. Nextdoor's public business directory pages exist for US cities only; UK and other country sites don't offer the same public directory.

**How fresh is the data?**
Every run reads the live pages, so the data is as current as Nextdoor's pages at the time of the run (see `scrapedAt`).

**Can I get reviews or recommendation texts?**
Not at the moment. The scraper returns the fave count and, for businesses that have one, Nextdoor's AI summary of recommendations. Open an issue if you need more.

### Is it legal to scrape Nextdoor?

Nextdoor Business Scraper collects only data that businesses publish on public Nextdoor pages, without logging in. Some businesses are sole traders whose page shows a personal name, phone number or email address, so treat the output as personal data where the law says so: you are responsible for using it in line with the GDPR, CCPA, anti-spam rules and Nextdoor's terms. This is not legal advice; ask a lawyer if you're unsure about your use case.

Nextdoor Business Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Nextdoor.

### Related Actors

| Actor | What it does |
|---|---|
| [Local Business Email Finder](https://apify.com/axiomworks/business-email-extractor) | Finds email addresses for local businesses from their websites. |
| [Craigslist Listings Scraper](https://apify.com/axiomworks/craigslist-listings-scraper) | Collects Craigslist listings. |
| [Reddit Leads Scraper](https://apify.com/axiomworks/reddit-lead-miner) | Finds Reddit posts from people asking for products or services. |
| [Google Search SERP Scraper](https://apify.com/axiomworks/google-search-results-scraper) | Scrapes Google search results for any query. |

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `category` (type: `string`):

Business category or service to search for, e.g. 'Handyman', 'Plumber', 'House cleaning' or 'Limpieza'. Needs location too. Returns the businesses Nextdoor lists for that search, in Nextdoor's order (neighbouring towns included). A category Nextdoor has nothing for returns 0 results.

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

US city and state for the category search, e.g. 'San Francisco, CA' or 'Houston, TX' (full state names also work). Needs category too. A city Nextdoor has no directory for ends with 0 results and a message saying so; only US cities are supported.

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

Nextdoor directory URLs such as https://nextdoor.com/topics/handyman/san-francisco/ca/ and/or business URLs such as https://nextdoor.com/pages/<slug>/ or https://nextdoor.com/page/<slug>. us.nextdoor.com works too. A URL that no longer exists is skipped with a warning.

## `businesses` (type: `array`):

Business page URLs or bare slugs, e.g. 'sf-pro-handyman-san-francisco-ca' (the part after /pages/ in the URL). One result per business; removed pages are skipped with a warning. These are fetched before any directory search.

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

Maximum number of businesses to return in total across all targets, 1-10000, default 50. Business pages and slugs are fetched first; directory searches fill what is left. The run stops as soon as this many results are saved, and you are charged only for results returned.

## `proxyConfiguration` (type: `object`):

Proxy to use for requests, default Apify Proxy (datacenter). Switch to residential proxies only if runs get blocked.

## Actor input object example

```json
{
  "category": "Handyman",
  "location": "San Francisco, CA",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "category": "Handyman",
    "location": "San Francisco, CA",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/nextdoor-business-leads-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 = {
    "category": "Handyman",
    "location": "San Francisco, CA",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/nextdoor-business-leads-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 '{
  "category": "Handyman",
  "location": "San Francisco, CA",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call axiomworks/nextdoor-business-leads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/nextdoor-business-leads-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/chG0cuxJYzl0WIgYQ/builds/ip34RsdrQUWRcYDiO/openapi.json
