# Nextdoor Local Leads (`apintrigue/nextdoor-local-leads-pro`) Actor

Phone-verified local business leads from Nextdoor — $5/1k (half the price of $10/1k competing scrapers). Returns name, phone, address, recommendation count, and an unclaimed-page flag tuned for agency lead-gen (GoHighLevel, marketing). Bring-your-own-cookies — no shared credentials, ToS-defensible.

- **URL**: https://apify.com/apintrigue/nextdoor-local-leads-pro.md
- **Developed by:** [Dalton Redden](https://apify.com/apintrigue) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 per qualified business leads

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Nextdoor Local Leads — phone-verified business leads in 60 seconds

**$5 per 1,000 leads · half the price of competing scrapers · free trial included**

Pull phone-verified local business leads from Nextdoor for any service category in any US metro. Auto-flags **unclaimed Nextdoor pages with high recommendation counts** — the perfect signal for cold outreach in lead-generation, agency, and GoHighLevel workflows.

### What you get

Each row in the output dataset:

| Field | Example |
|---|---|
| `category` | `plumber` |
| `name` | Anthony The Plumber |
| `phoneFormatted` | (314) 288-8712 |
| `phoneE164` | +13142888712 |
| `fullAddress` | 5604 Walsh St, Saint Louis, MO 63109 |
| `recommendationCount` | 315 |
| `isUnclaimedLead` | true |
| `description` | Plumbing service based in St. Louis, Missouri… |
| `url` | https://nextdoor.com/page/anthony-the-plumber-saint-louis-mo |

Import directly into GoHighLevel, HubSpot, Apollo, Instantly, Smartlead, Lemlist, or any CRM.

### How to use it (2 minutes the first time)

You provide your own Nextdoor session — that's the only thing that makes this ToS-defensible. There's a 1-click Chrome extension that does this for you:

#### Option A — Chrome extension (recommended for non-technical users)

1. Install **Apily Session Capture** (free): [link to Chrome Web Store — coming soon]
   *Until the Web Store listing is live, install as unpacked extension from the apily/apily monorepo — see `extensions/nextdoor-cookie-capture/README.md`*
2. Log into https://nextdoor.com in any tab
3. Click the extension icon → **Copy session to clipboard**
4. Come back to this actor, click **Start**, paste the clipboard into the **Nextdoor Cookie header** field — paste the `csrftoken` field separately from the JSON
5. Pick your categories (default: plumber, electrician, roofer, landscaper, dentist)
6. Click **Start** → leads appear in the Dataset tab in ~3 minutes

#### Option B — Manual (developers)

1. Open https://nextdoor.com in a logged-in Chrome tab
2. DevTools (Cmd+Opt+I) → **Network** tab → click any request to `nextdoor.com`
3. Right column → **Request Headers** → find the `Cookie:` line → copy the entire value
4. Paste into the **Nextdoor Cookie header** field
5. From the same Cookies list, find `csrftoken` → copy just the value → paste into **csrftoken** field
6. Click **Start**

A captured session typically lasts ~30 days before Nextdoor rotates it.

### Pricing

This actor uses Apify's **Pay per result** model:

- **Free trial**: first run free, up to 25 results
- **After free trial**: $0.005 per dataset item = **$5 per 1,000 leads**

Compare: competing Nextdoor scrapers charge $10+ per 1,000 leads. You're paying half.

For high-volume users (50,000+ leads/month), our direct API at **apily.dev/nextdoor** offers a fixed monthly subscription at ~$0.17 per 1,000 leads. Subscribe there to skip Apify's per-result pricing entirely.

### How to get access — no separate API key needed

**Any Apify account can run this actor.** Apify handles authentication + billing:

- Free Apify account → free trial run
- After the free trial, Apify charges your credit card per result
- You'll see line items on your Apify invoice clearly labeled "Nextdoor Local Leads"

**You only pay for results you actually get.** If the actor returns 0 leads (your session expired, no businesses matched your filter), you pay nothing.

For the direct Apily API (instead of going through Apify), get a key at https://apily.dev/nextdoor — email arrives within 24 hours with a Stripe Checkout link.

### Inputs

| Field | Description | Default |
|---|---|---|
| `categories` | Service categories | `["plumber","electrician","roofer","landscaper","dentist"]` |
| `metroSlug` | Nextdoor city slug | `saint-louis--mo` |
| `enrich` | Add phone/hours/claim status per business | `true` |
| `onlyUnclaimed` | Filter to businesses with no admin claim | `true` |
| `minRecommendations` | Drop pages below this many recommendations | `25` |
| `maxResultsPerCategory` | Cap per category to control cost | `50` |
| `nextdoorCookieHeader` | Your Nextdoor Cookie header | **required** |
| `nextdoorCsrfToken` | Your csrftoken value | **required** |

### How it works

The actor runs Nextdoor's own GraphQL operations as if you were browsing the site — using your session. Two calls per result: one to search for businesses in your category, one to fetch the per-business detail (phone, hours, claim status). Results are filtered by your `onlyUnclaimed` + `minRecommendations` rules, then deduped and pushed to the dataset.

We never store your session. It's used only for this run.

### Limits and caveats

- **One Nextdoor metro per run.** Set `metroSlug` to target a specific market.
- **Session expiry.** Nextdoor sessions last ~30 days.
- **CAPTCHA challenges** are possible at high sustained request rates (50+ req/min from one session). Built-in 200–600ms jitter stays under this.
- **Persisted query hash rotation.** Nextdoor rotates GraphQL hashes every few weeks. If you see `PERSISTED_QUERY_NOT_FOUND`, open an issue — we patch within 24 hours.

### Use cases

- **GoHighLevel agencies** — Find unclaimed pages with 100+ recommendations in your metro. Pitch "we'll manage your Nextdoor + Google" to highly-qualified prospects.
- **Local marketing consultants** — Map every category in a metro. Sell SEO + reputation to businesses with high real-world traction but no online presence.
- **B2B SDRs at home-services SaaS** (Jobber, Housecall Pro, ServiceTitan) — TAM mapping by territory.
- **Independent contractors** — Audit your own market: competition, rec count, claim status.

### Privacy + ToS

This actor uses **your own** Nextdoor session, not ours. Each customer hits Nextdoor as themselves — the only ToS-defensible model.

We do not store, log, or transmit your session anywhere except to Nextdoor itself, scoped to the duration of one run.

The data exposed (business name, phone, address, recommendations) is **already publicly visible** to any logged-in Nextdoor user in the relevant metro. We don't expose private member data or anything behind a paywall.

### Support

- Open an issue on the actor page
- Email: hi@apily.dev
- Direct subscription: apily.dev/nextdoor

### Changelog

- **0.0.2** (2026-05-29) — initial public release
- **0.0.1** — internal development build

# Actor input Schema

## `categories` (type: `array`):

Each value runs a Nextdoor business search (e.g. 'plumber', 'electrician', 'roofer'). Results merged + de-duped per run.
## `nextdoorCookieHeader` (type: `string`):

Paste your full Nextdoor Cookie header. Easiest path: install the Apily Session Capture Chrome extension, log into nextdoor.com, click the extension → copy session → paste here. Or leave blank if you've pre-saved cookies to your account's KVS 'nextdoor-sessions' under key 'cookies'.
## `nextdoorCsrfToken` (type: `string`):

The csrftoken cookie value. Captured automatically by the Chrome extension; for manual capture see your devtools → Application → Cookies → nextdoor.com.
## `enrich` (type: `boolean`):

Calls a second Nextdoor endpoint per business. ~3× the time, ~10× the bytes per result, but the phone is what GHL imports. Recommended.
## `onlyUnclaimed` (type: `boolean`):

Skip businesses whose Nextdoor page has been claimed by an admin. Primary signal for cold outreach.
## `minRecommendations` (type: `integer`):

Drop businesses below this many neighbor recommendations. 25 is the recommended floor for outreach.
## `maxResultsPerCategory` (type: `integer`):

Cap on returned businesses per category. Higher = more leads + more cost (you pay per result). 50 is a good first run.

## Actor input object example

```json
{
  "categories": [
    "plumber",
    "electrician",
    "roofer",
    "landscaper",
    "dentist"
  ],
  "enrich": true,
  "onlyUnclaimed": true,
  "minRecommendations": 25,
  "maxResultsPerCategory": 50
}
````

# 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 = {
    "categories": [
        "plumber",
        "electrician",
        "roofer",
        "landscaper",
        "dentist"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apintrigue/nextdoor-local-leads-pro").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 = { "categories": [
        "plumber",
        "electrician",
        "roofer",
        "landscaper",
        "dentist",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("apintrigue/nextdoor-local-leads-pro").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 '{
  "categories": [
    "plumber",
    "electrician",
    "roofer",
    "landscaper",
    "dentist"
  ]
}' |
apify call apintrigue/nextdoor-local-leads-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apintrigue/nextdoor-local-leads-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nextdoor Local Leads",
        "description": "Phone-verified local business leads from Nextdoor — $5/1k (half the price of $10/1k competing scrapers). Returns name, phone, address, recommendation count, and an unclaimed-page flag tuned for agency lead-gen (GoHighLevel, marketing). Bring-your-own-cookies — no shared credentials, ToS-defensible.",
        "version": "0.0",
        "x-build-id": "UUavsS1GVQxSj26J9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apintrigue~nextdoor-local-leads-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apintrigue-nextdoor-local-leads-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/apintrigue~nextdoor-local-leads-pro/runs": {
            "post": {
                "operationId": "runs-sync-apintrigue-nextdoor-local-leads-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/apintrigue~nextdoor-local-leads-pro/run-sync": {
            "post": {
                "operationId": "run-sync-apintrigue-nextdoor-local-leads-pro",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "categories"
                ],
                "properties": {
                    "categories": {
                        "title": "Service categories to scrape",
                        "type": "array",
                        "description": "Each value runs a Nextdoor business search (e.g. 'plumber', 'electrician', 'roofer'). Results merged + de-duped per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "nextdoorCookieHeader": {
                        "title": "Nextdoor Cookie header (optional if pre-saved)",
                        "type": "string",
                        "description": "Paste your full Nextdoor Cookie header. Easiest path: install the Apily Session Capture Chrome extension, log into nextdoor.com, click the extension → copy session → paste here. Or leave blank if you've pre-saved cookies to your account's KVS 'nextdoor-sessions' under key 'cookies'."
                    },
                    "nextdoorCsrfToken": {
                        "title": "Nextdoor csrftoken (optional if pre-saved)",
                        "type": "string",
                        "description": "The csrftoken cookie value. Captured automatically by the Chrome extension; for manual capture see your devtools → Application → Cookies → nextdoor.com."
                    },
                    "enrich": {
                        "title": "Enrich with phone / hours / claim status",
                        "type": "boolean",
                        "description": "Calls a second Nextdoor endpoint per business. ~3× the time, ~10× the bytes per result, but the phone is what GHL imports. Recommended.",
                        "default": true
                    },
                    "onlyUnclaimed": {
                        "title": "Filter to unclaimed pages only",
                        "type": "boolean",
                        "description": "Skip businesses whose Nextdoor page has been claimed by an admin. Primary signal for cold outreach.",
                        "default": true
                    },
                    "minRecommendations": {
                        "title": "Minimum recommendation count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Drop businesses below this many neighbor recommendations. 25 is the recommended floor for outreach.",
                        "default": 25
                    },
                    "maxResultsPerCategory": {
                        "title": "Max businesses per category",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Cap on returned businesses per category. Higher = more leads + more cost (you pay per result). 50 is a good first run.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
